u/drykilo

I'm a student at NYU studying to get into quant. I wanted to share my experience with an automatic capital allocator I designed. Last year I built a router that picks the best strategy for a given market and sizes it with Fractional Kelly Criterion in DeFi. Like an automatic mini allocator. I thought it would be a good way to actually learn how position sizing and edge estimation work instead of just reading about them.

I had maybe 5 strategies I'd written running on ETH paper data, and the router would pick whichever had the best recent risk-adjusted return and size it with fractional Kelly.

The first thing I learned: most strategies don't have edge.

Out of maybe 30 strategies I tested initially, 1 or 2 had any real edge after costs (or so I thought :), they got absolutely destroyed after realistic trading fees and friction). The rest were noise, though diversified. Crypto round-trips are like 6-7 bps per side depending on the pair, and if the edge is 10 bps per trade, I'm losing money.

A typical backtest result, it with performance by regime. It crushed in Crisis (+1440 bps) but bled out in High Vol (-1398 bps), ending at -245 bps net

I thought AI could help me with this and tried to improve the existing strategies with it. It gave worse results. It overcomplicates strategies a lot. What I surprisingly found is that dumb and small code works much better than complex models that overfit in the real world. And the tiny "dumb" strategies with on-chain data proved to be much much better than the rest, some even profitable on 2 years of trading data!

I added a cost-adjusted validation stage and regime decomposition. Seeing where a strategy bleeds (chop vs trend vs crisis) helped explain why backtests fail live.

The second thing: the router was actually decent.

Once I had enough strategies, I built a perfect-foresight benchmark (an oracle that picks the best strategy for each window, kinda like God or Congress :) to see if my allocator was doing anything.

To test it properly, I split 24 months of data into three windows: 12 months to train the router, 6 months to validate, and a 7-month true hold-out (May–Oct 2025) that I never touched until the very end. The hold-out is where I report all final numbers.

On the hold-out, at matched volume (~8 trades/day for both the router and the oracle), here's how they compared:

Policy	Trades/day	Gross bps/tr	Net bps/tr	Total return	Sharpe	Max DD
NULL (random 15%)	77.9	−0.47	−11.31	−61.1%	−26.89	61.1%
My router	8.6	+6.10	−4.32	−7.3%	−3.51	8.7%
Oracle (perfect foresight)	8.8	+7.21	−2.42	−5.3%	−1.16	7.8%

The router captures about 86% of the perfect-foresight ceiling (95% lower bound ≈ 39% via bootstrap). The oracle knows each bot's true full-sample edge in advance, my router doesn't. The gap between them is 1.1 bps. That's how much imperfect bot-quality estimation costs vs omniscience.

