farzad.money

How to build a Tradey desk

The recipe behind Farzad's public desk. Robinhood Agentic for the account. Claudey reads and places only an approved order. Two models decide independently. Code requires agreement and enforces risk. The public page shows every result and disagreement.

First, the blunt version

An auto-trader is not magic. It is a very fast intern with a brokerage login. If you give it vague freedom, it can do vague damage.

The safe design is simple: the AI can think, but code must enforce the rules before money moves.

We built this like a restaurant kitchen:

Hard requirement: Robinhood Agentic account

If you want to follow this Tradey / Robinhood pattern, you must set up a Robinhood Agentic account first. A normal Robinhood account is not enough for this automation path.

Think of it like this: regular Robinhood is a kitchen you cook in yourself. An Agentic account is a kitchen that has an explicit AI-assistant lane. Without that lane open, the bot cannot safely get the live account, position, quote, and order tools it needs through the Robinhood MCP connection.

If you use a different broker, you still need that broker's equivalent of AI/agentic API access with clear read + order tools. For this public Tradey recipe as built, the answer is Robinhood Agentic.

The brain
Two models decide independently; Claudey reads and executes
The boss
Master, cron jobs, files, logs, alerts
The safety layer
Hard caps, broker readback, kill switch, dry-run first

What we actually built

The Farzad setup has five big pieces.

1
Alpha Radar finds ideas.
It scans the market for liquid US stocks with fresh catalysts, news, volume, sentiment, and a clean risk map. It does not trade. It only creates a candidate list.
2
Claudey reads broker truth once.
Claudey reads broker-authoritative account, position, order, quote, earnings, and tradability data through MCP. Models never get credentials or execution tools.
3
Two models decide independently.
Grok 4.5 high and Hermes GPT-5.6 Sol xhigh receive the same broker snapshot, research dossiers, candidate data, journal, market pulse, recent decisions, and order history. Neither sees the other answer. Different action or symbol means no execution.
4
The validator blocks dumb or illegal moves.
Even model agreement is not enough. Code still checks buying power, size, spread, liquidity, earnings, concentration, reward-to-risk, pending orders, stops, targets, and every hard rule.
5
Only then can execution happen.
Claudey reviews the exact approved order with the broker, places it with an idempotency reference, reads broker state back, reconciles fills, journals the result, and refreshes the public dashboard. Every model disagreement is logged publicly.

What Claude MCP means

MCP is a tool adapter. Think of it like giving Claude a set of labeled buttons it can press instead of asking it to guess from a webpage.

In this case, the broker MCP tools are buttons like:

The important trick: broker reading, independent decisions, validation, and execution are separated. Claudey gets read-only broker tools for the snapshot. Grok and Hermes receive the same sanitized evidence bundle concurrently, but no broker tools and neither model sees the other's answer. Deterministic code requires agreement and still validates every risk rule. Claudey receives order tools only inside the narrow execution step.

The minimum parts you need

The safety rules that matter

If you skip this section, you should not build one. Seriously.

How the schedule works

The live setup runs often during market hours, but not as one giant chatbot sitting there yelling all day.

Copy-paste prompt for your own Tradey desk

Give this to Master. Replace the bracketed parts with your own broker, account size, and risk rules.

Build me a bounded Tradey desk using Claude MCP for broker access, a live web/X research model for decisions, and deterministic Python for risk.

Goal:
Create a safe, auditable auto-trading stack that starts in dry-run mode, then can be enabled for tiny live trading only after I explicitly approve it.

My broker:
Robinhood with an Agentic account. If using another broker, it must expose equivalent AI/agentic MCP tools.

Hard account requirement:
- I must set up a Robinhood Agentic account first before wiring live tools.
- Use only this dedicated Agentic cash test account: [account name or ID]
- Confirm agentic_allowed / agentic trading is enabled for that account.
- Do not trade my IRA, UTMA, margin, or any non-agentic account.

My account limits:
- Starting capital cap: [$ amount]
- Max I am willing to lose: [$ amount]
- Instruments allowed: [cash equities only is strongly recommended]
- Instruments banned: options, margin, crypto, OTC, penny stocks, illiquid stocks, leveraged ETFs, inverse ETFs

