Build a 12 Person Claude Paper Trading Desk

claude --version
python3.12 --version
git --version
uv --version

I'm setting up TradingAgents (https://github.com/TauricResearch/TradingAgents) so Claude runs as a trading research desk, and connecting it to my Alpaca PAPER account. Work in ~/trading-desk.

Before writing code, read the repository README and tradingagents/default_config.py. Use the API names the repository actually exposes. Do not guess. Stop and ask whenever you need a key. Never configure live trading. Never place an order unless I type YES first. If a step fails twice, log the failure and continue to the next step.

STEP 1: Install TradingAgents

Clone the repository into ~/trading-desk/tradingagents. Create a Python 3.12 virtual environment inside it and run `pip install .`.

Ask me for my Anthropic API key and set ANTHROPIC_API_KEY through local configuration. Confirm that the free Yahoo Finance data path works by pulling five days of BTC-USD data.

Inspect the repository and tell me which Claude model IDs it supports for deep_think_llm and quick_think_llm. Select the strongest supported model for deep thinking and a faster supported model for quick thinking.

If I provide a FRED API key, set FRED_API_KEY. Otherwise skip it because the desk must still work without FRED.

STEP 2: Create research_floor.py

Write a script using TradingAgentsGraph. It must accept:

* --ticker
* --date, defaulting to today
* --rounds, defaulting to 3

Use this configuration:

* llm_provider: anthropic
* deep_think_llm and quick_think_llm: the supported models selected in Step 1
* Enable all four analysts
* max_debate_rounds: the value supplied through --rounds
* max_risk_discuss_rounds: 2
* debug: True

As each stage finishes, print a clear heading and the result in this exact order:

1. Memory
2. Market Analyst
3. Sentiment Analyst
4. News Analyst
5. Fundamentals Analyst
6. Bull Case, separated by round
7. Bear Case, separated by round
8. Research Manager
9. Trader
10. Risk Team, separated by persona and round
11. Portfolio Manager

Before each stage, print one line identifying the agent currently working.

End with these five summary lines:

* Verdict
* Conviction
* Strongest bull point
* Strongest bear point
* What would flip the verdict

Save the full output to:

./reports/<ticker>-<date>.md

Save the structured verdict to:

./reports/<ticker>-<date>.json

Print total run time and approximate cost. Test the script once with BTC-USD and --rounds 1.

STEP 3: Verify memory

Inspect the code and confirm where TradingAgents stores its decision log and reflections. The expected default location is under ~/.tradingagents/.

If the repository exposes a supported function for recording the realized return of a past decision, connect it to research_floor.py. A new run for a ticker should settle the previous call for that ticker and show the resulting reflection before the Portfolio Manager decides.

Do not invent an unsupported memory API.

STEP 4: Connect the Alpaca MCP server

Read the current README at https://github.com/alpacahq/alpaca-mcp-server.

Register Alpaca's official MCP server with Claude Code at user scope using the README's current instructions. The expected command structure is:

claude mcp add alpaca --scope user --transport stdio uvx alpaca-mcp-server --env ALPACA_API_KEY=... --env ALPACA_SECRET_KEY=...

Ask me for my PAPER API key and PAPER secret key. Leave ALPACA_PAPER_TRADE at its default value of true.

Verify the server appears in:

claude mcp list

Then use it to show my paper account balance and confirm whether any paper positions are open.

STEP 5: Create trade_from_verdict.py

Write a script that reads:

./reports/<ticker>-<date>.json

It must convert the verdict into an Alpaca paper order plan using these rules:

* Use only price levels explicitly produced by the research desk, including breakout trigger, pullback zone, and stop.
* Never invent a price.
* Never use market orders.
* Use only limit or stop-limit orders.
* Make orders good till cancelled.
* Size each order at 10 percent of current cash.
* Never allocate more than 20 percent to one ticker across all open and proposed orders.
* For Hold with a breakout trigger and pullback zone, create a stop-limit buy at the breakout, with the limit 0.4 percent above it, plus a limit buy in the lower half of the pullback zone.
* For Buy with medium or higher conviction, create a limit buy at or just below today's close and attach the desk's stop as a bracket.
* For Sell when the account has no position, take no action.

Before submission, print a table containing:

* Ticker
* Verdict
* Order type
* Trigger
* Limit
* Quantity
* Dollar value
* Attached stop
* Exact report line that supplied each level

After printing the table, wait for me to type YES. Submit nothing for any other response.

Add a --dry-run flag that prints the table and exits without placing an order. Test it in dry run mode using the JSON created in Step 2.

STEP 6: Create run_daily.sh, but do not schedule it

Write a shell script that:

1. Exits immediately if ~/trading-desk/STOP exists.
2. Cancels open conditional paper orders left from the previous day.
3. Runs research_floor.py for every ticker in a TICKERS variable with --rounds 2.
4. Runs trade_from_verdict.py with --dry-run for each result.
5. Sends each ticker's five line summary to Telegram only when TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID are configured.
6. Appends one row per ticker to ./reports/daily_log.csv.

The CSV columns must be:

 date, ticker, verdict, conviction, action, account equity

Show me an example launchd entry for macOS or cron entry for other systems that would run the script at 9:00 AM local time on weekdays. Do not install or enable the schedule.

STEP 7: Hand off the finished setup

Return a table showing:

* Component
* Passed or failed
* File path
* Verification performed
* Any unresolved issue

Then show the three commands I should run for:

1. A labelled research run
2. An order plan
3. The daily loop by hand

Finally, report the measured or estimated token usage and approximate cost of the completed test run. Do not claim an exact token count unless it is available from the API or logs.

~/trading-desk/
├── STOP
└── tradingagents/
    ├── .venv/
    ├── research_floor.py
    ├── trade_from_verdict.py
    ├── run_daily.sh
    └── reports/
        ├── BTC-USD-<date>.md
        ├── BTC-USD-<date>.json
        └── daily_log.csv

cd ~/trading-desk/tradingagents
source .venv/bin/activate
python research_floor.py --ticker BTC-USD --rounds 3

python trade_from_verdict.py reports/BTC-USD-<date>.json --dry-run

python trade_from_verdict.py reports/BTC-USD-<date>.json

cd ~/trading-desk/tradingagents
./run_daily.sh

touch ~/trading-desk/STOP

rm ~/trading-desk/STOP

Run research_floor.py on BTC-USD and META for today with 3 rounds. When both finish, read the two JSON reports and turn each verdict into a concrete order plan for my Alpaca PAPER account using trade_from_verdict.py's rules: only the desk's own levels, no market orders, 10 percent of cash per order, 20 percent maximum per ticker, and good till cancelled. Show me the table with the source line for every level. Wait for YES. Then place them through the Alpaca MCP and show me the open orders.

Read ~/.tradingagents/memory/trading_memory.md and give me a table of every recorded call: date, ticker, verdict, what the price did afterward, and the recorded lesson. Then identify which lessons were applied in later calls and which were not. If the file or fields differ, inspect the repository's actual memory structure and explain the difference instead of guessing.

Run research_floor.py on ETH-USD and SOL-USD for today with 2 rounds. Show both five line summaries side by side. Tell me which ticker had the stronger bear case and explain why using the generated reports.

Using the Alpaca MCP, cancel all open orders on my paper account and then show me the open order list so I can confirm it is empty. Do not access a live account.