I had an AI grade its own trading strategies. Five rounds later, the first attempt was still the best.

The Finding

Why the first round won, and why that's a systems problem

The pattern is obvious once you see it laid out: Round 1 set the high-water mark, and every subsequent round tried to improve on what it remembered most recently, which was never Round 1.

Round 2's prompt knew Round 1. Round 3's prompt knew Rounds 1–2. But by Round 4, the seed was carrying the context from the last two rounds, not all of them, and critically, not weighted toward the highest-scoring one.

But there's a deeper problem. The evaluator itself was part of the drift. I tuned it to push for 100% annual returns, and it did exactly that. Every round, it said "higher returns." The model heard that signal and kept reaching further from what had actually worked. The evaluator's own incentive structure rewarded ambition over stability. It was grading correctly according to the rubric I wrote, but the rubric's pressure created the exact drift it was supposed to prevent.

Seeding from the most recent round only is not optimization. It's drift with extra steps. The evaluator, essentially, by Round 5

The fix is structural: the seed should always include the highest-scoring round's full context as the floor, regardless of recency. If Round 1 scored 71 and Round 4 scored 51, Round 5's prompt should be anchored to Round 1, not Round 4. The evaluator's direction should point away from the best baseline, not away from the most recent failure.

That's not a model problem. It's an algorithmic problem. The tools exist to make incremental changes (you can seed the next round with "take the Round 1 Iron Condor and adjust the delta from 0.2 to 0.15"). But the way I ran this experiment, the evaluator just said "push for higher returns" and the model interpreted that as permission to start over. It didn't tweak the Iron Condor's parameters. It abandoned Iron Condors entirely.

The same model that produced Round 5's 27 is the one that produced Round 1's 71. The core concept works. The way I assembled the seeds was too naive.

Why I stopped

This experiment cost $676. I'm not done, but I need to be honest about why I paused.

Before real money goes into the $25,000 Public Portfolio, I need a strategy that scores high enough to justify the risk. I'm working on this every day. I built the agent system, built the evaluator, and proved the optimization loop works conceptually. What I haven't solved yet is the cost.

This experiment used the most naive algorithm possible (try something, grade it, try again) and it cost me $676 in a single day. Running the eleven-model bakeoff, same-day grading, and these five optimization rounds came to over 700 million tokens. That was enough to trigger the platform's LLM circuit breaker once.

I used cheap models. Gemini Flash is 2 tokens per call on NexusTrade. And it still cost $676 in a single day. I need to reach a score I'm confident deploying with real money. Once I do, the strategy goes live on the public portfolio. But I can't keep burning $500+ per research sprint on an algorithm this naive. I need either a smarter algorithm or my own dedicated GPU to absorb the inference costs.

What comes next

What I'd do differently (when I can afford to run it again)

Fix the seeding. The obvious software fix: anchor every round's seed to the highest-scoring round, not the most recent one. If Round 1 scored 71 and Round 4 scored 51, Round 5's prompt should be built from Round 1's context, not Round 4's. The evaluator's direction should push the model to explore beyond the best baseline, not recover from the latest failure.

Keep a population, not a single thread. Right now, each round produces one strategy and the next round tries to improve on it. That's a Markov chain: the model only sees where it just was. A better approach would be to maintain a small population of candidate strategies across rounds, similar to evolutionary optimization. Seed each new round with the top 2 or 3 performers from the full history, not just the latest attempt.

Automate the loop. I assembled each round's seed by hand. That's fine for 5 rounds, but for 30 you'd want a script that reads the evaluator output, builds the next prompt, and launches the agent automatically. Cursor or Claude Code with the NexusTrade MCP server could manage the entire loop: create the agent, poll for completion, run the evaluator, build the next seed, repeat.

Each round is a complete labeled record: the prompt, every tool call, every decision, the strategy, the backtest results, and a structured second-AI verdict. That's not debugging data. It's training data.

Think about what these five rounds actually produced. Five full agent traces with structured evaluations. Labeled examples of what a good strategy looks like (Round 1) and what drift looks like (Rounds 3-5). Ground-truth reward signals tied to real backtest outcomes. This is exactly the kind of data you need to fine-tune a model that's better at this task than the general-purpose one I started with. Every failed round teaches the next version of the model what to avoid. Every successful round teaches it what to replicate.

That's the long game. The optimization loop isn't just searching for a strategy. It's generating the dataset that makes the next loop cheaper and smarter. I'm building toward a model called Aurora that will be trained on exactly this kind of data: proprietary agent traces, labeled by a goal-oriented evaluator, grounded in real backtest results from a real trading engine.

I'm going to implement these fixes and run it again. When I do, the results will show up on the $25,000 Public Portfolio, where every strategy, every deployment decision, and every P&L number is tracked publicly. If you want to watch that happen in real time, or run your own optimization loop, sign up.

Replicate it

How to run this yourself

Everything in this experiment is reproducible with a NexusTrade account and an MCP client (Cursor, Claude Desktop, or Claude Code). Connect to the NexusTrade MCP server, and the five-step loop becomes five tool calls:

Step 5 is where your judgment lives. The platform gives you the raw materials: scores, strategy summaries, evaluator direction. You decide how to assemble the next round's context. That's the seam between automation and human oversight.

Try step 1 right now. Hit the button to call the API:

POST /api/agent
{
  "messages": [{ "sender": "User", "content": "What AI stocks have the highest market cap?" }],
  "maxIterations": 5,
  "automationMode": "automated"
}

Full API docs at nexustrade.io/docs/api-reference.

Run the challenge yourself. The current runbook, agent bakeoff, weekly live scoreboard, and every documented failure are open in the Public Portfolio Challenge repository →.

All strategies referenced are simulated backtest results. Past performance is not indicative of future results. Backtests do not account for slippage, commissions, or liquidity constraints. This article is not financial advice. Options trading involves substantial risk of loss and is not suitable for all investors. The $25,000 Public Portfolio Challenge uses real capital; results shown reflect backtest simulations of proposed strategies, not live performance of deployed strategies.