# Cubicle

> Cubicle: trading tools for AI agents and the people they work for. Turn a trading rule into a deterministic state machine and rehearse it on real candles, read the tape (NQ, ES, YM, BTC, ETH, SOL), study and follow trading models with verifiable records (copy-trading), hire the house Accumulate strategy to run your own Robinhood Chain vault (spot, USDG) that only you control, and pay for a plan on chain from your own wallet (pro-50: 50 USDG per 30 days, the cheapest plan, no card, no human in the loop).

## Connect an agent

- MCP server (streamable HTTP): https://cubicle.algotrada.com/deck/api/mcp
- Per-service MCP endpoints: studio https://cubicle.algotrada.com/deck/api/mcp/studio; candles https://cubicle.algotrada.com/deck/api/mcp/candles; copy https://cubicle.algotrada.com/deck/api/mcp/copy
- MCP server card: https://cubicle.algotrada.com/.well-known/mcp/server-card.json · A2A agent card: https://cubicle.algotrada.com/.well-known/agent-card.json
- No key needed for: initialize, tools/list, catalogue, plans, strategies, strategy_quote, price, digest
- OpenAPI (HTTP routes): https://cubicle.algotrada.com/deck/api/openapi.json (also .yaml)
- A free key: https://cubicle.algotrada.com/deck/join?from=agent (or POST https://cubicle.algotrada.com/deck/api/join); send it as `Authorization: Bearer <key>`
- SDK (open source, MIT, zero dependencies): https://github.com/yawningmonsoon/cubicle-sdk · `npm install -g cubicle-sdk` · the walkthrough: https://github.com/yawningmonsoon/cubicle-sdk/blob/main/docs/walkthrough.md

## Offerings and prices (the one catalogue: /deck/api/catalogue)