The honest part: the router is still net-negative (−4.32 bps/trade after ~10 bps friction) (So is the Oracle but it is due to the roster of bots being bad overall, though they are diversified). The selection edge is real (+6.10 gross vs NULL's −0.47), but it's not large enough to clear costs yet. A 40-60% friction reduction (better execution, TWAP, order netting) would flip it net-positive.

What I found most interesting: even the oracle with perfect knowledge of every bot's true edge can't profit with volume on this roster. Of 87 bots, exactly 1 had genuine positive net edge in the hold-out window. This is a bot-supply problem, not a routing problem.

Also worth noting: the router's max drawdown is 8.7% vs NULL's 61.1%. The risk management (Kelly sizing, persistence veto, trend gate) cuts drawdown by 85% vs random and it loses money in a controlled way while selecting good trades.

I also found that best-available edge scales with roster size at r=0.986 against extreme-value theory (the √(2·ln N) scaling). The allocator wasn't the bottleneck, the roster quality is.

The network effect (this is the part I'm most excited about):

I wanted to know does adding more strategies like drip feeding actually help or would I just be diluting? I subsampled my 93-bot roster down to smaller sizes (10, 20, 35, 50, 70, 93 bots) and re-ran the entire pipeline, simulating a gradual influx.

The best bot's true edge climbs monotonically as you add more: −6 bps at 10 bots → +3 bps at 93 bots. When I fit that against extreme-value theory (that predicts the maximum of N random draws), the correlation is 0.986! Almost a perfect match. More strategies = higher ceiling, and it follows theory almost exactly.

The router only captures that rising ceiling if you use an absolute quality bar, not a relative percentile. If you filter "top 30% of whatever roster exists," the router's edge stays flat no matter how many bots you add. If you use a fixed quality threshold instead, the router's edge climbs with the roster. Extrapolating (with caveats, this is beyond the range I actually tested): ~+10 bps net edge at 1,000 bots, ~+16 bps at 10,000.

That's the quantitative argument for why roster growth matters more than router tuning. Every good, diversified strategy added raises the ceiling for everyone.

How the project evolved:

The router dynamically updates its own parameters as the roster changes but it does this by offline re-tuning not via real-time ML yet. The reason is that at 93 bots and ~8 trades/day, you can't detect effects smaller than ~47 bps with any statistical power. A real-time ML model would just be fitting noise. It also has self-capacity awareness so it doesn't frontrun itself.

Once the router worked, I began noting down everything scientifically and made a bunch of changes to my initial project. I added real-time on-chain signals with historical data as well. The project grew to include:

• 6 active domains: ETH, BTC, SOL direction + scalp (6 more registered but dormant: yield, tail hedge, liquidation arb, memecoins (this one might be insanely hard to get right tbh))
• 5-stage validation pipeline: static check, in-sample, out-of-sample, walk-forward, cost-adjusted
• Strategy sandbox: write Python strategies with custom stop-loss, take-profit, and trailing stops
• Arena & OpenLeaderboard: strategies that pass validation compete on live paper data for capital allocation
• Non-custodial design: API keys stay encrypted; the router handles execution routing but never holds custody of funds

Where it is now:

• 80+ default strategies running on live paper data (real prices, paper execution not great bots:)
• 3 are currently net profitable (best: ETH Squeeze Breakout, +184bps, 73% win rate). The rest are negative.
• Nobody can see any strategy code it runs in a confidential VM, and there are automatic payouts for the best strategies bi-weekly.

A standard Python strategy with declared SL/TP and data from a feature catalog like orderbook imbalance or cross-asset momentum, etc

What I'm looking for: I'm posting here because this subreddit has people with real domain expertise, and I'd love your feedback:

1. Does the router/Kelly allocation approach make sense, or is there an obvious flaw I haven't seen?
2. Is capturing ~86% of a foresight ceiling considered typical or decent for this setup (on 7-12 trades/day, on my quite diversified roster of bots)?
3. What features would you actually need in a Python strategy sandbox to make it worth testing your own models?

I'm a student and not charging for anything. Happy to share more details in the comments if anyone's curious.

TL;DR: I'm a student at NYU. Built a router that allocates capital across Python trading strategies using Fractional Kelly for DeFi. Tested 80+ strategies on 24 months of data, most have no edge after costs (shocking!! I know). On a 7-month true hold-out, the router captures 86% of a perfect-foresight ceiling at matched volume (+6.10 vs +7.21 gross bps/trade), with 8.7% max drawdown vs random's 61.1%. Found a network effect: best-available edge scales with roster size at r=0.986 vs extreme-value theory so, more strategies = higher ceiling for everyone. Would love feedback from people who actually know what they're doing. Thank you!

I'm a student at NYU studying to get into quant. I wanted to share my experience with an automatic capital allocator I designed. Last year I built a router that picks the best strategy for a given market and sizes it with Fractional Kelly Criterion. I thought it would be a good way to actually learn how position sizing and edge estimation work instead of just reading about them.

I had maybe 5 strategies I wrote running on ETH paper data and the router would pick whichever had the best recent risk-adjusted return and size it with fractional Kelly.

The first thing I learned about trading bots: Most strategies do not have edge.

Out of maybe 30 strategies I tested initially, 1 or 2 had any real edge after costs (or so I thought :), they got absolutely destroyed after realistic trading fees and friction). The rest were noise, though diversified. Crypto round-trips are like 6-7 bps per side depending on the pair, and if the edge is 10 bps per trade, I'm losing money.

A typical backtest result, it with performance by regime. It crushed in Crisis (+1440 bps) but bled out in High Vol (-1398 bps), ending at -245 bps net

I thought AI could help me with this and tried to improve the existing strategies with it. It gave worse results, it overcomplicates strategies a lot. What I surprisingly found is that dumb and small code works much better than complex models that overfit in the real world. And the tiny "dumb" strategies with on-chain data proved to be much much better than the rest, some even profitable on 2 years of trading data!

The second thing: the router was actually decent.

Once I had enough strategies, I built a perfect-foresight benchmark (an oracle that picks the best strategy for each window, kinda like God or Congress :) to see if my allocator was doing anything.

The router captures about 86% of the perfect-foresight ceiling (95% lower bound ≈ 39%) and this is on the same volume of trading, around 7-12 trades per day on both the oracle and my router on a very diversified roster of bots. I also found that best available edge scales with roster size at r=0.986 against extreme-value theory, the √(2*ln N) scaling.

This mechanism could technically make money, but the allocator wasn't the bottleneck, the roster quality was.

The network effect (this is the part I'm most excited about):

I wanted to know does adding more strategies like drip feeding actually help or would I just be diluting? I subsampled my 93-bot roster down to smaller sizes (10, 20, 35, 50, 70, 93 bots) and re-ran the entire pipeline from scratch on each one, simulating a gradual influx.

The best bot's true edge climbs monotonically as you add more: −6 bps at 10 bots → +3 bps at 93 bots. When I fit that against extreme-value theory that predicts the maximum of N random draws), the correlation is 0.986… almost a perfect match. More strategies = higher ceiling and it follows theory almost exactly. So I updated the router to auto-upgrade itself based on influx of new bots.

The router only captures that rising ceiling if you use an absolute quality bar, not a relative percentile. If you filter "top 30% of whatever roster exists," the router's edge stays flat no matter how many bots you add because the percentile just re-centers on whatever population is there. If you use a fixed quality threshold instead, the router's edge climbs with the roster obviously. Extrapolating (with caveats, this is beyond the range I actually tested): ~+10 bps net edge at 1,000 bots, ~+16 bps at 10,000.

Every good, diversified strategy added raises the ceiling for everyone in this system.

A standard Python strategy with declared SL/TP and data from a feature catalog like orderbook imbalance or cross-asset momentum, etc...

The router dynamically updates its own parameters as the roster changes but it does this via offline re-tuning on a cadence, not via real-time ML yet. The reason is that at 93 bots and ~8 trades/day, you can't detect effects smaller than ~47 bps with any statistical power. A real-time ML model would just be fitting noise. It also has self-capacity awareness so it doesn't frontrun itself.

Once the router worked, I began noting down everything scientifically and made a bunch of changes to my initial project. I added real-time on-chain data with historical data as well. These became obvious next steps:

• 6 active domains where bots compete: ETH, BTC, SOL direction + scalp (6 more registered but dormant, yield, tail hedge, liquidation arb, memecoins (This one might be insanely hard to get right tbh and would need the most external data)).
• 5-stage validation pipeline: static check, in-sample, out-of-sample, walk-forward, cost-adjusted
• Custom stop-loss, take-profit and trailing stops
• Arena & Open Leaderboard: strategies that pass validation compete on live paper data for capital allocation. The leaderboard serving as the Router's initial ranking system for bots.

Router routing capital across active domains. Also I made a Dummy \"Hedge Fund\" called DaBronjame2 which was meant to be a fund of a collection of only bad bots which traded only during Neutral markets and scalp in them. Shouldn't have played with 10x leverage before :)

Where it is now:

• 80+ default strategies running on live paper data (real prices, paper execution, Not great bots :)
• 3 are currently net profitable (best: ETH Squeeze Breakout, +184bps, 73% win rate). The rest are negative. However, the router does manage to pick the ones on a winning streak frequently.

What I'm looking for: I'm posting here because this subreddit has people with real domain expertise:

1. Does the router / Kelly allocation approach make sense, or is there an obvious flaw I haven't seen?
2. Is capturing ~86% of a foresight ceiling considered typical or decent for this setup (on a volume of 7-12 trades per day, on my quite diversified roster of bots)? How do I increase the efficiency of the router?

Happy to share more details in the comments if anyone's curious.

TL;DR:
Built a router that allocates capital across Python trading strategies using Fractional Kelly. Tested 80+ strategies on live paper data, most have no edge after costs (shocking!! I know). The router captures ~86% of a perfect-foresight ceiling at matched volume. Found a network effect: best-available edge scales with roster size at r=0.986 vs extreme-value theory... so more strategies = higher ceiling for everyone. It snowballed into a full creator platform (5-stage validation, Open arena, non-custodial, confidential VMs for strategy privacy, etc). Happy to answer any questions or provide more details!

I'm a student at NYU studying to get into quant. I wanted to share my experience with an automatic capital allocator I designed. Last year I built a router that picks the best strategy for a given market and sizes it with Fractional Kelly Criterion in DeFi. Like an automatic mini allocator. I thought it would be a good way to actually learn how position sizing and edge estimation work instead of just reading about them.

I had maybe 5 strategies I'd written running on ETH paper data, and the router would pick whichever had the best recent risk-adjusted return and size it with fractional Kelly.

The first thing I learned: most strategies don't have edge.

Out of maybe 30 strategies I tested initially, 1 or 2 had any real edge after costs (or so I thought :), they got absolutely destroyed after realistic trading fees and friction). The rest were noise, though diversified. Crypto round-trips are like 6-7 bps per side depending on the pair, and if the edge is 10 bps per trade, I'm losing money.

A typical backtest result, it with performance by regime. It crushed in Crisis (+1440 bps) but bled out in High Vol (-1398 bps), ending at -245 bps net

I thought AI could help me with this and tried to improve the existing strategies with it. It gave worse results. It overcomplicates strategies a lot. What I surprisingly found is that dumb and small code works much better than complex models that overfit in the real world. And the tiny "dumb" strategies with on-chain data proved to be much much better than the rest, some even profitable on 2 years of trading data!

I added a cost-adjusted validation stage and regime decomposition. Seeing where a strategy bleeds (chop vs trend vs crisis) helped explain why backtests fail live.

The second thing: the router was actually decent.

Once I had enough strategies, I built a perfect-foresight benchmark (an oracle that picks the best strategy for each window, kinda like God or Congress :) to see if my allocator was doing anything.

To test it properly, I split 24 months of data into three windows: 12 months to train the router, 6 months to validate, and a 7-month true hold-out (May–Oct 2025) that I never touched until the very end. The hold-out is where I report all final numbers.

On the hold-out, at matched volume (~8 trades/day for both the router and the oracle), here's how they compared:

Policy	Trades/day	Gross bps/tr	Net bps/tr	Total return	Sharpe	Max DD
NULL (random 15%)	77.9	−0.47	−11.31	−61.1%	−26.89	61.1%
My router	8.6	+6.10	−4.32	−7.3%	−3.51	8.7%
Oracle (perfect foresight)	8.8	+7.21	−2.42	−5.3%	−1.16	7.8%

The router captures about 86% of the perfect-foresight ceiling (95% lower bound ≈ 39% via bootstrap). The oracle knows each bot's true full-sample edge in advance, my router doesn't. The gap between them is 1.1 bps. That's how much imperfect bot-quality estimation costs vs omniscience.

The honest part: the router is still net-negative (−4.32 bps/trade after ~10 bps friction) (So is the Oracle but it is due to the roster of bots being bad overall, though they are diversified). The selection edge is real (+6.10 gross vs NULL's −0.47), but it's not large enough to clear costs yet. A 40-60% friction reduction (better execution, TWAP, order netting) would flip it net-positive.

What I found most interesting: even the oracle with perfect knowledge of every bot's true edge can't profit with volume on this roster. Of 87 bots, exactly 1 had genuine positive net edge in the hold-out window. This is a bot-supply problem, not a routing problem.

Also worth noting: the router's max drawdown is 8.7% vs NULL's 61.1%. The risk management (Kelly sizing, persistence veto, trend gate) cuts drawdown by 85% vs random and it loses money in a controlled way while selecting good trades.

I also found that best-available edge scales with roster size at r=0.986 against extreme-value theory (the √(2·ln N) scaling). The allocator wasn't the bottleneck, the roster quality is.

The network effect (this is the part I'm most excited about):

I wanted to know does adding more strategies like drip feeding actually help or would I just be diluting? I subsampled my 93-bot roster down to smaller sizes (10, 20, 35, 50, 70, 93 bots) and re-ran the entire pipeline, simulating a gradual influx.

The best bot's true edge climbs monotonically as you add more: −6 bps at 10 bots → +3 bps at 93 bots. When I fit that against extreme-value theory (that predicts the maximum of N random draws), the correlation is 0.986! Almost a perfect match. More strategies = higher ceiling, and it follows theory almost exactly.

The router only captures that rising ceiling if you use an absolute quality bar, not a relative percentile. If you filter "top 30% of whatever roster exists," the router's edge stays flat no matter how many bots you add. If you use a fixed quality threshold instead, the router's edge climbs with the roster. Extrapolating (with caveats, this is beyond the range I actually tested): ~+10 bps net edge at 1,000 bots, ~+16 bps at 10,000.

That's the quantitative argument for why roster growth matters more than router tuning. Every good, diversified strategy added raises the ceiling for everyone.

How the project evolved:

The router dynamically updates its own parameters as the roster changes but it does this by offline re-tuning not via real-time ML yet. The reason is that at 93 bots and ~8 trades/day, you can't detect effects smaller than ~47 bps with any statistical power. A real-time ML model would just be fitting noise. It also has self-capacity awareness so it doesn't frontrun itself.

Once the router worked, I began noting down everything scientifically and made a bunch of changes to my initial project. I added real-time on-chain signals with historical data as well. The project grew to include:

• 6 active domains: ETH, BTC, SOL direction + scalp (6 more registered but dormant: yield, tail hedge, liquidation arb, memecoins (this one might be insanely hard to get right tbh))
• 5-stage validation pipeline: static check, in-sample, out-of-sample, walk-forward, cost-adjusted
• Strategy sandbox: write Python strategies with custom stop-loss, take-profit, and trailing stops
• Arena & OpenLeaderboard: strategies that pass validation compete on live paper data for capital allocation
• Non-custodial design: API keys stay encrypted; the router handles execution routing but never holds custody of funds

Where it is now:

• 80+ default strategies running on live paper data (real prices, paper execution not great bots:)
• 3 are currently net profitable (best: ETH Squeeze Breakout, +184bps, 73% win rate). The rest are negative.
• Nobody can see any strategy code it runs in a confidential VM, and there are automatic payouts for the best strategies bi-weekly.

https://preview.redd.it/fus4ccw05ckh1.png?width=1918&format=png&auto=webp&s=1f48886acceda494c8f2da2bb5c58c6ea855a9e8

What I'm looking for: I'm posting here because this subreddit has people with real domain expertise, and I'd love your feedback:

1. Does the router/Kelly allocation approach make sense, or is there an obvious flaw I haven't seen?
2. Is capturing ~86% of a foresight ceiling considered typical or decent for this setup (on 7-12 trades/day, on my quite diversified roster of bots)?
3. What features would you actually need in a Python strategy sandbox to make it worth testing your own models?

I'm a student and not charging for anything. Happy to share more details in the comments if anyone's curious.

TL;DR: I'm a student at NYU. Built a router that allocates capital across Python trading strategies using Fractional Kelly for DeFi. Tested 80+ strategies on 24 months of data, most have no edge after costs (shocking!! I know). On a 7-month true hold-out, the router captures 86% of a perfect-foresight ceiling at matched volume (+6.10 vs +7.21 gross bps/trade), with 8.7% max drawdown vs random's 61.1%. Found a network effect: best-available edge scales with roster size at r=0.986 vs extreme-value theory so, more strategies = higher ceiling for everyone. Would love feedback from people who actually know what they're doing. Thank you!

The work is amateur! Thank you.

I can share a simpler version too, using only high school math and a more intuitive explanation, but less rigorous

[Basel Problem](https://nyu-0o6yd4.filedrop.me/s/a73eee83-d499-4333-ae52-2880a41b6551)

I'm a student at NYU studying to get into quant. Last year I started a project that I thought would be small, building a router that picks the best strategy for a given market in DeFi and sizes it with Fractional Kelly Criterion. Like an automatic mini allocator. I thought it would be a good way to actually learn how position sizing and edge estimation work instead of just reading about them.
I had maybe 5 strategies I wrote running on ETH paper data and the router would pick whichever had the best recent risk-adjusted return and size it with fractional Kelly.
The first thing I learned: most strategies do not have edge.
Out of maybe 30 strategies I tested initially, 1 or 2 had any real edge after costs (or so I thought :), they got absolutely destroyed after realistic trading fees and friction). The rest were noise, though diversified. Crypto round-trips are like 6-7 bps per side depending on the pair, and if the edge is 10 bps per trade, I'm losing money.

A typical backtest result in the studio, it separates performance by regime. It crushed in Crisis (+1440 bps) but bled out in High Vol (-1398 bps), ending at -245 bps net. It gets flagged as Noise.

I thought AI could help me with this and tried to improve the existing strategies with it. It gave worse results, it overcomplicates strategies a lot. What I surprisingly found is that dumb and small code works much better than overfit models in the real world. And the tiny "dumb" strategies with on-chain data proved to be much much better than the rest, some even profitable on 2 years of trading data!
I added a cost-adjusted validation stage and regime decomposition. Seeing where a strategy bleeds (chop vs trend vs crisis) helped explain why backtests fail live.
The second thing: the router was actually decent.
Once I had enough strategies, I built a perfect-foresight benchmark (an oracle that picks the best strategy for each window, kinda like God or Congress :) to see if my allocator was doing anything.
The router captures about 86% of the perfect-foresight ceiling (95% lower bound ≈ 39%) and this is on the same volume of trading, around 7-12 trades per day on both the oracle and my router on a very diversified roster of bots. I also found that best available edge scales with roster size at r=0.986 against extreme-value theory (the √(2·ln N) scaling).

This mechanism could technically make money, but the allocator wasn't the bottleneck, the roster quality was.
The network effect (this is the part I'm most excited about):
I wanted to know does adding more strategies actually help or am I just diluting? I subsampled my 93-bot roster down to smaller sizes (10, 20, 35, 50, 70, 93 bots) and re-ran the entire pipeline from scratch on each one.
The best bot's true edge climbs monotonically as you add more: −6 bps at 10 bots → +3 bps at 93 bots. When I fit that against extreme-value theory (the √(2·ln N) scaling that predicts the maximum of N random draws), the correlation is 0.986… almost a perfect match. More strategies = higher ceiling, and it follows theory almost exactly. 

But here's the catch: the router only captures that rising ceiling if you use an absolute quality bar, not a relative percentile. If you filter "top 30% of whatever roster exists," the router's edge stays flat no matter how many bots you add because the percentile just re-centers on whatever population is there. If you use a fixed quality threshold instead, the router's edge climbs with the roster. Extrapolating (with caveats, this is beyond the range I actually tested): ~+10 bps net edge at 1,000 bots, ~+16 bps at 10,000.
That's the quantitative argument for why I want creators :) Every good strategy added raises the ceiling for everyone.
How it expanded into a creator studio:

\"The web IDE where you can write standard Python strategies with declared SL/TP and pull from a feature catalog like orderbook imbalance or cross-asset momentum.\"

The router dynamically updates its own parameters as the roster changes but it does this via offline re-tuning on a cadence, not via real-time ML yet. The reason is that at 93 bots and ~8 trades/day, you can't detect effects smaller than ~47 bps with any statistical power. A real-time ML model would just be fitting noise. It also has self-capacity awareness so it doesn't frontrun itself.

Once the router worked, I began noting down everything scientifically and made a bunch of changes to my initial project. I added real-time on-chain data feeds with historical data as well. These became obvious next steps:

• 6 active domains: ETH, BTC, SOL direction + scalp (6 more registered but dormant, yield, tail hedge, liquidation arb, memcoins (This one might be insanely hard to get right tbh), etc, waiting for strategies)
• 5-stage validation pipeline: static check, in-sample, out-of-sample, walk-forward, cost-adjusted
• Creator IDE: write Python strategies with custom stop-loss, take-profit, and trailing stops directly in the browser or via API/MCP
• Arena & Leaderboard: strategies that pass validation compete on live paper data for capital allocation
• Non-custodial: API keys stay encrypted in user vaults

\"Live portfolio dashboard routing capital across active domains. Also I made a Dummy \"Hedge Fund\" called DaBronjame2 which was meant to be a fund of a collection of only bad bots which traded only during Neutral markets and scalp in them. Shouldn't have played with 20x leverage before :)\"

Where it is now:

• 80+ default strategies running on live paper data (real prices, paper execution, Not great bots:)
• 3 are currently net profitable (best: ETH Squeeze Breakout, +184bps, 73% win rate). The rest are negative.

What I'm looking for: I'm posting here because this subreddit has people with real domain expertise, and I'd love your feedback:

1. Does the router / Kelly allocation approach make sense, or is there an obvious flaw I haven't seen?
2. Is capturing ~86% of a foresight ceiling considered typical or decent for this setup (on a volume of 7-12 trades per day, on my quite diversified roster of bots)?
3. What features would you actually need in a Python strategy sandbox to make it worth testing your own models?

I'm a student and not charging for anything. Oh, and importantly nobody can see any strategy code, it runs in a confidential VM! Happy to share more details if anyone's curious.

TL;DR:
I'm a student at NYU. Built a router that allocates capital across Python trading strategies using Fractional Kelly for DeFi. Tested 80+ strategies on live paper data, most have no edge after costs (shocking!! I know). The router captures ~86% of a perfect-foresight ceiling at matched volume. Found a network effect: best-available edge scales with roster size at r=0.986 vs extreme-value theory... so more strategies = higher ceiling for everyone. It snowballed into a full creator platform (5-stage validation, arena, non-custodial, confidential VMs for strategy privacy and more). Would love feedback from people who actually know what they're doing. Does the approach make sense, is 86% of ceiling decent, what would you need in a Python strategy sandbox?

Why is there no correct information on the door heights(measured from inside) of the MTA trains?? Google just says 6'3 even though there's definitely a difference in heights between the older trains, like the R, W, N, etc(the ones without the digital displays inside) and the newer models like A, C, M, J, etc.?

Personally, my head literally touches or brushes the top of the doorway when I'm standing in it. But on the newer cars (M, J, A, C, etc) it feels like I have several inches of clearance above my head standing in the exact same spot with the same shoes (and also time of day)

Does anyone know the correct heights, and could anyone please measure the inside doorway height on both the older and newer trains with a good measuring tape?

Hiii does anyone know how I can join the NYU Blockchain club? I think they had a discord or something but I can't find the link to join :( btw I've taken two courses in Blockchain and DeFi at Stern and loved it

I just finished Requiem yesterday, and honestly the difference in pacing, aesthetic and overall quality between the initial care center and Racoon city is so jarring.

Everything in the care center was excellent like in RE Village. The atmosphere, levels, tension and even the item fetch objectives all worked really well because everything felt so polished. Every room actually had identity.

I want to love the game so much the manor was so fucking good 😭😭😭.

Things took a nosedive in Racoon city for me. RC is sooo fucking boring and annoying, like the detonators parts collection was seriously very boring and the padding for the sake of padding, so unnecessary. Though the game performance was excellent in RC.

I just clocked out of the story after a few hours in RC and I just wanted it to end so bad so I can't genuinely comment about the quality of the story.

It's very obvious they just stitched together two games, one polished but without content and another with a lot of content but no polish or aesthetic relevance.

The part where you play as Chloe also didn’t really work for me. It wasn't scary and felt shoehorned in😕

It is also frustrating to not see many YouTube reviewers pointing this out. It feels like a lot of reviews just accept the whole thing without questioning how different the game becomes.

In comparison, Resident Evil Village felt much more consistent to me. Even when it changed things up at the end, the shifts didn’t feel this jarring and the game maintained its aesthetic and momentum so much better.

I’m hugely disappointed because the first half showed how great this game could have been. It could have been so peak😭😭😭.

Wifi's been down since like 2 hours and it's not like the wifi works great normally. Optimum is absolutely terrible! Is anyone else experiencing this??

Hi I'm building an open-source platform for robotics and would love to interact with anyone from robotics labs at NYU. I've emailed quite a lot of people but they never respond 😕 I have to validate my project by doing research at these labs. Would love any kind of help!

A map based visualizer for subreddit wars, can even include fanbase wars or any kind of virtual wars, would be very cool tbh