A walkthrough of running thousands of strategy hypotheses per week through Astra's large context window, with gating, cost accounting, and a synthetic tape to validate discovery versus survivorship.
Adapted from @gemchange_ltd# How to Use GPT-6 Astra to Search Like a Quant Desk. Every Gate, Every Formula, Runnable Code Astra shipped on September 3 with a 1,050,000 token context window and a published rate of $10 per million input tokens and $50 per million output. One strategy idea costs about a third of a cent. Point it at a tape, let it propose all night, wake up to a ranked list. Ten thousand hypotheses a week. No analyst alive does that. Take a market that is pure noise, randomness with a plausible shape. 1. Run 200 random strategies on it. Your best one comes back at a Sharpe of 0.80. 1. Run 1,000 and the best is 0.94. 1. Run 100,000 and it's 1.27, with a smooth equity curve, a drawdown you could live with The maximum of N draws from a zero mean distribution isn't zero. It grows with N. So throughput on its own produces a rising threshold that your real edges then have to clear. Tech, AI and finance news, fast. @entropymarkets (https://x.com/entropymarkets) The useful part of an always on research engine is the accounting that tracks how many times you looked. Same structure as the February piece. One layer at a time, a formula and runnable code for each. The difference is that the machine writes the hypotheses now, so the expensive skill moved from having ideas to turning them down. One thing about the data before we start. The tape is synthetic with exactly one real edge planted in it. On real data you never find out whether a surviving strategy was skill or survivorship, so real data can't tell you whether your discovery engine actually works. A tape where you already know the answer can. The engine has to pass both halves. Find the planted edge, and reject the 1,400 plausible things it also generates. Every number and chart below comes out of that run. ## 1. What the loop looks like Fourteen nights. 1,400 specs proposed, 43 promoted, 5 distinct ideas once you collapse the near duplicates. Each gate runs in cost order, cheapest first, so the expensive tests only ever see candidates that already survived the free ones. Trial count is cumulative over the life of the factory rather than per night, so every hypothesis you've ever run against this data raises the threshold for the next one. Spend is metered per batch, and the number worth watching is cost per surviving distinct idea, not cost per hypothesis. ## 2. What the model is allowed to hand you The obvious move is to let Astra write Python. Don't. That gives you an unbounded surface to audit, and nobody is auditing hypothesis 4,812 at three in the morning. Let it emit a spec instead. A small typed vocabulary of strategy shapes with numeric parameters, executed by your engine, which you already verified once. Now the question isn't "is this code correct", it's "is this spec inside the grammar", and a validator answers that in twenty lines. Never repair a malformed spec. If you repair it you're testing something the model didn't propose and you didn't choose, and you find that out months later when it matters. > The key and from_key pair deserves a word, because getting it wrong cost me an afternoon. An earlier version printed entry_z at two decimals while Spec stored three. Keys are what you log, cluster on and re price from, so every reconstruction quietly rebuilt a slightly different strategy than the one that got promoted. Nothing crashed. Nothing threw. The Sharpe ratios in my audit log just stopped matching the Sharpe ratios of the strategies my audit log named, and I stared at it for an hour before I saw it. Astra supports structured outputs through a JSON schema in response_format, which kills most parse failures. Keep the validator anyway. Function calling needs the Responses endpoint, by the way. Chat Completions rejects any request carrying tools. Run the proposer at temperature near 1.0. This is the one stage where variance is the actual product. Everything downstream kills bad variance for free, so your expensive failure mode is a proposer that keeps handing you the same three ideas in different clothes. If you do want code generation, generate into the grammar instead of around it. Let the model propose a new family, review it once by hand, add it to the engine, and from then on it's a parameter like any other. ## 3. One engine, audited once Every spec goes through the same code. Three rules, and each one is a popular way to invent alpha by accident. The lag lives in exactly one place. Signals get computed from information up to T, positions get held from t+1. Every lookahead bug I've ever found was in code that applied the shift in two places and double counted one of them. Costs get charged on turnover from the very first backtest. A gross Sharpe is not a smaller version of a net Sharpe. It's a different number with a different ranking, and strategies do not keep their order when you go from one to the other. Everything annualises the same way, because the multiple testing arithmetic later compares 1,400 Sharpe ratios, and that comparison means nothing if half of them were computed under a different convention. Write the cost drag out as a formula and the first filter becomes obvious. Let c be the round trip cost per unit of notional you turn over, t the average daily turnover, σd the daily return standard deviation. Set that to zero, solve for c∗, and you get the cost level where the strategy stops working. Print this next to every candidate. A strategy that breaks even at 4bps against an assumed 2bps isn't a strategy, it's a rounding error in your broker's favour. The specs that eventually survived here break even somewhere between 53 and 59bps, which is the kind of margin you want before real money goes anywhere near it. ## 4. How noisy is a Sharpe ratio, really Before you set any threshold you need the sampling distribution of the thing you're thresholding. For returns with per period Sharpe s over T observations, the variance of the estimator is roughly The measured dispersion of 1,680 shuffled timing backtests on this tape, which I build in section 6, is 0.289. Closed form and empirical null agreeing to three decimals is a decent sign that both of them are measuring the same thing. The closed form assumes independent returns, which strategy returns obviously aren't. Lo's correction for autocorrelation out to lag q scales the Sharpe by For the survivor below the first five autocorrelations are -0.033, -0.092, -0.013, +0.026 and +0.009, which gives η(5)=1.093. Mild negative autocorrelation, so the naive Sharpe is slightly conservative here. On a trend strategy with positive autocorrelation η drops below 1 and the naive Sharpe overstates instead. The shuffle based estimate picks all of this up without you having to pick a q, which is one good reason to prefer it. ## 5. The bar Under the null of no skill, the expected maximum Sharpe across N trials, with γ the Euler Mascheroni constant. The curve is flatter than people expect, and that's exactly the problem. Going from 200 trials to 100,000 moves the bar from 0.80 to 1.27. A factor of 500 in effort for 0.47 of Sharpe. You cannot search your way past this, and every extra trial makes the next discovery slightly harder to believe. The second function is the one I actually use in conversation. Best result from the naive 200 spec sweep was a net Sharpe of 0.89, and trials_to_beat says 745. Telling someone "our 0.89 is what 745 random trials produce on this tape" ends an argument faster than any p value, and notice it's a statement about your process rather than about the strategy. ## 6. Effective trials, because forty jitters aren't forty ideas Raw counting has the opposite failure mode. Forty parameter jitters of one idea are one hypothesis tested forty times, and charging yourself forty trials for them sets a threshold nothing can ever clear. Cluster candidates by correlation distance. The top panel is the whole article in one line. The bar climbs from 0.72 on night one to 0.85 on night fourteen. Nothing about the market changed in between. The tape is fixed and was generated before the first spec existed. The only thing that changed is how many times the factory had looked. The bottom panel shows why you need both counts. Raw trials climb straight to 1,400. Effective trials reach 328, and the gap opens from night three onward, which is exactly when refinement kicks in. Clustering cuts both ways and it should. A factory that spams neighbours of one idea gets a low effective count and a low bar, and it also gets a PBO near 0.5, because it stopped searching and started polishing. ## 7. Permutation Last question about any single strategy. Did the timing carry information, or would any schedule with that much exposure have done just as well? Shuffle the positions and leave the returns alone. Shuffling returns destroys the volatility clustering and autocorrelation that made your backtest look good in the first place, which hands you a null that's trivially easy to beat. The +1 in the numerator matters too. Without it you can report p = 0, and no finite experiment supports that claim. Survivors here come back at p = 0.0017, which is the floor for 600 permutations. ## 8. Kill the duplicates, then ask if the survivors die together Without deduplication the factory promoted 241 specs. All 241 were the same mean reversion idea at slightly different parameters. That's one position at 241 times the intended size, described in your risk report as 241 positions. Nobody notices until the day it matters. Running the expensive gates on representatives only is both correct and about ten times faster. Then the portfolio question. My five distinct survivors correlate at +0.305 on daily returns, which sounds fine. Correlation is an average over the whole distribution though, and the part that can hurt you lives in one corner of it. A fitted Student t copula givesν=5, and the lower tail dependence coefficient is ## 9. Put a real one and a fake one side by side Green trades the asset with the planted effect. Red is the best candidate the search found on an asset with no effect in it at all, at a net Sharpe of 0.85. Neither curve looks wrong, and if you'd only ever seen the red one you'd have no reason to doubt it. Nothing in the shape of an equity curve separates these. The separation lives entirely in the tests. Red fails the bar at 0.85, and even back in the naive 200 spec sweep where the bar was only 0.80, it would have died at the deflated Sharpe gate about a second later. ## 10. Capacity, which no backtest will ever tell you Everything above is about whether an edge exists. Capacity is about whether it exists at your size, and a strategy turning over 16.5% of its position every day hits this wall a lot earlier than people expect. Square root law of market impact, with Y an empirical constant usually estimated somewhere between 0.5 and 1. Impact eats your entire per trade alpha when Δ=μtrade, which gives a breakeven participation rate. ## 11. What Astra's benchmarks do and don't predict Read the footnotes in the vendor table while you're there. Claude Fable 5 and 5.1 got excluded from three life science rows because they refuse most of the questions. Some Fable scores on ScreenSpot-Pro and ExploitGym come from Mythos rather than Fable. And Epoch AI, which runs FrontierMath, has disclosed that OpenAI funded its development and has exclusive access to part of it. Here's why none of that predicts your survivor rate. Every benchmark Astra saturates has a verifiable answer sitting right there at evaluation time. A FrontierMath problem has a solution. An ARC game has a win condition. An exploit either lands or it doesn't. A terminal task either completes or it doesn't. That's what makes those benchmarks trainable and that's why progress on them is fast. A strategy proposal has no verifiable answer at proposal time. Verification is the 557 days of Minimum Track Record Length from section 8, and no amount of reasoning effort shortens that by a single day. The model can't check its own work here, because the checking is the part that takes two years. The metric that does predict it is one you have to measure on your own workload. On this run that's 5 over 328, or 1.5%. Track it per proposer and per model, and switch models when that moves, not when a leaderboard does. The companion number is your factory's statistical power. Given a true edge of size SRtrue, the probability it clears the bar is roughly At the bar and dispersion I measured here, true Sharpe P(clears the bar) 0.4 6.2% 0.6 19.8% 0.8 43.8% 1.0 70.4% 1.2 89.0% 1.5 98.8% And the same 1.0 Sharpe edge at four different trial counts, trials bar P(detected) 100 0.72 83% 1,400 0.85 70% 100,000 1.27 18% 8.6M 1.54 3% ## 12. Where Astra fits Given all that, the division of labour is narrower than the marketing suggests. The model is genuinely good at the proposal distribution. Reading a description of a market and suggesting which families and horizons are worth testing on which assets, given what already failed, beats random search. It's also the only lever that raises your survivor rate instead of just your trial count. It's useful for triage afterwards too. Hand it a survivor with its diagnostics and ask what would have to be true for this to be real, which microstructure effect could produce it, which data artifact could explain it. Cheap, and it catches things. It does not touch the statistics. It doesn't compute the bar, it doesn't decide what passes, and it never sees a candidate's equity curve before judging it. Nothing anywhere in this pipeline asks a model whether a strategy is good. ## Sources and methods API facts verified against OpenAI's model page on September 13, 2026. Prices, rate limits and index versions all move, so re check before you build a budget on them. - GPT-6 Astra model page, pricing and rate limits. https://developers.openai.com/api/docs/models/gpt-6-astra - Structured outputs. https://developers.openai.com/api/docs/guides/structured-outputs - Prompt caching. https://developers.openai.com/api/docs/guides/prompt-caching - Batch. https://developers.openai.com/api/docs/guides/batch - Reasoning effort levels. https://developers.openai.com/api/docs/guides/reasoning - ARC Prize verification of both ARC-AGI-3 harness results. https://arcprize.org/blog/astra - OpenAI announcement tables, cross checked. https://www.vellum.ai/blog/gpt-6-astra-benchmarks-explained - Independent index comparison. https://www.mindstudio.ai/blog/gpt-6-astra-benchmarks-analysis - Artificial Analysis Intelligence Index methodology. https://artificialanalysis.ai/evaluations/artificial-analysis-intelligence-index - Index v4.2 interim revision, September 4, 2026. https://www.explainx.ai/blog/artificial-analysis-intelligence-index-v4-2-september-2026
