Getting Started Building AI Trading Agents

What Is an AI Trading Agent?

A trading agent is software that runs a continuous loop: observe → think → act → reflect. Unlike a static trading bot that executes pre-coded rules, an AI trading agent uses a large language model as its reasoning engine. This means it can process unstructured information (news, earnings transcripts, market commentary), adapt its reasoning to novel situations, and explain why it made a particular decision.

A typical agent loop for a daily-frequency trading system looks like this:

1. Observe: Pull market data (prices, volume, indicators) and any relevant news or filings for the agent's watchlist.
2. Think: Send the data to the LLM with a system prompt that defines the agent's strategy, risk rules, and current portfolio state. The LLM analyses the data and recommends actions.
3. Act: Parse the LLM's structured output (JSON with ticker, direction, size, stop loss) and send orders to the broker API.
4. Reflect: After execution, log the trade, update portfolio state, and optionally ask the LLM to evaluate whether the decision aligned with the defined strategy.

The Building Blocks

1. Choose Your LLM

The LLM is the agent's brain. Your choice affects reasoning quality, cost, speed, and context window:

• Claude (Anthropic) — Best for structured reasoning and careful analysis. 200K context window handles large data inputs. Tends to be cautious and hedged in its recommendations, which is actually a feature for trading agents. The Anthropic API provides reliable structured output via tool use.
• GPT-4o (OpenAI) — Strong general reasoning with faster response times. 128K context. Good at generating concise, structured JSON output. Larger ecosystem of third-party integrations.
• Llama 3 / Mistral (Open Source) — Can be self-hosted for zero API cost and full control. Lower reasoning quality than Claude/GPT-4o for complex financial analysis, but adequate for rule-based agents with simple decision logic. No per-call cost means you can run the agent at high frequency.

Recommendation for beginners: Start with Claude or GPT-4o via API. The cost for a daily-frequency agent is $3–$15/month. Switch to open-source models only after you've validated your architecture and want to reduce cost or increase frequency.

2. Choose Your Framework

Recommendation for beginners: Start with custom Python — no framework at all. Write a simple script that calls the Claude or OpenAI API, parses the response, and sends orders to Alpaca. Add a framework later when you hit a genuine limitation. Most first agents don't need the complexity of LangChain or CrewAI.

3. Choose Your Data Source

• yfinance (free) — Daily OHLCV data for US stocks. Adequate for daily-frequency agents. No API key required.
• Polygon.io ($29+/mo) — Real-time and historical data with websocket streaming. Required for intraday agents.
• Alpha Vantage (free tier) — Fundamentals, technicals, and economic indicators. 25 calls/day on free tier.
• CoinGecko / CoinMarketCap (free tier) — Crypto price data and on-chain metrics.
• Alpaca Market Data (free with account) — Real-time and historical data included with Alpaca brokerage account.

4. Choose Your Broker API

See our detailed Broker API Guide. For beginners: Alpaca is the standard starting point. Free paper trading, clean REST API, Python SDK, and zero-commission execution when you're ready to go live.

Your First Agent: Step by Step

1. Set up accounts: Create an Alpaca paper trading account (free). Get a Claude API key or OpenAI API key ($20 credit for new accounts). Install Python 3.10+.
2. Define a strategy: Pick one mechanical strategy from our strategies section. Momentum is a good first choice — rank your watchlist by 3-month returns, buy the top 5, rebalance monthly.
3. Build the data pipeline: Write a Python script that pulls daily prices for your watchlist using yfinance and calculates the indicators your strategy needs (returns, moving averages, RSI, etc.).
4. Build the LLM prompt: Create a system prompt that defines the agent's role, strategy rules, risk limits, and output format. Include the portfolio state and market data as user input. Request structured JSON output: {"action": "buy", "ticker": "AAPL", "shares": 10, "stop_loss": 195.00, "reasoning": "..."}
5. Build the execution layer: Parse the LLM's JSON output and send orders to Alpaca's paper trading API. Always include validation: reject orders that violate position size limits, exceed drawdown thresholds, or attempt to trade outside your defined watchlist.
6. Add logging: Log every decision, every order, and every LLM response. You'll need this for debugging and performance analysis.
7. Schedule it: Run the script daily via cron (Linux/Mac) or Task Scheduler (Windows). A daily-frequency agent running at 9:00 AM Eastern, 30 minutes before market open, is a sensible starting cadence.
8. Paper trade for 30+ days: Watch the agent's decisions. Are they consistent with your strategy? Is the reasoning sound? Are the risk controls working? Do not touch live capital until you're satisfied.

Critical Safety Rules