- Tape candles: 0.005 USDC a call (free inside any plan's allowance; the free `price` tool gives the latest close with no key); buy with the `tape` tool
- Trading model records: 0.02 USDC a call (free inside any plan's allowance); buy with the `model_record` tool
- Studio: a rule into a machine: 0.05 USDC a call (3 forges a day free without a plan; unlimited inside a plan's allowance); buy with the `forge` tool
- Plan pro-50 (the cheapest): 50 USDG per 30 days on chain 4663; buy with the `plans` tool
- Plan premium-99 (copy-trading): 99 USDG per 30 days on chain 4663; buy with the `plans` tool
- Hire the Accumulate strategy for your vault: a volume fee of at most 0.3% per trade plus a fee on realised profit above the high-water mark, in the signed mandate (opening a vault is free; the vault takes the fees on each trade); buy with the `vault_prepare` tool

## Pay for a plan (on chain, no card)

1. Call the `plans` tool with a plan id: it returns the price and the exact USDG transfer on Robinhood Chain (chain 4663).
2. Send it from your own wallet; nothing is signed by Cubicle.
3. Sign the claim message the `plans` tool gives you with the paying wallet and call `plan_claim`.
Plans page: https://cubicle.algotrada.com/deck/plans

## Vaults

- Robinhood Chain vaults (mainnet, USDG): open to any wallet since 2026-10-07 (no invite list, no deposit cap), owner-only control (only the owner deposits, withdraws, revokes or freezes), a hired strategy trades under a signed mandate with per-order and open caps, and the house Accumulate operator is live for hire; the contracts are not externally audited yet, so deposit only what you can afford to lose.
- `vault_prepare` returns the unsigned transactions; the owner's wallet signs them.

## Free tools

- `catalogue`: The whole Cubicle API as data: the studio's eight-state machine and what each gate asks, every tool with the tier that opens it (and whether it is open to the caller), and the flows. Call it first when asked what Cubicle can do.
- `plans`: The Cubicle plans (price per 30 days, what each includes) and exactly how to pay on Robinhood Chain in USDG: the treasury, the token, and — when the subscription vault is live — the two wallet transactions (approve, subscribe) that renew automatically every 30 days. Nothing here moves money: the trader signs in their own wallet.
- `strategies`: The strategies anyone can rent to run a Cubicle spot vault (today: accumulate, which buys a fixed amount of ETH or BTC on an interval up to a budget and never sells): what each does, its parameters, the venues and assets, the limits the vault itself enforces, the fee, how to rent it, and its honest status (not live with real funds yet).
- `digest`: FREE, no key: the sha256 (or keccak256) digest of a text, as 64 hex characters, computed here. Agents, registries and the coordination layer use it to check that this server answers with content they can verify by code; it is also a plain utility. Nothing is stored.
- `price`: FREE, no key, no sign-in: the tape's latest price for one market (NQ, ES, YM, BTC, ETH or SOL) with the time of that 1-minute close and whether the tape is stale. Use it whenever an agent needs a current price; it is the same tape every Cubicle vault checks its orders against. For a window of candles use tape (needs a key).
- `strategy_quote`: A live quote for one accumulate buy on Robinhood Chain: what a USD amount of USDG buys of ETH or BTC on the best Uniswap route right now, the tape's price, the cost against the tape in bps, and whether the vault's own price rule (at most 1% worse than the tape) would accept it. A static call: nothing is signed or sent.

## Tools with a key

- `account`: The caller's Cubicle account: their tier (free, Cubicle Operators holder, pro-50, max premium-99), their plan and until when, and every capability with whether it is open and which tier opens it.
- `plan_claim`: Claim a plan you paid for on chain: give the payment's transaction hash and the paying wallet's EIP-191 signature over the exact message the plans tool returns ("Cubicle plan claim\nagent: <your agent id>\ntx: <tx hash>").
- `models`: The trading LLM models on the Taifoon venue a trader can study and, on the max plan, follow: each with its status (trading or stopped, derived from its last trade), markets, fills, realized PnL and win rate — all read from the venue, never from a model's words.
- `desk_read`: The house Nemotron desk (llm-nemotron-fest) as it is: its last turn (every 30 minutes), each market's decision and which reader decided it (the vote rule the Nemotron answers, or Jev), the facts it read, and the venue's own positions with realised and unrealised PnL.
- `model_record`: One trading model's record from the venue's first-in-first-out paired closes: realized PnL, maximum drawdown, win rate, per market, and the window.
- `follow_quote`: Quote following a trading model (max plan): checks the model is live and followable, validates the follower's sizing (fixed_notional usd, or proportional bps of their balance) and caps (max_notional_usd, max_open_positions, max_daily_loss_usd, markets the model trades), and shows what one mirror would be at the given balance.
- `follow`: Follow a trading model (max plan): creates the follow record — the model, your sizing (fixed_notional usd, or proportional bps of your balance), your caps (max_notional_usd, max_open_positions, max_daily_loss_usd, markets) and optionally the wallet your own runner will sign with.
- `stream_key`: Cubicle's paid signal stream on the Taifoon coordination layer (pro-50 or premium-99): the desks' world-clock signals and Kronos forecasts arrive as kind signal from venue cubicle, sealed with a topic key per UTC day.
- `follows`: Your own follow records (max plan): every follow you created, active, stopped or replaced, with its digest and attribution.
- `unfollow`: Stop following a model at once (any tier may stop): the active follow record is marked stopped and kept; open mirror positions stay yours to manage.
- `my_vaults`: The caller's trading vaults, read from the chain: each with whether its funds are devnet (test money) or mainnet (real), what is in it, what is free, what is set aside as margin, the mandate and who administers it..
- `operator_link`: Make a wallet the venue's payout wallet for this principal (S1 step 4).
- `step_up_receipt`: A five-minute proof that the account's owner passed their second factor, for the venue's vault: send it as the x-step-up header of POST /vault/withdraw (api.taifoon.dev/vault/withdraw) with your key.
- `vault_prepare`: The wallet steps for a Cubicle vault as UNSIGNED transactions and EIP-712 typed data for the owner's own wallet.
- `script_validate`: Validate a cubicle.script v1 (the YAML text) with the reference validator: the JSON report with every diagnostic (codes C000–C095, file:line:col) and the budget (warm-up bars, memory, nodes per bar).
- `script_rehearse`: Step a cubicle.script v1 over the deck's own bars with the deterministic reference runner (cubicle-script run): one frame per bar (state, every gate's truth and the two sides it compared, fields, vars, position, order, fill, log), the summary (trades, wins, sum R, final state, blocked counts) and the frame hash — the run's receipt.
- `onboard`: Where a wallet stands on the way to a funded Cubicle vault, read from the chain (gas, USDG in the wallet, its accounts, the factory's invite gate), and the ONE next step with the tool that does it: connect, add gas, open a vault (vault_prepare), buy USDG with a card (fund_with_card) or send it, fund the vault (vault_prepare), or ready.
- `fund_with_card`: A link to buy USDG on Robinhood Chain with a card, bank transfer or Apple/Google Pay through MoonPay, paid straight into the trader's own wallet (Cubicle never holds the money).
- `session_size`: How big to trade the crypto session that is open now (BTC, ETH, SOL): full size when the session is expected to move more than usual, reduced when it should be quiet.
- `weather`: The weather over a market: the tone the last 72 h of news headlines set (each headline tagged up, down or flat by Cubicle's house model; the tone and its band are computed in code from those tags, recency-weighted), the headlines themselves with their times and links, the tape's regime (trend, drift or chop by the efficiency ratio of the last 48 five-minute closes) and one word for the sky (clear, crosswind, overcast, fog).
- `workflow_read`: Read a trading idea the way the studio does: the deterministic reader fills the 7 parts (markets, trigger, direction, stand aside, stop, target, session) from the trader's OWN words and says which required parts are still missing.
- `reverse`: Reverse-engineer what the trader POSTED before saying anything about it: a rule in words, a pasted Pine script (read statically, never run) or a chat transcript.
- `studio_move`: Move the trader's rule through the studio's state machine when forge is refused: score_parts (Jev scores clarity — needs the trader's own TypeSafe key), accept_parts (the trader accepts the rule as read, without a Jev score), choose_coverage with choice approximate (build from the gates the tape can measure) or stop, reset (start over).
- `forge`: The studio machine's FORGED move: compiles the trader's strategy from the gates the tape can measure into a cubicle.script v1 (the file the reader gate grades; its runner hash is the seed).
- `grade`: Grade a forge with Jev (RUBRIC_v1): code checks the facts first, then Jev answers whether the code does what the trader said.
- `rehearse`: Run the forged cubicle.script over the real tape with the reference runner, cubicle-script, net of 8 bps a round trip (the last week by default): how many trades it took, the R, and a comparison with a random null.
- `watch_fields`: What a strategy test reports at every step the strategy takes: the trader's current list, and the whole vocabulary, grouped by indicator (price, volume, RSI 14, EMA 20, EMA 60, VWAP, the Bollinger bands, the 20 bar range, bar size, the 50 bar mean, the clock).
- `watch_set`: Set what the trader's strategy tests report at every step: up to 8 items, each a field id from watch_fields or an expression over those fields (numbers, + - * / and brackets, optionally one comparison with < > <= >=).
- `strategy_steps`: The steps the trader's last tested strategy took on one market, as the test engine reported them: each step's time, the move (ready to in a trade, and so on), the conditions true at that bar, the trade it opened or closed, and the watched items' values at that bar.
- `tape`: Read real candles from the Taifoon tape for one market.
- `forecast`: The envelope the forecast sidecar had issued for one market and timeframe by a given time: a MAGNITUDE band (how far price may travel over the next 24 bars, as two prices and a width in ATR), the odds of a move of 0.5, 1 and 2 ATR within 6, 12 and 24 bars, and its measured calibration (ece, n, band coverage).
- `chart_state`: What the deck's chart would show for one market, timeframe and window, as ONE JSON object computed in code: the bars (count, first and last, the last candle), the indicators drawn, the trader's own marked levels and zones (theirs — they may be used as levels the trader gave), the envelope under its draw gate and its facts, and the fact sheet of the window (open, close, high, low, range, change, volume, session).
- `chart_image`: The deck's own chart plate for one market, timeframe and window, rendered server-side from the same geometry the screen uses (bars, indicators, the envelope cone when its calibration permits) as a PNG you can look at, together with the chart_state JSON for the same window.
- `drawings`: The trader's own drawings on one market's chart: lines, boxes, paths and notes, each anchored at bars (UTC times) and prices.
- `draw`: Draw on the trader's chart, as they ask: a line (two points), a box (two corners), a path (2 to 24 points moving forward in time: a zigzag of legs) or a note (one point and a short word).
- `erase`: Remove one of the trader's drawings by its id (from the drawings tool).
- `film`: Seal a past window of the tape into a FILM: the bars replayed one by one with the trader's drawings and marked levels, optionally the structure computed over the bars (pivots, legs, swings and the range they share, none drawn before the bar that confirmed it) and a rehearsed machine's trades.
- `replay_open`: Put the trader's chart and its time compressor on a past window: the market, the window, the speed to play it at and, optionally, the moment to hold on (a trade, a sweep, a touch of a level).
- `replay_record`: Read back what happened in the trader's last replay of one market: every beat on the tape, each of their strategies' trades and state changes, and their own moves (travel, speed, seek), in order with their times, plus the recording's hash (the same at any replay speed).
- `image`: Look at a chart the trader attached (the id is in the studio state).
- `skills`: List the Cubicle skill bank: every skill's name, family, grade and status (runnable / stub / concluded).
- `skill_read`: Read one skill's method (its SKILL.md) — only the methodology and engineering skills are readable; strategy, lens, pillar and copy skills are sealed and will be refused..

## Identity

- Cubicle studio: ERC-8004 agent 96558 on Base, card https://cubicle.algotrada.com/deck/api/cards/studio
- Cubicle candles: ERC-8004 agent 96559 on Base, card https://cubicle.algotrada.com/deck/api/cards/candles
- Cubicle copy-trading: ERC-8004 agent 96560 on Base, card https://cubicle.algotrada.com/deck/api/cards/copy