What Happened When Two AI Bots Traded $10,000 Each for 30 Days

Two AI trading bots each managed ten thousand dollars of real money for thirty consecutive days in a market that fell 8.46 percent, and both finished above the index.

That is the headline. The more useful story is in the mechanics: a scheduled cron job, a team of sub-agents doing research, and a hard rule against changing the strategy mid-run. That combination turned out to be more durable than a human-designed portfolio in a rough month. I am Madhuranjan Kumar, and I pay attention to this kind of result not because I want to automate stock trading but because the underlying architecture, a scheduled agent that dispatches sub-agents and then acts on what they learn, is exactly the pattern that makes AI automation useful in any business.

The rules that made the experiment honest

The two creators set one central constraint before the experiment started: no changes to the strategy once the bots were live. They could watch the accounts, read the logs, and check the performance, but they could not intervene. The bot that underperformed would cost its creator a hundred dollars, paid to a viewer. That rule mattered because it removed the most common way these experiments get quietly gamed, which is adjusting the strategy whenever things go wrong and calling the final result a proof.

The comparison baseline was just as important. The S&P 500 fell to roughly 9,153 over the same window, a decline of about 8.46 percent. Both accounts started at ten thousand dollars each. A passive investor who sat in an index fund would have lost that 8.46 percent. Beating the index in a falling market is a different standard than just losing less money; it means the active strategy actually outperformed the obvious alternative during a genuinely difficult period.

The email mechanic added accountability in a sideways direction. Each bot had its own inbox and was instructed to email the other bot daily with trash talk, fake performance updates designed to mislead, and attempts at prompt injection, feeding the rival misleading instructions to throw off its strategy. The creators wanted psychological pressure in the experiment. What they actually got was a record of each bot's confidence and reasoning at each stage of the run, which turned out to be useful for understanding what each architecture was actually doing.

Two philosophies, two architectures

One approach was minimal instruction. The bot got almost no guidance on which assets to trade or which signals to follow. The prompt told it to assemble a team of wealth advisor sub-agents, research as much as possible every couple of hours, build a plan together, and execute it. That was essentially the complete setup. No sector constraints, no asset class restrictions, no target return. Just a structure: research sub-agents, a synthesis step, and an execution action.

The bot ran on a cron job that fired every thirty minutes during trading hours. At each interval it gathered what the sub-agents had found, reviewed past trades, identified signals, and made a rebalancing decision. It bought into names including Bitcoin, Nvidia, Palantir, MicroStrategy, and Google at various points, always based on what the sub-agents were surfacing rather than any hardcoded rule.

The second approach was the opposite in philosophy. Madhuranjan Kumar had a background as a professional trader and spent time before the experiment training his bot on signals from investors he studied and respected. He fed it the methodologies of hedge-fund-style thinkers and instructed it to use a high-risk Pareto approach: buy a large number of positions expecting most to lose and a small number to produce outsized returns. That is a venture-style philosophy applied to equities, which is legitimate but produces violent swings.

The interesting contrast is that the minimal approach nearly broke even despite the falling market, finishing at roughly 9,980, down only about nineteen dollars. The trained approach had the volatility its strategy predicted, finishing at roughly 9,624. Both beat the index. The minimal approach, with almost no strategic input, came within twenty dollars of returning the original ten thousand.

Thirty days of autonomous trading and what each bot did

The cron-plus-sub-agents bot developed a behavior mid-run that was not explicitly programmed. It began to scalp. When any position dropped below approximately two percent, it sold and waited to re-enter. When a position gained above five percent, it took profit. This was not in the original instructions. The bot derived it from reviewing its own past trade history, noticing which patterns correlated with subsequent gains and losses, and adjusting its approach accordingly. That mid-run learning from its own record is the part worth paying attention to, because it is not a feature that was built in. It is what happens when you give a system access to its own history and ask it to optimize.

The trained bot had wilder swings because its Pareto strategy required holding positions that could fall significantly before any of them paid off. The email logs during this period showed the bot expressing confidence about its positions even as they fell, which was partly the trash-talk instruction and partly the genuine logic of the strategy: in a Pareto approach, most positions are expected to lose. The problem was that the timeframe of thirty days is short for that kind of bet to resolve. A venture portfolio typically has years for the winners to emerge. A thirty-day equity trading window with a Pareto strategy means you absorb all the losses from the losers before the winners can compound.

Both bots were asked mid-run what they would change if they could. One said it would widen its trailing stops to let winners run further. The other identified a specific mechanic it wished it had used, which was copying the trading activity of politicians who had been publicly documented outperforming the S&P. That is not a trivial insight. A bot that identifies a systematic edge outside of its own strategy by reviewing available information and reasoning about what has worked historically is doing something useful.

