FriesTrader

An AI trading agent built to run cheap and fully on its own, trading real orders on Robinhood using its Agentic Trading MCP server. Once set up, it's able to run unattended on its own schedule every weekday, no manual triggering needed, and the actual safety mechanism is mechanical, auditable risk rules, not the model's judgment. Two short scheduled Claude Code sessions a day screen stocks, write out their reasoning, and (only under a narrow, explicit gate) place real trades, without a team of specialized sub-agents burning tokens on every decision. Because it's just two lean sessions instead of a multi-agent pipeline, it runs comfortably on a Claude Pro subscription (as low as $200/year on the annual plan), no Claude Max or metered API spend required.

This is a template/framework extracted from a real, live deployment. Adapt it, don't just run it blind — read "What this does and doesn't solve" below before pointing it at real money.

If you build on this, a star, a fork, or a link back to this repo is always appreciated.

Why this is safer than it sounds

"Fully autonomous" and "trading real money" together should make you nervous. Here's what actually stands between a thesis and an order:

• Every trade passes through mechanical rules the LLM cannot override — position sizing, stop-loss, take-profit, loss limits, a wash-sale guard, each computed by a small stdlib-only Python script in scripts/ rather than the model doing arithmetic in prose. Same inputs always produce the same numbers, and a good story never cancels a stop-loss.
• New deployments start in dry_run and stay there for a minimum number of cycles (dry_run_min_cycles_before_live) before a live order is even possible, so you can watch it screen and reason before it touches real money.
• Only you can flip execution.mode to "live" — the agent is explicitly barred from ever changing this itself, and refuses to place live orders while dry_run.
• Every decision is logged, approved or rejected — trade_log.jsonl is append-only, so you can check whether the reasoning is actually sound, not just trust it.

Requirements

• A Robinhood account with Agentic Trading enabled, connected via Robinhood's own MCP server.
• Claude Code, on a Pro subscription or higher.
• A GitHub account, to host your own copy of this repo — only needed for the cloud-hosted deployment (see "How it works" below for the cloud vs. local tradeoff).

How it works

Trading runs as two separate phases, on two separate schedules — a full trading day's closing data feeds the thesis, and a fresh opening price is used for the actual order, rather than trading on a stale overnight price.

