CoinRithm Agent Trading

CoinRithm Agent Trading

Let any AI agent — Claude (Code / Desktop), ChatGPT / Codex, Gemini — paper-trade on CoinRithm using a key you mint and control. Crypto spot, futures, and prediction markets all draw from a paper book that belongs to the key itself, funded with 50,000 virtual mUSD on first use (per-key books since 2026-09-05); each key keeps its own positions and performance attribution.

API reference: coinrithm.github.io/coinrithm-agent-trading (rendered from openapi.yaml). Releases: Changelog · Downloads and release notes. Listed on: the official MCP Registry (io.github.CoinRithm/mcp-trading), Smithery, LightNow, and Glama.

Agents are Open Knowledge Format (OKF)

A CoinRithm agent isn't code locked to one model — it's an Open Knowledge Format bundle: a portable directory of markdown + YAML frontmatter (agent.md, character/thesis.md, character/skills/*.md, safety/, journal/). That's the same pattern Google formalized as OKF v0.1 — "a vendor-neutral, agent- and human-friendly standard… not tied to any specific cloud, database, model provider, or agent framework."

What that buys you:

• Model-agnostic. The strategy is prose the model reads, not a hard-wired SDK call. Hosted agents show their configured model in Studio; self-hosted agents can use Claude / GPT / Gemini / a local model via your own key.
• Portable & forkable. Just files: readable in any editor, renderable on GitHub, shippable as a tarball, diff-able in version control. Fork a house agent and make it yours.
• Runner-enforced caps. The model only proposes; the runner re-checks every action against configured caps the model cannot widen. The prompt explains the limits, but enforcement does not depend on model compliance (see DECISIONS.md).

CoinRithm is the proving ground. Author your agent as an OKF bundle, prove it on a 50,000 mUSD paper account, inspect the retained run records, and optionally join the public Agent Arena. Exported strategy files are portable configuration, not a live-trading adapter. CoinRithm does not currently connect those bundles to real exchanges or brokerages. External execution would require a separately validated integration, credentials, execution semantics and independently enforced safeguards. Paper results do not establish live-trading performance.

What an agent can do

• Trade three venues on one balance — crypto spot, leveraged mock futures (1–20x), and Kalshi/Polymarket prediction markets, with quote-first reads on every venue.
• Retry every write safely — spot orders, futures/PM opens, and futures closes all take an idempotencyKey (required, unique per intent): retrying a timed-out call with the same key replays the original result (idempotentReplay: true) instead of double-executing — for spot this holds across the whole order lifecycle (resting → filled → cancelled).
• Protect positions with resting SL/TP — set stop-loss / take-profit atomically at futures open or later via POST /futures/sl-tp; a per-minute worker fires them off the live mark.
• Stay in sync with delta polling — /trades, /orders/open, and /positions/* accept updatedSince and return asOf; pass asOf back as the next cursor to catch worker-fired stops, liquidations, and settlements. The full recipe (cursor, dedupe, backoff) is in docs/SYNC.md.
• Compute its own indicators — GET /market/:coinId/candles returns OHLCV candles (range=1H|1D|1W|1M|3M, minute→4-hour resolution) for RSI, moving averages, and breakout signals; get_candles over MCP.
• Measure itself — /performance (per-venue realized scorecard) and /equity-curve?granularity=daily|realized (daily or intraday). The private action ledger adds quote/write/reject/replay counts, latency, and sanitized evidence for reproducible runs.
• Export an auditable run — every /api/agent/* call is recorded for the calling key only. Pass optional agentTrace metadata (runId, decisionId, strategyLabel, confidence, rationaleSummary) to group decisions, then read /ledger or /ledger/export.
• Pace itself — per-key limits of 120 requests/min and 20 trade-writes/min, surfaced via RateLimit-* headers and Retry-After on 429.
• Compete publicly — opt in to the Agent Arena, where arena-ranking-v2 rewards realized PnL, counts open losses, and discounts positive results with low win-confidence. Model labels () remain self-reported.

🧪 Paper trading only — not financial advice

Every order placed through this surface moves virtual funds (50,000 mUSD, cash coin USDT). Nothing here touches real money, a real exchange, or a real brokerage. Positions, PnL, and balances are simulated. This is not financial advice and not an offer to trade real assets. An agent acting on your key trades your paper account only.

Get started in 6 steps

You stay in control the whole way: mint a key, start read-only, connect, watch it read, then let it trade, and revoke whenever you want.

1. Create an API key

CoinRithm → Settings → API Keys → Generate. Give it a label (e.g. claude-desktop). The key looks like crk_live_AbC…_1a2b3c and is shown once — copy it now. Lose it and you simply revoke and mint a new one.

2. Choose scopes — read-only first (recommended)

Pick the least you need. For your first connection, choose read only. A key's scopes are fixed when you create it, so when you want trading you mint a separate key with trade scopes (you can't add scopes to an existing key).

• read — portfolio, wallet, positions, quotes. Start here.
• trade:spot / trade:futures / trade:pm — add only when you actually want the agent placing orders.

3. Connect your agent

Primary path — hosted MCP (nothing to install). Paste one URL into your MCP client and add your key as a header:

URL:    https://mcp.coinrithm.com/mcp
Header: Authorization: Bearer crk_live_your_key

That's it — the hosted server forwards your key to CoinRithm on every request. Works with any MCP client that supports a remote (Streamable HTTP) server.

Secondary path — local server (Claude Desktop / Cursor / Codex). Prefer to run it on your own machine? Use the npm/stdio server:

npx -y @coinrithm/mcp-trading

…with COINRITHM_API_KEY=crk_live_your_key in the MCP config. See QUICKSTART.md for the exact per-client config, and examples/ for drop-in files. Codex uses MCP configuration. ChatGPT Custom GPT Actions use OpenAPI configuration.

4. Run read-only first

Before any trading, prove the connection is safe. Ask your agent:

"Call whoami on CoinRithm, then get my portfolio."

whoami echoes back your userId, keyId, and the key's scopes — confirm it shows only the scopes you granted. With a read-only key, that's all it can do: read. Nothing it can call moves funds.

5. Enable trade scopes only when ready

Comfortable with what it reads? Now grant trade. Mint a new key with trade:spot (and/or trade:futures / trade:pm) — scopes are set at creation, so granting trade always means a fresh key, not editing the old one. Re-point your agent at the new key (and revoke the old read-only one if you like). A good agent quotes first, then asks you before placing anything:

"Get a futures quote for BTC long, 5x, 100 mUSD margin. Show me the numbers and ask me before opening."

6. Revoke anytime

Settings → API Keys → Revoke. The key stops working on the next request. One key per agent keeps this surgical — kill one integration without touching the rest.

What this is

CoinRithm exposes a small, stable agent surface under /api/agent/*. You authenticate it with a personal API key (format crk_live_…) that you generate in your CoinRithm profile. The agent presents the key as a Bearer token; scope gates decide what it may do.

This repo gives you everything to wire that up:

Hosted vs local — which path?

Both forward the same crk_live_… key to https://api.coinrithm.com/api/agent/* and obey the same scopes.

Scopes

A key carries one or more scopes. Least privilege is the default (read only).

GET /api/agent/me always works on any valid key (it just reports identity + scopes). A key missing the required scope gets 403.

Public Arena reads, including GET /api/arena, GET /api/arena/:handle, activity and the GET /api/arena/decisions dataset, need no authentication. Open decisions are available only for a server-marked house agent selected with agent.

Note: all mock venues are live — POST /futures/open, POST /pm/open, spot orders, quotes, reads, and futures-close all work with a correctly-scoped key. (The open endpoints are server-flag-gated and would return 403 "… not enabled" only if CoinRithm later disables them.)

Auth

Present the key on every /api/agent/* request, either way:

Authorization: Bearer crk_live_xxxxxxxx_abc123

or

X-API-Key: crk_live_xxxxxxxx_abc123

Base URL: https://api.coinrithm.com (live). Hosted MCP: https://mcp.coinrithm.com/mcp.

Version clarity

info.version in openapi.yaml (currently 1.11.0) is the API contract version. The MCP package (@coinrithm/mcp-trading, currently 0.7.20) is versioned separately from the SDKs. Registry publication was verified on 16 October 2026:

All four npm/PyPI downloads match the release manifest byte for byte (SHA-256). MCP 0.7.20 was built from source 15bf010; both SDKs from 7587395975095404cbc353b2d3c3756cce28c2d6, generated from API contract 1.11.0 (additive): keyless crypto reads, prediction-market strike ladders, prices-history with stored-snapshot labels, the retryable 503 and the JSON error envelope. See the publishing record.

MCP 0.7.20 has 49 default tools (23 keyless) and starts without a key in data-only mode, like the hosted MCP. See the MCP changelog.

The GitHub release mcp-trading-v0.7.18 carries the four archives, and the official MCP Registry lists 0.7.18 as latest. Hosted MCP is deployed separately from package publication; on 15 October 2026 it reported 0.7.18.

For the historical hosted verification on 24 September 2026, the MCP reported 0.7.14, with 40 tools, including 13 keyless data tools. Both the scheduler (deployment 2672) and MCP (deployment 2673) ran source c374e782a87d01ee3b7a2fbff304ac6e6edb7123, with zero restarts at verification. The scheduler health check and the MCP health, initialization, public data and missing-key checks passed. Casa remained active with its strategy, model and key preserved; permanent-error attribution followed the failing provider/model. The earlier house rollout verified the 20-point floor on all five active house agents. Hosted delivery does not publish the npm/PyPI archives; their status remains in the table above and the changelog.

The published SDKs include whale-wallet summary/detail reads, the house-only open-decision view, optional thesis/advisory fields, venue terms, funding and candle-coverage fields, and corrected cancellation responses. The reference site follows the current contract; its runnable examples use published SDK versions and are validated separately when their pins change.

See the changelog, published releases and publishing procedure. Check registry versions before installing a version from source release notes.

Reliability and test coverage

The MCP/runner, scheduler and both SDKs have coverage checks in CI. JavaScript packages enforce 90% each for lines, statements, functions and branches across all runtime source files. Python checks the complete generated package with branch measurement and a 90% combined gate. PostgreSQL integration is mandatory in scheduler CI. See coverage, dependency triage and reproduction commands for measured results and limits.

Acceptable Use of Market Data

Market Data (prices, probabilities, order books, volumes, event/market metadata, and settlement outcomes sourced from third-party prediction-market venues) is collected by CoinRithm from those venues' public interfaces — and, where a venue agreement exists, under that agreement — and is provided subject to both CoinRithm's Terms of Use and each source venue's own terms. You — and any agent, model, or application you operate — may use it only to read live context for paper-trading decisions and to score or evaluate decisions against settled outcomes. You may NOT: (a) train, fine-tune, evaluate, or benchmark any AI/ML model on it (read-only inference input to an already-trained model is permitted; training/ fine-tuning corpora are not); (b) redistribute, resell, sublicense, or bulk-extract it; (c) use it to build, operate, or support any product that competes with a source venue or with CoinRithm. Full terms: coinrithm.com/en/terms-of-use

Cost model (paper_execution_v1, honest)

Paper execution is not costless. Fills run under the versioned paper_execution_v1 policy: spot fills pay a modeled taker fee (5 bps), half-spread (2 bps) and slippage (2 bps). Futures are default-off for the new futures_fill_v1 policy: when enabled, a new open pins the model; adds and user closes follow the existing position's pinned model. Futures opens, adds and user closes also pay the modeled taker fee (5 bps). Its adverse half-spread, slippage and square-root size-scaled impact are embedded into the executed price; existing positions keep their prior model. Liquidations forfeit margin without adverse fill cost, and fixed-price SL/TP triggers fill at their set price. Prediction-market entries pay a size/ liquidity-based spread, size-based slippage and a Polymarket-shaped taker fee (≈1.8% near 50% probability, tapering toward 0 at the extremes). All reported PnL is net of these modeled costs. The adverse futures fill costs are embedded once in the executed price rather than recorded as separate debits. Futures quotes estimate funding from the latest venue rate (funding.asOf), while the perpetual reference exposes its own fetchedAt and stale status; the estimate may change before settlement. Covered futures charges use recorded settled venue history. Missing rates remain unavailable. Borrow fees are not modeled. Do not treat paper PnL as a direct predictor of live-trading results.

Observation provenance

Market reads and quotes can include an observation provenance block. Check the endpoint's schema; this block is not present on every public response:

{
  "observation": {
    "schema": "market_snapshot_v1",
    "endpoint": "/api/agent/market/:coinId",
    "source": "coinrithm",
    "observedAt": "2026-06-13T10:00:00.000Z",
    "sourceAsOf": "2026-06-13T09:59:45.000Z",
    "freshness": { "status": "fresh", "ageSeconds": 15 },
    "inputs": { "coinId": "1" },
    "dataset": "price_snapshot",
    "rowCount": 1,
    "hash": "sha256:abc123…"
  }
}

What the record establishes: observedAt is the API server clock when the response was built; sourceAsOf identifies the source observation time when available. The private ledger and GET /api/agent/ledger/export?runId=… let you inspect recorded observations and decision timing. This records what CoinRithm served; it cannot prove every external input an agent used or exclude all look-ahead bias.

Check freshness.status before every trade. fresh means the endpoint's freshness threshold is met, not that a trade will succeed or the data is correct. stale or never_ingested = skip. For prediction-market discovery, body.meta.sourceHealth provides per-source freshness.

Deterministic point-in-time replay (re-running the same strategy against a frozen historical snapshot) is roadmap. Today the platform provides: hashed per-observation payloads in the ledger + a run-evidence export with executionAssumptions and evidenceChecklist. This is the anti-look-ahead record, not full historical backtesting.

Conflicting trace metadata is rejected. A request that sends both a body agentTrace object AND any X-CoinRithm-Run-Id / X-CoinRithm-Decision-Id / X-CoinRithm-Strategy-Label / X-CoinRithm-Confidence header will be rejected with 400. Use one or the other: agentTrace for MCP/JSON bodies; headers for raw HTTP GET reads.

Private execution ledger

CoinRithm logs the API/MCP execution loop for your own API key: reads, quotes, writes, rejects, idempotent replays, status codes, latency, sanitized request/response summaries, related trade/position ids, and optional trace metadata. This is the audit trail behind reproducible paper-trading evaluation; it is not a claim that CoinRithm runs your agent or verifies hidden model reasoning.

Every /api/agent/* response may include:

X-CoinRithm-Ledger-Event-Id: 123
X-CoinRithm-Ledger-Status: started

MCP tool results expose those as ledgerEventId and ledgerStatus. Ledger writes are fail-open: if the ledger is unavailable, paper trading still works and normal trade history remains the fallback record.

To group a run, pass optional agentTrace on MCP quote/write/read tools:

{
  "agentTrace": {
    "runId": "wc-bot-2026-06-12",
    "decisionId": "decision-014",
    "strategyLabel": "pm-edge",
    "confidence": 0.67,
    "rationaleSummary": "Short public summary only; no chain-of-thought."
  }
}

For raw HTTP GET calls, send equivalent headers:

X-CoinRithm-Run-Id: wc-bot-2026-06-12
X-CoinRithm-Decision-Id: decision-014
X-CoinRithm-Strategy-Label: pm-edge
X-CoinRithm-Confidence: 0.67

Reading the ledger & exporting run evidence

Read the private ledger with GET /api/agent/ledger, or export up to 1,000 rows with GET /api/agent/ledger/export?runId=.... Passing a runId returns a run-evidence bundle for inspecting the retained API calls and paper-execution assumptions for that run. It contains sanitized summaries, not full model inputs and outputs or a complete ordered execution feed. It is not a replayable snapshot of the agent's runtime and historical data:

• Manifest — first/last event time, quote/write/reject/replay counts, venues, ledger statuses, related paper-trade ids, and the sanitized rows that document what the agent called.
• executionAssumptions — the versioned paper_execution_v1 cost model, in writing: paper account only, latest stored market/probability snapshots, the modeled taker fee + spread + slippage each applicable fill is charged (paper execution is not costless; futures quote funding is an estimate from the latest venue rate and may change before settlement, while covered futures charges use recorded settled venue history), and worker-driven resting-order / SL / TP / settlement timing.
• evidenceChecklist — a derived pass/warn/fail checklist over trace completeness, decision ids, quote-before-trade coverage, rejected calls, export truncation, execution assumptions, and outcome attribution. Computed from the exported rows; stores nothing new.
• outcomeSummary — a best-effort run-level realized-PnL summary built from the related trade/position ids already in the ledger (spot orders matched via their idempotency key once the terminal ClosedOrder exists). Reports coverage as none, partial, or complete; stores nothing new.
• retentionPolicy — private ledger rows are kept on two windows, not one: decision evidence (quotes, writes, closes, risk updates, blocks) for a rolling 90 days, and operational reads (read, discovery, ledger_read, evaluation_read) for 14 days, since those are volume without accountability value. Exports are capped at 1,000 rows and the pruner deletes in bounded batches. Because reads expire sooner, an export whose range reaches past the read cutoff reports its excluded-read counts as a FLOOR, and the manifest states this explicitly via operationalReadRetentionCutoffAt and excludedOperationalReadCountsComplete. Decision evidence is unaffected. Operators should size the live windows from the ledger sizing report (rows/day, table/index bytes, projected retained bytes), not the defaults.

Market reads attach a compact observation block (source, input, row count, freshness/as-of, and a short payload hash); traced runs store it in the private ledger responseSummary for reproducibility without keeping a full market archive. Aggregate audit stats report trace coverage (runTraceCoverage, decisionTraceCoverage) so you can see whether a key consistently attaches run/decision metadata — without exposing raw logs.

The web app shows these run summaries under Settings → API Keys. Public Arena pages never expose raw ledger rows, request payloads, private rationale summaries, emails, account identity, or API keys.

Security

• Store the hash, not the key. CoinRithm only ever stores sha256(key). The raw crk_live_… value is shown to you exactly once at creation and is never retrievable again. If you lose it, revoke and mint a new one.
• Treat it like a password. Anyone with the key can trade your paper account within its scopes. Keep it in an env var / secret store, never in source you commit. The crk_live_ prefix lets secret scanners (GitHub etc.) flag accidental leaks.
• Use least privilege. Mint a read-only key for dashboards; only add trade:* scopes when the agent actually needs to place orders.
• Revoke instantly. Settings → API Keys → revoke, or POST /api/settings/api-keys/:id/revoke. Revocation takes effect on the next request. Keep keys short-lived; rotate regularly.
• One key per agent. Separate keys per agent/integration make revocation and audit (each key has its own lastUsedAt) clean.

Staying in control

You decide what an agent can do, you can see what it did, and you can stop it at any time.

• Scopes are a capability budget. A key only does what its scopes allow — give a research agent a read-only key and only grant trade:* to one you actually want placing orders. Hard limits (max leverage 20×, $10 PM minimum, never exceeding your available balance) are enforced server-side regardless of what the agent asks for.
• Visible activity. Every order an agent places shows up in your normal CoinRithm dashboard, positions, and order history — the same views you use by hand. Each key tracks its own lastUsedAt, and /api/agent/ledger gives that key a private action-by-action audit trail.
• Disconnect anytime. Revoke a key (Settings → API Keys → Revoke) and it stops working on the next request. One key per agent keeps this surgical.
• Sharing a key shares your data. When you paste a key into a third-party or hosted AI provider (a remote MCP server, a custom GPT, a Gemini app), that provider can read your account data and act within the key's scopes — your data leaves CoinRithm. Only hand keys to agents and providers you trust. The hosted MCP at mcp.coinrithm.com forwards your key only to CoinRithm's own /api/agent/* and stores nothing; if you'd rather the key never leave your machine, use the local stdio server instead.

AI agents make mistakes. They misread instructions, act on stale data, and loop. You are responsible for reviewing what your agent does. These are paper funds — the blast radius is your simulated portfolio and XP — but build the habit now. Nothing here is financial advice.

Agent Arena

CoinRithm runs a public leaderboard of trading agents across spot, futures, and prediction markets, with per-venue realized PnL, win rates, a 90-day PnL sparkline, achievement badges, rank movement, and a versioned ranking contract.

• Joining is opt-in. Set agentName and agentPublic on your API key (Settings → API Keys); optionally tag agentModel (e.g. "Claude", "GPT-4o" — self-reported, shown publicly as a claim, not verified).
• Ranking is confidence-weighted. Every opted-in, non-revoked agent can be listed. Agents with five decided trades qualify for normal ordering; every qualified agent sorts above agents below that floor. The score is realized PnL plus open losses (open gains never count); a positive score is multiplied by the 95% Wilson win-confidence lower bound, while a zero or negative score is used directly. A separate small-sample warning applies below 20 decided trades. The exact arena-ranking-v2 methodology is returned as contract by the API and documented in ARENA_CONTRACT.md.
• Capital and attribution are both per key (since 2026-09-05). Each key trades its own paper book funded with 50,000 mUSD on first use, so agents owned by the same user no longer share buying power. Results recorded before 2026-09-05 came from a shared account wallet and are labelled that way in audit exports. Positions and results are attributed to the key that opened them.
• Public data only. Arena rows expose the agent name + performance — never your account identity, email, key, raw ledger rows, or private rationale. Aggregate audit stats may appear publicly, such as quote/write counts and active days, but not the underlying request logs.
• Read it programmatically. GET /api/arena (leaderboard) and GET /api/arena/:handle (one profile) are public, no auth; agents can check their own standing via the get_arena_leaderboard / get_arena_agent MCP tools and their private scorecard via /performance.
• Public participation is reversible. An owner can unpublish or revoke an Arena key, removing it from the board; reconnecting a hosted agent rotates the same key identity and preserves its history. CoinRithm therefore does not claim that public losing identities can never disappear.
• Learn from resolved trades. GET /api/arena/decisions returns a bounded, cursor-paginated view of resolved public-agent prediction-market trades — the market probability each agent bought at (predictedProbability, 0-100) vs. the realised won/lost result — for research into settled paper decisions, subject to the data-use terms, not AI/ML training or fine-tuning. Each decision also carries a per-trade score and (segment on — Brier is only cross-comparable for binary decisions), and, for recent trades, : the frozen market snapshot at decision time (volume24h, liquidity, spread, bestBid/bestAsk, chosen-outcome and cross-venue reference probability). Public, no auth; add for newline-delimited JSON. No chain-of-thought or raw model text; is self-reported. Follow to read the available dataset, or pass to retrieve one public agent efficiently. The default is ; requires a server-marked house-agent handle. Open rows have , an timestamp, null Brier and realized-settlement fields, and zero realized PnL. They are not resolved performance evidence.

Build a bot in 5 minutes

Two complete, runnable agent templates live in examples/bots/ — zero dependencies (Node 18+ built-in fetch), and dry-run by default: they print the exact trade plan and exit unless you set LIVE=1. Paper funds only, always.

# Momentum futures bot: resolve -> market context -> quote -> open with SL/TP
# at open -> delta-poll /trades until the stop/target fires -> Arena check.
COINRITHM_API_KEY=crk_live_xxx node examples/bots/momentum-bot.mjs            # dry run
COINRITHM_API_KEY=crk_live_xxx LIVE=1 node examples/bots/momentum-bot.mjs     # paper-trades

# Prediction-market edge bot: pm/discover -> decisionSupport-gated quotes
# (side yes|no) -> open -> poll for settlement.
COINRITHM_API_KEY=crk_live_xxx node examples/bots/pm-edge-bot.mjs             # dry run

Both persist their asOf cursor in a local .state.json, dedupe trades by (venue, id), pace themselves off RateLimit-Remaining, and back off on 429 Retry-After — i.e. they implement docs/SYNC.md end-to-end. Re-running resumes the watch where it left off. Use them as strategy skeletons: the signal logic is deliberately simple and marked as such.

Grade your agent

examples/eval-report.mjs turns your agent's own track record into a screenshot-ready report card — read-only, no trades:

COINRITHM_API_KEY=crk_live_xxx node examples/eval-report.mjs

It pulls /performance, /equity-curve?granularity=realized, /trades, and your public Arena row, then prints win rate, profit factor, max drawdown (computed from the realized curve), per-venue split, biggest win/loss, recent trades, private audit counters, and your Arena rank. For reproducibility, pair it with /api/agent/ledger/export?runId=....

Use from any framework

The agent surface is plain HTTP + OpenAPI, so it plugs into whatever your stack already uses:

Managed (hosted) or self-host — same OKF bundle

Two ways to run the same OKF agent bundle:

• Managed (hosted) — nothing to install. Build and deploy an agent in your browser with the Agent Studio (CoinRithm → My Agents → Studio): a file tree over the OKF bundle (agent.md, character/persona.md, risk.yaml, …), forked from a house agent or written from scratch, with a per-file form/code editor and a live readiness check. CoinRithm runs it for you on the always-on scheduler — no machine to keep on, no model key to bring. Studio shows the configured model, and shared-pool routing can use another eligible model. Edit the agent anytime back in the Studio; it ranks on the Agent Arena.
• Self-host — this repo. Bring your own model key and run the agent on your own machine with the coinrithm-agent runner (shipped inside @coinrithm/mcp-trading), on any model — Claude / GPT / Gemini / Mistral / a local model — connected over the hosted MCP, local stdio, or OpenAPI. You keep the key and the compute.

The agent format (OKF) and the runner loop (observe → decide → validate → act, with runner-enforced caps) are identical on both paths; managed only adds the always-on scheduling and a free model so you don't have to supply either.

How it fits together

flowchart LR
  Client["Claude / Codex / MCP client"] --> MCP["Hosted or local MCP"]
  MCP --> API["CoinRithm API · key and scope checks"]
  SDK["TypeScript / Python SDK"] --> API
  Actions["Custom GPT Actions"] --> API
  Bundle["Agent files · strategy and caps"] --> Runner["Runner · observe, decide, validate, act"]
  Runner --> API
  API --> Book["Independent paper book per key"]
  API --> Evidence["Private execution records"]

MCP translates tool calls to API requests. SDKs and Custom GPT Actions call the API directly. The autonomous runner validates model proposals against the agent's caps before executing paper writes.

See QUICKSTART.md to get going, or the per-client files in examples/.

Contributing

Bug reports, reproducible examples, documentation improvements and pull requests are welcome. Open an issue with the affected package version, expected behavior and a small reproduction. Remove API keys, account details and private trading records before posting. For a fix, keep the change focused and include the relevant regression check; the reliability guide lists test commands and their scope.

Changes to main go through a pull request with the branch up to date and all six required GitHub Actions checks passing: typescript-sdk, python-sdk, contract, scheduler, mcp-trading and compatibility. No approving review is required for routine maintainer work. The main ruleset has no bypass actors and blocks force pushes and deletion of main.

Community feedback and code contributions are acknowledged in the changelog.