A New Approach to AI Trading Agents: Let LLMs Write Strategies, Not Make Decisions

When AI Trading Agents Hit the "Different Answer Every Day" Problem

The appeal of AI trading agents is obvious: no emotional swings, no need to master quantitative math, and the ability to turn your trading ideas into executable strategies using plain language. But one developer, after extensive testing, identified a core pain point — and built a platform called AlphaGround around solving it.

The problem lies in the decision-making mechanism itself. In most AI trading agents, the large language model (LLM) is making the actual trading decisions every day — and the same prompt can produce different answers on different days. When a strategy loses money, you have no way to tell: was it a flawed trading idea, or was the model just having an "off day" and firing randomly? This uncertainty means you can't iterate, can't improve — you're just at the mercy of chance.

The Core Idea: Turning the LLM from "Trader" to "Author"

The most critical design decision in this platform is a complete role reversal for the LLM in the workflow.

The LLM Writes; the Strategy Runs

The traditional approach puts the LLM in the role of a trader, involved in every single transaction. The new approach instead casts the LLM as a strategy author. Users describe their trading ideas in natural language, the LLM asks a few clarifying questions about ambiguities, and then translates those ideas into an executable strategy — essentially what a quantitative analyst would normally have to hand-code.

Once the user reviews and confirms the strategy, it goes live. From that point on, the strategy executes every trade independently, with no further LLM involvement in any decisions. The agent strictly follows the rules you set for every single trade.

This architecture maps onto a well-known technical concept in quantitative finance: decoupling strategy generation from strategy execution. In traditional quant trading systems, strategy logic is typically hardcoded (e.g., in Python or Pine Script) and runs without relying on real-time inference from any external model. What AlphaGround does is essentially use the LLM as a "code generator" that translates natural language descriptions into deterministic rules — which might look like conditional trigger logic (e.g., "buy when RSI drops below 30 and volume increases") — and once generated, those rules run with fixed logic. This aligns with the increasingly popular "LLM as compiler" paradigm: LLMs excel at understanding intent, resolving ambiguity, and generating structured output, but are poorly suited as real-time decision nodes in contexts requiring consistency.

Attributability: When You Lose, You Know What to Blame

The greatest value this architecture delivers is attributability. When a strategy loses money, you can be certain it's a problem with the strategy itself — not the model having a random day — so you can make targeted improvements.

The platform also emphasizes that every trade clearly shows the real reason it occurred — not a story the AI made up after the fact, but the actual conditions and specific values that triggered the trade. This kind of transparency is exactly what traditional "black box" AI trading lacks.

Publicly Verifiable Performance and GitHub-Style Collaboration

Beyond the rethought decision-making mechanism, this platform also draws on open-source philosophy for performance tracking and community collaboration.

Immutable, Public Track Records

Strategies currently run on real market data using $100,000 in simulated capital (paper trading). All performance records are public and non-editable. If you modify a strategy, it becomes v2, while the v1 trade history remains fully visible. This versioning mechanism makes the entire evolution of each strategy completely transparent.

Paper trading is a standard step in quantitative strategy validation — it simulates placing orders with virtual capital on real market data without generating actual fills. Its core value is evaluating whether a strategy's logic works under zero-risk conditions. However, paper trading has a widely acknowledged limitation: it assumes orders can be filled in full at the current quoted price, ignoring real-world friction costs like slippage (the gap between actual fill price and expected price), market impact (large orders moving the price), and insufficient liquidity (inability to fill at the expected size). For high-frequency or large-capital strategies, the performance gap between simulation and live trading can be especially significant. As a result, the simulated performance the platform currently displays should only be treated as a reliable reference once live trading is available and sufficient real data has been accumulated.

Fork Strategies Like a Code Repository

You can also fork anyone's agent and adapt it into your own version, just like forking a repository on GitHub. This way, strategies are shared in a public environment, measured by real results, and everyone can learn from what actually works. This design transforms quantitative strategy development from a solitary, behind-closed-doors activity into a shareable, verifiable collaborative ecosystem.

The analogy between strategy sharing and GitHub's fork mechanism has genuine merit: GitHub's core value lies in version control and traceability — every change is recorded, and anyone can fork a new version from any historical point without affecting the original. AlphaGround's version management logic is similar: v1 trade history remains accessible after v2 is published, which in a financial context compresses the room for "backtest cheating" and "selective disclosure." That said, there's a fundamental difference: a code repository's value comes from collaborative contribution, whereas trading strategies have an inherent "publish-and-perish" paradox — once enough people use the same strategy, the market inefficiency it exploits tends to be arbitraged away. This is a long-term challenge that any strategy-sharing platform will have to face.

Current Status and Early User Opportunity

The platform is currently available as a public beta, free to try. At this stage it supports paper trading only; the developer says live trading with real brokerage connectivity will launch next week.

As an early-user incentive, the first 1,000 registered users will become "Founding Members for Life," receiving a profile badge and occasional perks.

A Few Observations

The most valuable insight this product offers isn't really "AI can trade for you" — it's that it honestly acknowledges the unreliability of LLMs as real-time decision-makers. LLM output randomness may be harmless in creative or conversational contexts, but in financial decisions that demand reproducibility and attributability, it's a fatal flaw.

Positioning the LLM as a "strategy generator" rather than a "real-time trader" is essentially using a deterministic rules engine to execute decisions, while using the LLM to lower the barrier to writing those rules — a remarkably pragmatic compromise. It preserves the usability of natural language interaction while avoiding the risk of betting real money (once live trading launches) on a model's random fluctuations.

That said, some healthy skepticism is warranted: there is often a wide gulf between impressive paper trading performance and live trading results, with slippage, liquidity, and actual fill mechanics all significantly affecting outcomes. The platform's live trading feature hasn't launched yet, and its real-world value remains to be proven by the market. For users who have trading ideas but lack programming skills, tools like this are worth watching — but approach them with a mindset of testing and learning, and proceed with caution.

Note: This article is based on a single-source introduction posted by the developer on Reddit. All feature descriptions and performance claims come from the platform itself and have not been independently verified.