Use Claude MCP for broker access:
1. Check whether Claude CLI is installed and can authenticate non-interactively.
2. Check whether a broker MCP server is configured.
3. Confirm the available MCP tools.
4. Separate tools into read-only tools and execution tools.
5. Let Claude Sonnet read the broker snapshot. Fail closed if account permission, positions, orders, buying power, or quotes are unavailable.
6. Never expose credentials or give execution tools to the research model.

Use live research and independent consensus:
1. Use the strongest available model with live web and X access. This build uses Grok 4.5 at its maximum supported reasoning level.
2. Give it the broker snapshot and verified research dossiers, but no broker credentials or execution tools.
3. Run a second strong model independently on the exact same evidence. Do not show either model the other model's answer.
4. Require the same action and symbol before execution. Require materially similar levels for stop or target updates.
5. Treat reviewer failure, malformed output, low confidence, or disagreement as no consensus and block execution with no fallback.
6. Allow at most one proposed order per cycle.
7. Require a fresh multi-source dossier for every new buy.

Build these files:
1. autonomy_config.json
   - enabled=false by default
   - account cap
   - max daily orders
   - max position size
   - min price
   - min average volume
   - allowed and banned instruments
   - kill switch path

2. trade_journal.jsonl
   - every trade has symbol, entry, quantity, dollar basis, stop, target, horizon, confidence, thesis, status

3. order_ledger.jsonl
   - every proposed, rejected, placed, filled, or failed order is recorded

4. alpha_radar.py
   - finds possible trades from live market/news/search data
   - writes candidates only
   - never places orders

5. autotrader.py
   - asks Claude Sonnet to read account, positions, orders, quotes, earnings, and tradability through MCP
   - replaces all model-provided broker fields with the broker snapshot, including explicit null or empty values
   - gives one immutable evidence bundle to the live research model and an independent second reviewer concurrently
   - prevents either model from seeing the other's answer
   - requires the same action and symbol, plus materially similar stop or target levels for plan updates
   - strips every order and plan update when the models disagree or either reviewer is unavailable
   - logs every review privately and publishes every sanitized disagreement
   - validates every agreed order again with deterministic code
   - rejects anything outside the config, including unknown buying power, stale research, weak reward-to-risk, excessive spread, near-term earnings, or active broker orders
   - reviews the exact order with broker MCP
   - places only the exact reviewed order if live mode is enabled
   - reads broker state back after placing and reconciles pending or partial fills
   - journals only confirmed fills

6. candidate_outcomes.py
   - records every qualified candidate whether traded or skipped
   - measures 1, 3, 5, and 10-session returns and excess return versus SPY
   - compares traded selections with skipped opportunities
   - never changes live risk directly

7. public_dashboard.py
   - creates a static HTML/JSON dashboard
   - moves excess return versus SPY into the top performance summary
   - shows total dual-model reviews, agreements, disagreements, unavailable reviews, and every blocked disagreement
   - excludes account numbers, broker order IDs, secrets, local paths, raw prompts, and private logs

8. deploy script
   - deploys the dashboard to Vercel or another static host
   - stays silent on success
   - alerts on failure

9. cron jobs
   - premarket scan
   - market-hours Alpha Radar refresh
   - market-hours autotrader every 15 minutes
   - post-close read-only review
   - dashboard refresh and deploy

Hard safety requirements:
- Start in dry-run mode.
- Ask me before enabling live mode.
- No order unless the independent decision models agree on the action and symbol.
- No execution when either reviewer fails, times out, returns malformed output, or falls below the approval confidence threshold.
- Model agreement never bypasses deterministic risk validation.
- No order without a stop, target, horizon, thesis, confidence score, and risk/reward estimate.
- No order unless broker tradability is verified.
- No order unless liquidity rules pass.
- No order unless buying power and position limits pass.
- No order unless broker review returns clean enough.
- Use idempotency references so the same order is not accidentally placed twice.
- Add a kill switch file that immediately stops live trading.
- Print only on trade, blocker, auth failure, or system failure.
- After building, run a dry-run test and show me the exact output.

Important:
Do not place real orders during setup. Do not claim anything works until you have run it and verified the files, cron jobs, dry-run output, and dashboard locally.

What to ask before going live

If any answer is fuzzy, do not go live. Keep it in dry-run.

What Vercel does in this setup

Vercel is just the public display case. It does not trade. It hosts the static dashboard.

The bot writes a clean public JSON file, then deploys the static website. If Vercel fails, trading can still run, but the public page may be stale until deploy works again.

For this site, the public dashboard is deployed at farzad.money.