Build a 24/7 AI Trading Agent with Claude Code and Alpaca

const ALPACA_BASE_URL = "https://paper-api.alpaca.markets";
const ALPACA_KEY = process.env.ALPACA_API_KEY;
const ALPACA_SECRET = process.env.ALPACA_API_SECRET;
 
async function alpacaFetch(path, options = {}) {
  const res = await fetch(`${ALPACA_BASE_URL}${path}`, {
    ...options,
    headers: {
      "APCA-API-KEY-ID": ALPACA_KEY,
      "APCA-API-SECRET-KEY": ALPACA_SECRET,
      "Content-Type": "application/json",
      ...options.headers,
    },
  });
  return res.json();
}
 
export async function getAccount() {
  return alpacaFetch("/v2/account");
}
 
export async function getLatestQuote(symbol) {
  const res = await fetch(
    `https://data.alpaca.markets/v2/stocks/${symbol}/quotes/latest`,
    {
      headers: {
        "APCA-API-KEY-ID": ALPACA_KEY,
        "APCA-API-SECRET-KEY": ALPACA_SECRET,
      },
    }
  );
  return res.json();
}
 
export async function placeOrder(order) {
  return alpacaFetch("/v2/orders", {
    method: "POST",
    body: JSON.stringify(order),
  });
}

// research.js
import { getAccount, getLatestQuote } from "./alpaca.js";
 
function rsi(prices, period = 14) {
  const gains = [];
  const losses = [];
  for (let i = 1; i < prices.length; i++) {
    const change = prices[i] - prices[i - 1];
    gains.push(change > 0 ? change : 0);
    losses.push(change < 0 ? Math.abs(change) : 0);
  }
  const avgGain = average(gains.slice(-period));
  const avgLoss = average(losses.slice(-period));
  if (avgLoss === 0) return 100;
  const rs = avgGain / avgLoss;
  return 100 - 100 / (1 + rs);
}
 
function average(arr) {
  return arr.reduce((a, b) => a + b, 0) / arr.length;
}
 
export async function buildMarketData(watchlist) {
  const account = await getAccount();
  const tickers = await Promise.all(
    watchlist.map(async (symbol) => {
      const quote = await getLatestQuote(symbol);
      return {
        symbol,
        price: quote.quote.ap,
        bid: quote.quote.bp,
        ask: quote.quote.ap,
      };
    })
  );
 
  return {
    timestamp: new Date().toISOString(),
    account: {
      buying_power: account.buying_power,
      portfolio_value: account.portfolio_value,
    },
    watchlist: tickers,
  };
}

# system_prompt.md
 
You are a disciplined algorithmic trading agent. Analyze market data and decide whether to place a trade.
 
Rules:
- Never risk more than 2% of portfolio value on a single trade.
- Only trade during regular US market hours (9:30 AM - 4:00 PM ET).
- Do not trade if you are uncertain. The default action is NO_TRADE.
- Always explain your reasoning in plain language.
 
Output valid JSON in this exact format:
 
{
  "decision": "BUY" | "SELL" | "NO_TRADE",
  "symbol": "TICKER or null",
  "qty": number or null,
  "reasoning": "2-3 sentence explanation",
  "confidence": "LOW" | "MEDIUM" | "HIGH"
}

// execution.js
import { placeOrder } from "./alpaca.js";
 
export async function executeDecision(decision, account) {
  if (decision.decision === "NO_TRADE") {
    console.log("No trade:", decision.reasoning);
    return null;
  }
 
  if (decision.confidence === "LOW") {
    console.log("Skipping low-confidence signal:", decision.reasoning);
    return null;
  }
 
  const portfolioValue = parseFloat(account.portfolio_value);
  const maxRisk = portfolioValue * 0.02;
 
  // Validate position size
  if (decision.qty * decision.estimatedPrice > maxRisk) {
    throw new Error("Position exceeds 2% risk limit");
  }
 
  return placeOrder({
    symbol: decision.symbol,
    qty: decision.qty,
    side: decision.decision.toLowerCase(),
    type: "market",
    time_in_force: "day",
  });
}

// journal.js
import fs from "fs";
import path from "path";
 
export function writeJournalEntry({ marketData, decision, order, timestamp }) {
  const entry = {
    timestamp,
    market_snapshot: marketData,
    agent_decision: decision,
    order_result: order || "NO_ORDER_PLACED",
  };
 
  const logPath = path.join("./journal", `${timestamp.split("T")[0]}.jsonl`);
  fs.mkdirSync("./journal", { recursive: true });
  fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
}

// agent.js
import { buildMarketData } from "./research.js";
import { getTradeDecision } from "./claude.js";
import { executeDecision } from "./execution.js";
import { writeJournalEntry } from "./journal.js";
 
const WATCHLIST = ["AAPL", "MSFT", "NVDA", "TSLA"];
 
async function runCycle() {
  const timestamp = new Date().toISOString();
  console.log(`Starting cycle: ${timestamp}`);
 
  const marketData = await buildMarketData(WATCHLIST);
  const decision = await getTradeDecision(marketData);
  const order = await executeDecision(decision, marketData.account);
 
  writeJournalEntry({ marketData, decision, order, timestamp });
 
  console.log(`Cycle complete: ${decision.decision}`);
}
 
runCycle().catch(console.error);

## Routines
 
### trading-cycle
Schedule: every 15 minutes on weekdays between 9:30 AM and 4:15 PM ET
Command: node agent.js
Description: Run one full trading cycle