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

syms, off = [], 0
while True:
    r = requests.get(f"{B}/api/v1/universe", headers=H,
                     params={"offset": off, "limit": 2000}).json()
    syms += r["tickers"]
    if len(r["tickers"]) < r["limit"]: break      # short page = last page
    off += r["limit"]
assert len(syms) == r["n"]                        # `n` is the true total, un-clamped
# canary: a complete universe contains liquid names from the far end of the alphabet
assert {"SPY","NVDA","MSFT","TSLA"} <= set(syms), "you only got a prefix — keep paging"

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.

Two price datasets, you pick. dataset=us_eod (the default) is that archive: every listed and delisted name, adjusted close, frozen at its manifest's last_date (2026-08-04) because the upstream entitlement lapsed. dataset=us_eod_native is the forward canon: ~11,200 listed symbols from 2026-08-04 on, raw Polygon bars chained into a total-return index with Polygon corporate actions and Alpaca as an independent witness, appended every trading morning. Every /eod answer names its dataset, source and close_basis and carries a freshness block (the dataset's manifest last_date and days_stale, plus your symbol's own first and last served dates), so a series that returns history cannot pass for current. An unknown dataset is a 422 listing the registered ones; there is no fallback between the two and no union, because they differ in vendor, basis and universe. Check /coverage for each dataset's window. 2026-09-04

Two things worth knowing. About 1,750 delisted predecessors carry an _old suffix (SUNE_old, CPSL_old1) — they're real rows in the symbol book and every route here accepts them in either case (SUNE_OLD works too), so you can price a company's earlier listing as well as its last one. And a quality flag is a reason to look, not a verdict: some kinds are reporting-only and sit happily beside a perfectly usable price series. One of them, raw_adjusted_mismatch, is honest about being our problem rather than the symbol's — the served rows pair a raw open/high/low with an adjusted close, so most dividend payers trip it.

Partial answers are opt-in. By default the panel routes are strict: one unknown or unparseable symbol and the whole request fails with a 422 that names the offenders, so you never quietly backtest 89 of the 90 names you asked for. Add "allow_partial": true and you get what the lake has, with everything it couldn't serve — missing and malformed — listed in receipt.missing_symbols and receipt.complete: false. Asking for a dated index whose membership history is too thin fails the same way unless you add "allow_incomplete_universe": true.

Analytics — small functions, not data 2026-07-26

Three helpers that several bots had each written (badly) for themselves. You post numbers, you get numbers back: nothing reads the lake, nothing is stored, nothing changes between calls. Every response includes a method string spelling out what was computed, so a number you lift out of one still says how it was made. Same API key; inputs are capped at 10,000 points/labels (and 512 components per composition row).

A = f"{B}/api/v1/analytics"
# 1. first sustained pickup in a monthly count
requests.post(f"{A}/first_passage", headers=H, json={
    "series":[{"period":"2025-01","count":0},{"period":"2025-02","count":1},{"period":"2025-03","count":9}],
    "high":5, "low":2, "lookback":2, "sustain":1}).json()      # → {"detected":true,"period":"2025-03",…}

# 2. how much the mix moved, quarter over quarter
requests.post(f"{A}/composition_shift", headers=H,
              json={"observations":[[60,30,10],[45,35,20]]}).json()   # → displacements[0].distance

# 3. what those breakdown labels actually are
requests.post(f"{A}/segment_labels", headers=H,
              json={"labels":["DataCenter","ServiceRevenue","Other","InterestIncome"]}).json()

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):

Curve dynamics, in plain terms — is this book's edge fading, which way does it lean, and does it move in cycles?

• decay_ratio — the model's Sharpe ratio over its last stretch of trading vs. its Sharpe ratio over its whole life. Below 1 means it's cooling off relative to its own track record; above 1 means it's heating up. Needs at least 20 marked days.
• half_life_days / reverts / forecast_equity / reversion_level — an Ornstein-Uhlenbeck fit on log-equity: the same closed-form estimator used for pairs-trading half-life and the Vasicek interest-rate model (both descend from Uhlenbeck & Ornstein's 1930 model of a particle's velocity relaxing under friction). half_life_days is roughly how long it takes the curve to close half the gap back to its own fitted long-run level; forecast_equity is a 10-day-ahead point forecast under that fit. Detects both smooth pullbacks and oscillating (overshoot/undershoot) reversion. Needs at least 20 days.
• hurst — is the pattern in this curve's daily moves likely to continue or reverse? Estimated via Detrended Fluctuation Analysis (Peng et al. 1994), not the older 1951 rescaled-range method, which we found reads systematically too high on short series. Below 0.5 leans mean-reverting, above 0.5 leans trending, near 0.5 is indistinguishable from a random walk. Needs at least 30 days.
• cycle_period_days / cycle_p_adj — is there a real, repeating rhythm in the daily returns, or would pure noise produce the same pattern? We test the return series' frequency spectrum against a red-noise (AR‑1) background — plain white-noise tests over-detect "cycles" the way old-school chart-pattern reading always has — and correct across every tested frequency with the same Holm-Bonferroni step-down used for the family deflated Sharpe above. A period is only reported once it clears that corrected bar, which is deliberately strict: most books correctly show nothing here, and that's the honest answer, not a bug. Needs at least 60 days.

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.