graph TD
    RH[Robinhood MCP] -- watchlist + scan / quotes / historicals --> A[Phase A: Screen & Thesis]
    A -- thesis per candidate --> P[pending_proposals.jsonl]
    P --> B[Phase B: Re-verify & Risk Enforcement]
    RR[risk_rules.json] -- thresholds --> S[scripts/*.py deterministic risk math]
    S -- JSON results, read verbatim --> B
    RH -- fresh open price / positions --> B
    B -- dry_run or gated live order --> RH
    B -- every decision logged --> L[trade_log.jsonl]
    L -- plain-English recap --> REC[trade_log_recent.md]

• Phase A (Steps 1–3, ~4:30pm Central weekdays) — screens candidates from your watchlist plus a supplementary market scan, gathers signals, writes a logged thesis per candidate to pending_proposals.jsonl. Places no orders, not even dry-run ones. Full spec: PHASE_A_TASK.md.
• Phase B (Steps 4–7, ~8:35am Central weekdays) — re-verifies Phase A's proposals against fresh opening data, enforces risk_rules.json mechanically, and dry-runs or (gated) places orders. Full spec: PHASE_B_TASK.md.

Both are designed to run as cloud-hosted scheduled agent sessions, independent of any local machine — each run clones this repo fresh and commits/pushes its results back to main, so the repo itself is the persistent state, not local disk. (Running locally instead works too, but only fires while your machine is on and available at each scheduled time.)

• risk_rules.json — the hard, mechanical limits (position sizing, stop- loss, loss limits, universe filters, execution mode, wash-sale guard). Nothing in this system should be able to override these. Several fields need your own account details before this is usable — see First-time setup below.

• scripts/ — the deterministic risk-math engines Phase B runs instead of hand-computing anything, each a standalone Python 3 script (stdlib only, no dependencies) you can run and inspect on its own:

  • pnl_pct.py — daily/weekly loss-limit % against starting_capital_usd, and the entries-halted decision.
  • stop_loss.py — the fixed or volatility-scaled stop_pct (clamped, sample-stdev of daily returns), including the trailing-high reference price once a take-profit tier has fired, and the trigger decision.
  • take_profit.py — tiered partial-exit firing, cascading quantity correctly when a single cycle's gain jumps past more than one not-yet-fired tier at once.
  • rank_candidates.py — the conviction / risk_flags / pct_below_52wk_high priority sort new entries and top-ups compete on.
  • position_sizing.py — position/top-up sizing and the concurrency/ cash-buffer checks, compounding running totals down the ranked list.

  Each takes plain CLI args, prints one JSON object, and is meant to be read from directly rather than re-derived — see PHASE_B_TASK.md Step 5 for the exact call shape of each.

• PHASE_A_TASK.md / PHASE_B_TASK.md — the full, self-contained spec each phase follows.

• trade_log_template.jsonl — the log line shapes; real logs accumulate in trade_log.jsonl in this same style.

See it in action

This is what a real Phase B cycle actually produces (trade_log_recent.md, regenerated every run, symbols genericized):

2026-07-09

Loss limit: OK — daily 0.0%, weekly -2.1%, within -5%/-10% limits.

Held positions (stop-loss / take-profit):

• EXAMPLE — stop 7.00% (vol-scaled), drawdown -2.3% — holding

New-entry candidates considered: OTHER, ANOTHER

• OTHER — approved: medium conviction, $60.00 (12% of account)
• ANOTHER — rejected: max_concurrent_positions already filled this cycle

Orders placed: OTHER — buy $60.00 (dry_run)

No JSON parsing required to see what it did and why. Full field-level examples (thesis records, raw trade_log.jsonl lines) are further down in Example output.

What this does and doesn't solve

• It gives you a structured, auditable version of "let an LLM screen and reason about trades" instead of an opaque one.
• It does not make LLM-driven stock picking more likely to beat a simple index fund — there's no established track record for that, and this can't backtest the reasoning step honestly (news-based reasoning can't be validated against historical data the model may already know the outcome of).
• The risk rules are the actual safety mechanism here, not the reasoning quality. Treat loosening them as the highest-risk change you can make to this system.
• This is a template extracted from a real deployment trading a small personal account, shared for others to learn from or adapt. It is genuinely not financial advice, and running it against real money is entirely your own decision and risk.

First-time setup

Get your own copy first:

• Cloud-hosted scheduled sessions (recommended): these commit and push results back to main, so you need a repo you actually control.
  • Running this against your own account: click "Use this template" (top of this repo's GitHub page) and make the result private — it'll accumulate real trading data (trade_log.jsonl, proposals) once running.
  • Building a public variant, not running your own account: Fork it — keeps a link back here and an easy "Sync fork" button for updates.
• Running locally: skip this — just clone or download the repo; state lives on local disk, but your machine needs to be on and available at each scheduled run time.

See "Keeping your copy updated" below for pulling in future improvements.

1. Robinhood's Agentic Trading requires a separate, dedicated account — distinct from your regular investing account, and restricted to only the funds you put in it. See that page to open one and connect its MCP server to Claude Code (or to your routine's MCP connections). Nothing below works without this: every tool call in PHASE_A_TASK.md/PHASE_B_TASK.md (quotes, positions, orders, etc.) goes through it.
2. Fill in account_number in risk_rules.json with your own Robinhood account number, set starting_capital_usd to your real starting balance, set universe.watchlist_name to a watchlist you've already created and populated in your Robinhood account, and review every other threshold — the defaults here are illustrative, not a recommendation.
3. Create a scan via the Robinhood MCP's create_scan tool (relative volume > 2.0x, market cap above your min_market_cap_usd), then paste its ID into universe.supplementary_scan_id. Phase A calls this scan every run to surface movers outside your watchlist — left as the placeholder, that call fails every cycle.
4. Fill in wash_sale_avoidance.linked_accounts with every Robinhood account number you personally control, not just this one — if this is genuinely the only