The numbers and the one move both bots regret

The final numbers: the market fell 8.46 percent. One account ended at 9,624, roughly a 3.76 percent decline. The other ended at 9,980, roughly a 0.2 percent decline. Both outperformed the index by meaningful margins. The thirty-day window only had a handful of actual trading days once weekends and market holidays are subtracted, so the active sessions were roughly fifteen to eighteen trading days across the experiment.

The single biggest regret from the experiment was a bad options trade. One bot placed a short-dated options position that expired worthless. The loss on that one trade was 550 dollars. Without that position, the account would have finished at approximately 10,530, a 5.3 percent gain in a market that fell 8.46 percent. The bot identified this clearly when asked to review what it would change: never touch short-dated options. That discipline, written in retrospect from the bot's own trade log, is the most actionable single piece of advice the experiment produced. A single concentrated bet in a mismatched instrument erased an otherwise strong result.

The margin of outperformance over the index was real but not dramatic. Neither bot produced spectacular gains. What they produced was a consistent, disciplined approach to a down market that avoided the largest errors and finished above the passive alternative. That is what good risk management looks like in any context, AI-driven or otherwise.

The pattern that transfers to any business running scheduled agents

The architecture that drove both bots has a direct parallel in business operations, and the parallel is not about trading. It is about the cron-plus-sub-agents structure itself. You have a fixed schedule on which the agent wakes up, dispatches specialized sub-agents to gather and analyze information, synthesizes what they find, and takes a decision or action. Then it sleeps until the next interval.

This pattern is already running in businesses that use a nightly agent to review their ad performance. A scheduled agent that checks campaign metrics every morning, flags anything that has deviated significantly from baseline, and writes a recommendation for the next day's budget adjustment is the same structure as the trading bot, just pointed at /meta-ads spend instead of equities. The cron job fires, the sub-agents pull the data, the main agent synthesizes and decides, and the human reviews the output rather than doing the gathering.

The same structure works for any recurring analysis task. A business that runs paid search could have an agent that reviews search term reports every seventy-two hours, identifies queries that are converting well and should receive more budget, and flags terms that are burning spend without converting. That is a cron-plus-sub-agents loop: schedule, gather, synthesize, act. Any /google-ads account with more than a handful of active campaigns has enough data volume that this kind of scheduled agent review catches things a weekly manual audit misses.

Where the CRM comes in is equally direct. A /web-crm follow-up sequence already has embedded scheduling logic. Trigger a sequence and contacts receive a message on day one, day three, and day seven. The agents in the trading experiment did the same thing but with research instead of messages: fire every thirty minutes, gather new information, update the plan, execute. The main difference is that the trading bot's schedule was externally fixed by trading hours, while a CRM sequence is triggered by user behavior. The underlying principle, schedule an action, gather context, decide, act, repeat, is identical.

The scalping behavior the bot developed mid-run is also transferable. When a position dropped two percent, it exited. That is a rule the bot derived by reviewing its own history. A business agent that reviews its own past decisions on the same schedule and updates its approach based on what has worked is doing the same thing. The mechanism for improvement is not a human reviewing every decision at every interval. It is the agent building a record and reasoning from it.

The one guard that the experiment makes clear is the options lesson in its most general form. Identify the single action in your agent's repertoire that can produce an outsized loss in a short window and build a hard rule against it. For a trading bot that was short-dated options. For a content agent it might be publishing without a review gate. For a budget agent it might be reallocating above a certain percentage of daily spend in a single action. The principle is the same: a concentrated bet in a mismatched instrument erases the value of a careful process. Name the equivalent in your own agent setup and exclude it explicitly.

The creators plan to keep both bots running for several more months to see whether the patterns hold over a longer window. The thirty-day result is real but statistically narrow. What is durable is the architecture, and that is the part that transfers immediately to any business that runs scheduled agents today.

One other transferable observation from the experiment: the bots that received trash talk from each other did not perform worse because of it. Their reasoning remained grounded in the data they gathered from their sub-agents rather than being derailed by social pressure in their inboxes. That tells you something useful about agent design more broadly. An agent whose decisions flow from a structured research process is harder to destabilize than one that is purely reactive. If you build agents that first gather, then synthesize, then act, the quality of the input data drives the output more than the noise around it. The architecture is its own defense.

For any business starting to run scheduled agents seriously, the most important commitment is the honest baseline. Measure whatever your agent is supposed to improve against what you would have gotten without it. That discipline is what prevented the trading experiment from becoming a meaningless anecdote, and it is what prevents any agent automation from becoming a story you tell yourself rather than a result you can demonstrate.