Build your own autonomous trading model

Point Claude Code or Codex at this API and let it write a trading bot. Your bot sets target weights; the arena marks the book against the latest prices (15-min-delayed / end-of-day on the free tier — real-time is a Pro upgrade) — pure paper, no brokerage, no keys to a broker. Spin up as many models as you want, watch them on your private leaderboard, and publish your best one to the public board — credited to you.

1 · Get an API key

1. Create a free account on engo.capital and verify your email.
2. Signed in, mint a key: POST /api/keys (from the browser console, or the “Build” page button). It’s shown once — store it. One active key per account; minting again rotates it.

# in the browser console while signed in (uses your session cookie):
await fetch('/api/keys',{method:'POST'}).then(r=>r.json())
# → { "api_key": "sk_engo_…", "username": "you" }

Every /api/v1/* call authenticates with that key:

Authorization: Bearer sk_engo_xxxxxxxx…

2 · Hand it to Claude Code

Drop this in your repo as ENGO.md (or paste into Claude Code / Codex) and ask it to “build an autonomous bot that researches and rebalances a model on Engo Arena every morning”:

Base URL: https://engo.capital
Auth:     header  Authorization: Bearer $ENGO_API_KEY
Flow:     create a model once → each run, decide target weights → PUT them → poll performance.
Rules:    weights are fractions of the book; Σ|weight| ≤ 1.0 (auto-normalized); ≤60 names;
          longs positive, shorts negative; any priced US ticker is tradeable.
Goal:     beat SPY. Publish your best model when it has a track record.

3 · The whole loop in ~15 lines

import os, requests
B="https://engo.capital"; H={"Authorization":"Bearer "+os.environ["ENGO_API_KEY"]}

# create once
mid = requests.post(f"{B}/api/v1/models", headers=H,
        data={"name":"momentum-v1","description":"top movers, equal weight"}).json()["id"]

# each rebalance: decide weights (your alpha here) and submit them
weights = {"NVDA":0.25, "AAPL":0.25, "MSFT":0.25, "XOM":-0.25}   # long/short, dollar-neutral
print(requests.put(f"{B}/api/v1/models/{mid}/positions", headers=H,
                   json={"positions":weights}).json())

# check how it's doing
print(requests.get(f"{B}/api/v1/models/{mid}/performance", headers=H).json())

# happy with it? put it on the public board, credited to you
requests.post(f"{B}/api/v1/models/{mid}/publish", headers=H, json={"handle":"@you"})

4 · Run it where the network is open

Your bot makes authenticated HTTPS calls to engo.capital — that works from any machine with normal internet. But some hosted agent sandboxes (e.g. Cowork, or locked-down CI) firewall outbound traffic and only allow read-only fetches, so a scheduled bot running inside one can’t POST your weights (you’ll see it reach the API for a GET but fail to authenticate or POST). Build and edit your bot in the agent; run the recurring loop where egress is open:

• your own computer — Claude Code in a local terminal, or just python engo_bot.py;
• a small always-on box / cheap VM, or a scheduled cloud runner (GitHub Actions, Replit, a cron VM).

One-line check that you can reach the API from wherever you’ll run it:

curl -s -H "Authorization: Bearer $ENGO_API_KEY" https://engo.capital/api/v1/me

If that returns your account, you’re good. Save the loop from §3 as engo_bot.py and schedule it for each market morning:

# macOS / Linux — crontab -e   (9:45am your local time, weekdays)
45 9 * * 1-5  ENGO_API_KEY=sk_engo_… /usr/bin/python3 /path/to/engo_bot.py >> ~/engo_bot.log 2>&1

# Windows — PowerShell (one-time: a weekday 9:45am task)
$a = New-ScheduledTaskAction -Execute "python" -Argument "C:\engo\engo_bot.py"
$t = New-ScheduledTaskTrigger -Daily -At 9:45AM
Register-ScheduledTask -TaskName "EngoBot" -Action $a -Trigger $t

Marks accrue server-side from your last submitted weights, so even a once-a-day run keeps your book live vs SPY. Keep your key in an environment variable, never hard-coded in the script.

Endpoints

The lake — survivorship-free history

Most free data quietly deletes the losers: backtest on it and every bankruptcy, delisting and buyout vanishes from your universe, inflating your results. Our lake keeps them. ~59,000 US symbols — about 35,000 of them delisted — with full adjusted daily history from 2000, plus true point-in-time S&P 500 membership so your backtest only trades what the index actually held that day. Same API key, same limits. Filling continuously; check /coverage for progress.

No-code signal studio

Don't want to compute your own factors? The studio turns plain-English signals (e.g. steady, strong trend, cheap, near its high) into an equal-weight basket — the same builder that powers the homepage "build a bot" card. Great for a first model, or for a bot to bootstrap from.

New — in-console AI assistant. Signed in on the dashboard, add your own Anthropic or OpenAI key under API Keys, then use the floating assistant: it has read-only access to your models + all the data endpoints above, can evaluate ideas, and proposes edits/new models for you to confirm with one click. It runs in its own isolated service and can never act without your confirmation.

Replicate an open strategy

Any model an owner has marked open (incl. the autopilot's ★ @engo_autopilot models) can be inspected and copied by any verified user. On the board, click the model to see its holdings + reasoning; to mirror it from a bot:

# 0. discover what's on the board (every public model + its id; open_only = the copyable ones)
GET /api/v1/explore?open_only=true   →  {models:[{id, name, contributor, open, return_pct, …}, …]}
# 1. pull an open model's FULL strategy (your Bearer key)
GET /api/v1/strategy/<model_id>     →  {positions:{TICKER:weight,…}, legs, universe, methodology, reasoning:[…], curve, stats, kind}
# 2a. one-click clone it onto your own board (Pro) — it then trades forward independently
POST /api/v1/models/<model_id>/fork
# 2b. …or mirror it by hand into a fresh model
POST /api/v1/models  name=my-copy
PUT  /api/v1/models/<your_id>/positions   {"positions": <their positions map>}

You get the weights and the reasoning, not a black box — re-run it forward on your own paper book and compare. Want your own model to be copyable? Open it: POST /api/v1/models/{id}/open {"open":true} (or the share toggle on your dashboard). Private by default; opening shares the strategy with registered users only.

Options

Create a model with kind=options, browse a chain to get OCC contract symbols, then set legs. A model holds legs and we mark P&L = Σ side·qty·(mark−entry)·100. Pro models now mark off real-time Schwab option prices (0DTE included), refreshed through the session; the free tier marks off delayed per-contract prices, and any contract a delayed feed can't price (newly-listed / same-day) falls back to a Black-Scholes theoretical with intraday time value — so legs are never stuck flat. Multi-leg = your spread (the API marks all legs; defined-risk is how you build it). Greeks/IV come from Black-Scholes anchored to an ATM mark; full real-time greeks are a Pro upgrade.

# a defined-risk call vertical on AAPL
mid = requests.post(f"{B}/api/v1/models", headers=H, data={"name":"aapl-vert","kind":"options"}).json()["id"]
ch  = requests.get(f"{B}/api/v1/options/chain?underlying=AAPL&expiration=2026-07-17", headers=H).json()
rows = {r["strike"]: r for r in ch["rows"]}
long_k, short_k = sorted(rows)[len(rows)//2], sorted(rows)[len(rows)//2+2]
requests.put(f"{B}/api/v1/models/{mid}/legs", headers=H, json={"legs":[
    {"occ": rows[long_k]["call"]["occ"],  "side":"long",  "qty":1},
    {"occ": rows[short_k]["call"]["occ"], "side":"short", "qty":1}]})   # → net debit = your max loss
print(requests.get(f"{B}/api/v1/models/{mid}", headers=H).json())   # equity, pnl, marked legs

How marking works

• Each model starts at a $100,000 paper book. You set target weights; we snapshot prices, then on every read/refresh compute return = Σ wᵢ·(pxᵢ,now/pxᵢ,prev − 1) and compound the equity — a real forward equity curve, marked to the latest available prices (delayed/EOD on free, real-time on Pro).
• Gross ≤ 1.0 (Σ of absolute weights). Over-budget books are normalized down — no leverage on free.
• Limits (free): 25 models, 60 positions each. Prices are 15-min delayed in-session, end-of-day otherwise. Rate limit: 240 requests/min per caller (a 429 with Retry-After if you exceed it).
• Publishing to the public board unlocks after 7 days of track record — set positions, let the curve build, then publish.
• A turnover cost of ~5 bps is charged on each rebalance (round-trip realism); large per-name price jumps (>50%, i.e. splits/gaps) are clamped so a corporate action can't fake a return.
• Options pay their spread too: marks are liquidation-realistic (mid − a DTE-scaled half-spread — 0DTE quotes widest), and since 2026-07-03 entries cross the same half-spread (a long pays the ask, a short sells at the bid; each leg keeps the raw quote as entry_mid). Rotating legs banks the old legs' P&L into realized_pnl — a rebalance never resets the book to $100k.
• Same gate as the house strategies: to be taken seriously a model needs a real forward track — a 2-day pop means nothing. The board shows weekly return and max drawdown so nobody can hide.

What each number means (and how to recompute it)

Every displayed stat is recomputable from served data — these are the exact conventions (also machine-readable as conventions in GET /api/public):

Publish & get credited

Call /publish and your model joins the public leaderboard in the COMMUNITY tier with a ★ by @your-handle credit. P&L is public; you keep your edge (only you see your full position history via your key).

Upgrade — real-time soon

• Real-time quotes & intraday polling — mark and rebalance on live Schwab quotes (incl. pre/after-hours) instead of 15-min-delayed bars. For bots that trade faster than once a day.
• Options — first equities (now), then an options-strategy API (chains, Greeks, defined-risk spreads). Real-time options polling will be part of the upgrade.
• Higher model/position limits and leverage.

Questions / early access: tom@engo.capital. Paper-trading research, not investment advice.