GPT-6 Astra traded 7 days with real $10,000: the AI agent narrowly loses to the S&P 500

An AI agent gets $10,000 of real money and seven trading days to beat the S&P 500. That is exactly what Nate Herk tried with GPT-6 Astra, OpenAI's agent model, running in Codex at a high setting. The account closed at $9,900 while the benchmark sat at $9,980, a gap of roughly 0.8 percent, and the bet is settled. The performance is the least interesting part of the run. What the video actually documents is operations: the model refused to place the trades itself, so Herk had to insert a second agent purely to carry out the orders. I watched the full video and sorted what this experiment says about running agents with real money on the line.

The setup is deliberately unforgiving. The capital is $10,000 in real cash, no paper portfolio, and orders are routed through the broker Alpaca. The window is seven trading days, the benchmark is the S&P 500. The stake is a VIP ticket for the AIS Live event on October 17 and 18, raffled among comments in his community if the agent fails to beat the index. That clause triggered. One rule from his earlier attempt is looser this time: instead of leaving the system untouched after setup, he may make up to two changes per trading day. What he cannot do is stop it. The agent keeps trading even at a total loss, there is no kill switch. A previous run of this experiment existed and he calls it decent, though the video does not add details.

The operations side is the most instructive part of the video. GPT-6 Astra designed its own setup: given the task description, the model delegated to several trading agents that contributed research and strategy. The result is a daily rhythm of six action wake-ups plus notifications, running between 7:45 in the morning before the open and 3:15 in the afternoon after the close, Central Time. One routine reads news and picks watchlist candidates before the bell, the next hunts for the first qualifying trade, a midday pass reviews positions, an afternoon routine manages the open positions, another closes out remaining ones, and the final wake-up confirms the exit and records the day's result.

So the relay does not feel like a chain of clueless strangers, everything runs inside a single thread. Each agent leaves a handoff message when its shift ends, the next one reads it, acts, and writes the following message. Herk says the result feels like one continuous agent; technically it is a chain of scheduled wake-ups passing state along. If you operate agent chains, this is the pattern worth copying: handoff messages instead of shared memory, fixed times instead of event chaos, one thread instead of scattered conversations.

The first trading day ended at $9,991, down about nine dollars. The agent had bought Tesla, roughly nine shares and a bit over $3,000 committed, with a stop attached. The price slipped, the stop fired immediately, the damage stayed small. Herk's frustration was about pace rather than size: with a seven-day window, a day of minus nine dollars is no progress. He pushed that feedback into the system, which then worked more aggressively: three entry reviews instead of the previous filter, less restrictive conditions, and the reward-to-risk ratio lowered from 2:1 to 1.5:1 to allow more trades. The model's reply deserves a place in the agent-operator quote collection: I understand the urgency and I should have acted on your feedback sooner.

Day two brought the real surprise, and it had nothing to do with prices. GPT-6 Astra stopped executing trades, and Herk describes the blocker as a model-level restriction: it would gladly help with strategy, but it would not place trades automatically on his behalf. He tried talking it around, the model held. His workaround is the most instructive move of the video: he set up a second agent, a Grok bot with its own email address and a webhook. Astra ends each routine by sending that bot an email, the bot wakes up, takes the recommendations, and executes the trades through Alpaca. Planning and execution are split, joined by a reviewable channel. The email interface is the improvised part; the split itself is exactly the seam you would want to build on purpose when real money is involved.

First, the separation of planning and execution. In this run it emerged from a model restriction, but it is the architecture you want anyway: one agent drafts and justifies, a second executes, and a reviewable channel sits between them. The fact that the model declined to trade autonomously reads, from the operator side, as a visible guardrail that appears precisely when real money is at stake. Keep that boundary, do not tunnel around it; build your own limits, logging and approval steps into the execution layer instead of improvising them via an email trick.

Second, the operations layer. What demonstrably worked this week was not the strategy but the scaffolding: routines with fixed wake-ups, handoff messages for continuity, a dedicated execution agent, a live brokerage connection, and no failed trading days. What is missing is the longer horizon that Herk himself has deferred. For your own projects the order of work follows from that: make the operating layer robust first, lengthen the window second, never the other way around.

The final score is a narrow loss to an index, and it proves little in either direction. What holds up: the agent stack of routines, handoffs and a separate execution bot ran a full week on real money without an outage. The refusal to execute came from the model, not from the designer, which makes it a built-in guardrail rather than a configuration choice. And the performance question stays noise at this length, as Herk says openly. A follow-up is announced, and only a longer window will move the profit question out of the noise.

All figures and events come from Nate Herk's video and his follow-up posts on LinkedIn and X, retrieved on September 28, 2026. This is a self-run experiment without independent verification, and this post reports the numbers as shown in the video.