# Cubicle (remote · cubicle.algotrada.com)

Agent trading tools: candles, copy-trading, hire a strategy for your Robinhood vault, pay on chain

- Trust score: 70/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-18

## Components

- remote · `cubicle.algotrada.com`: 70/100 (this document), [markdown](https://verifymcp.io/servers/com-algotrada-cubicle-cubicle/deck-api-mcp.md), [page](https://verifymcp.io/servers/com-algotrada-cubicle-cubicle/deck-api-mcp)

## Channel facts

- Endpoint: `https://cubicle.algotrada.com/deck/api/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.1.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-18.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: this server exposes a tool marked destructive (studio_move) and its handshake is open, but we could not confirm whether a tool call is gated, so we do not assert it is callable unauthenticated.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 71/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5625 tokens (~140/item across 40 items; 40 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 40/100
  - Stability observed for 12 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 41 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### How do I install the Cubicle MCP server?

Cubicle is a hosted endpoint at https://cubicle.algotrada.com/deck/api/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http com-algotrada-cubicle-cubicle 'https://cubicle.algotrada.com/deck/api/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "com-algotrada-cubicle-cubicle": {
      "url": "https://cubicle.algotrada.com/deck/api/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-algotrada-cubicle-cubicle": {
      "type": "http",
      "url": "https://cubicle.algotrada.com/deck/api/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-algotrada-cubicle-cubicle]
url = "https://cubicle.algotrada.com/deck/api/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-algotrada-cubicle-cubicle": {
      "type": "remote",
      "url": "https://cubicle.algotrada.com/deck/api/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-algotrada-cubicle-cubicle --url 'https://cubicle.algotrada.com/deck/api/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-algotrada-cubicle-cubicle:
    url: "https://cubicle.algotrada.com/deck/api/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "com-algotrada-cubicle-cubicle": {
      "Transport": "http",
      "Url": "https://cubicle.algotrada.com/deck/api/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-algotrada-cubicle-cubicle -t streamable-http -u 'https://cubicle.algotrada.com/deck/api/mcp'
```

### Other

```json
{
  "mcpServers": {
    "com-algotrada-cubicle-cubicle": {
      "type": "http",
      "url": "https://cubicle.algotrada.com/deck/api/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-17 (score 70, +1)

- [functional] New tool “stream_key”

### 2026-10-15 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-13 (score 68, +1)

- [functional] Server version: 1.0.0 → 1.1.0
- [functional] New tool “reverse”

### 2026-10-12 (score 67, +1)

- [functional] New tool “replay_record”

### 2026-10-10 (score 66, 0)

- [functional regression] Schema quality: 4021 → 5106
- [functional] New tool “follow”
- [functional] New tool “follows”
- [functional] New tool “replay_open”
- [functional] New tool “strategy_steps”
- [functional] New tool “unfollow”
- [functional] New tool “watch_fields”
- [functional] New tool “watch_set”

### 2026-10-09 (score 66, +1)

- [security] New tool “erase”, which the server declares destructive
- [functional regression] Schema quality: 2988 → 4021
- [functional improvement] Stability: unverified → 0.10
- [functional] Destructive annotations: pass → 100
- [functional] New tool “draw”
- [functional] New tool “drawings”
- [functional] New tool “film”

### 2026-10-06 (score 65)

First indexed and scored.

## MCP tools (40)

### `catalogue` (~60 tokens)

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.

### `account` (~66 tokens)

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. Call it before telling a trader what they can or cannot do.

### `plans` (~137 tokens)

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.

Input parameters:

- `plan` (string): a plan id (pro-50 or premium-99) to prepare the payment steps for
- `wallet` (string): the 0x address of the wallet that will pay — needed for the renewing subscription, which is authorized for that wallet only

### `plan_claim` (~167 tokens)

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>"). The door reads the transfer to the treasury itself and opens the plan for this principal; only the wallet that paid can claim it. Needs your Cubicle key.

Input parameters:

- `chain` (string): the chain the payment was made on (Cubicle takes plans on Robinhood Chain only)
- `payer_signature_hex` (string, required): the paying wallet's EIP-191 signature (0x + 130 hex) over the claim message
- `tx_hash` (string, required): the payment transaction's hash (0x + 64 hex)

### `models` (~83 tokens)

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. Simulated market-maker and flow actors are never listed.

### `desk_read` (~122 tokens)

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. Composed from the desk's log and the venue, no model asked; a turn older than 45 minutes is marked stale. Not a forecast.

Input parameters:

- `market` (string): one market, or every market when absent

### `model_record` (~84 tokens)

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. Always say what the record is not: a forecast, or what a follower would have made.

Input parameters:

- `model` (string, required): the model's attribution, from the models tool (starts with llm-)

### `follow_quote` (~186 tokens)

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. Creates nothing and moves nothing.

Input parameters:

- `balance_usd` (number): the follower's balance, to show a mirror's size (optional)
- `caps` (object, required): {"max_notional_usd":100,"max_open_positions":3,"max_daily_loss_usd":40,"markets":["BTC"]}
- `model` (string, required): the model's attribution from the models tool
- `sizing` (object, required): {"kind":"fixed_notional","usd":50} or {"kind":"proportional","bps":200}

### `follow` (~258 tokens)

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. Validated exactly as follow_quote; one active follow per model, a new one supersedes it. Returns the record, its digest (the coordination record follow.created) and the attribution every mirror of it is placed under (copy:<you>:<model>). Nothing is traded by this call: your own runner mirrors fills under this record, and it can be stopped with unfollow at any time.

Input parameters:

- `caps` (object, required): {"max_notional_usd":100,"max_open_positions":3,"max_daily_loss_usd":40,"markets":["BTC"]}
- `follower_wallet` (string): the 0x address your runner signs mirrors with (optional now; required once the venue enforces per-order auth)
- `model` (string, required): the model's attribution from the models tool
- `sizing` (object, required): {"kind":"fixed_notional","usd":50} or {"kind":"proportional","bps":200}

### `stream_key` (~221 tokens)

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. Register your X25519 PUBLIC key (make a pair with `npx -y @taifoon-io/sdk coord keygen --out FILE`; the secret never leaves your machine) and the day's keys are sealed to it on the stream; you get your holder id, the stream URL and the one SDK command that prints the signals decoded. Call again to have today's keys re-sent; action forget stops it. Ticks and outcomes are public; anyone without a key sees the signal bodies as ciphertext.

Input parameters:

- `action` (string): register (default: register or refresh your key), status (what is registered, nothing changes) or forget (remove your key)
- `x25519` (string): your X25519 public key: 0x and 64 hex characters (needed for register)

### `follows` (~42 tokens)

Your own follow records (max plan): every follow you created, active, stopped or replaced, with its digest and attribution. Yours only — no follower ever sees another's.

### `unfollow` (~60 tokens)

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. Returns the stopped record, or says there was none.

Input parameters:

- `model` (string, required): the model's attribution

### `strategies` (~84 tokens)

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` (~101 tokens)

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.

Input parameters:

- `algorithm` (string): sha256 (default) or keccak256
- `text` (string, required): the text to hash (UTF-8)

### `price` (~102 tokens)

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

Input parameters:

- `symbol` (string, required): the market, by ticker

### `strategy_quote` (~110 tokens)

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.

Input parameters:

- `asset` (string, required): the asset
- `usd` (number, required): USD of USDG to spend

### `my_vaults` (~64 tokens)

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.

### `vault_prepare` (~427 tokens)

The wallet steps for a Cubicle vault as UNSIGNED transactions and EIP-712 typed data for the owner's own wallet. Open: call without vault for the transaction that opens it. Fund and hire: call again with the new vault's address (from my_vaults) for allow + deposit and the mandate to sign. Withdraw: withdraw_shares queues shares, then claim_shares pays what the vault's free funds cover to the owner. Chain 4663 is Robinhood Chain (real USDG; open to any wallet since 2026-10-07, no deposit cap; the contracts are not externally audited, so deposit only what you can afford to lose); 36927 is the devnet (test money). Signs and sends nothing.

Input parameters:

- `administrator` (string): who administers the vault under the mandate (second call), e.g. llm-nemotron-dual
- `chain` (number): 4663 Robinhood Chain (real money) or 36927 the devnet (test money); defaults to the devnet
- `claim_shares` (string): withdrawal step two: whole shares to claim (read claimableRedeemRequest(0, owner) on the vault)
- `deposit_usd` (number): USD of the stable to deposit (second call)
- `kind` (string): what the account is for: spot (trades on Uniswap today) or futures (margin; settles when the venue sends statements)
- `margin_usd` (number): margin vaults only: the most the mandate may ever lose (second call)
- `market` (string): spot administrators only: the market it buys
- `name` (string): a name for the vault
- `owner` (string, required): the 0x address of the wallet that owns (or will own) the vault
- `vault` (string): the vault's 0x address (every call after the first)
- `withdraw_shares` (string): withdrawal step one: whole shares to queue (read balanceOf(owner) on the vault)

### `workflow_read` (~96 tokens)

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. Use it before restating or forging a rule; never fill a part the trader did not say.

Input parameters:

- `text` (string, required): everything the trader has said about the rule, in their words

### `reverse` (~178 tokens)

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. Returns a dossier: the route (what it is and the first tool), findings each marked observation, inference or unknown with an id (E1, E2) and what would settle each unknown, the checklist (market, bar size, trigger, direction, stop, target, stand aside, numbers match the tape, run over recorded bars) as answered, partial or unresolved, and the ceiling (hypothesis until rehearsed). Cite the ids; never present an inference or an unknown as a fact. For an attached chart use the image tool first.

Input parameters:

- `text` (string, required): what the trader posted, verbatim: the rule, the Pine source or the transcript

### `studio_move` (~130 tokens)

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). Ask the trader before accepting or choosing for them; the studio decides every gate, this only performs the move they chose.

Input parameters:

- `choice` (string): for choose_coverage: approximate or stop
- `move` (string, required): the move

### `forge` (~85 tokens)

The studio machine's FORGED move: compiles the trader's strategy from the gates the tape can measure. The studio refuses it unless the strategy has passed READ, CLARIFIED and EXPRESSIBLE — when refused, tell the trader the move the studio is waiting for (it is in the result).

Input parameters:

- `intent` (string, required): the rule in the trader's words, every part included

### `grade` (~81 tokens)

Grade a forge with Jev (RUBRIC_v1): code checks the facts first, then Jev answers whether the code does what the trader said. Spends one of the trader's Jev decisions (trial, plan or their own key). It judges fidelity to their words, never profitability.

Input parameters:

- `seed_hash` (string, required): the seed hash forge returned

### `rehearse` (~106 tokens)

Walk a forged machine over the real tape with the canonical stepper (the last week by default): how many trades it took, the R, and a comparison with a random null. Call it after a forge when the trader wants to know whether the rule actually fires. A rehearsal is evidence about the past, never a forecast.

Input parameters:

- `market` (string): the market to walk, defaults to the one the trader named
- `seed_hash` (string, required): the seed hash forge returned

### `watch_fields` (~145 tokens)

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). Each indicator has named fields (the bands have boll_up and boll_dn, the range has range_high, range_low and range_pos). An item may also be an expression over the fields, such as close - ema20 or rsi14 > 50. Call it before watch_set, and when the trader asks what can be tracked.

### `watch_set` (~147 tokens)

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 < > <= >=). This replaces the list. It applies to the NEXT test, so offer to rehearse again afterwards. An item that cannot be read is refused by name and the rest are kept. Use it when the trader says what they want tracked ('watch the RSI and how far price is from the EMA'): translate their words into fields; never invent a field.

Input parameters:

- `items` (array, required): field ids or expressions, in the order they should be shown

### `strategy_steps` (~182 tokens)

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. Also, per watched item, its average at the entries of winning trades and of losing trades. Use it to answer 'what was the RSI when it bought', 'why did it enter there', 'what do the winners have in common'. These are past bars of one tested week: a description, never a forecast and never advice.

Input parameters:

- `market` (string): the market the strategy was tested on (defaults to the newest test)
- `only` (string): trades = only the steps that opened or closed a trade (default); all = every step

### `tape` (~238 tokens)

Read real candles from the Taifoon tape for one market. Use it to ground an answer in what the market actually did in a past window — never to predict. NQ is not continuous (weekend halt, 21:00 UTC daily break). A past window is SEALED: its bars never change, so cache it. The same tape is open over plain HTTP with no key: GET https://clob.taifoon.dev/tape/v1/candles/{market}/{tf}?from=&to= with unix SECONDS and a User-Agent that names you (OpenAPI: https://www.taifoon.io/clob/openapi.yaml). It is the tape the coordination layer's conformance check replays, so what you read here is what the judge reads.

Input parameters:

- `from` (string, required): window start, ISO-8601 UTC
- `market` (string, required): the market
- `tf` (string, required): timeframe (the time machine serves these; build a 15-minute range from 1m or 5m bars)
- `to` (string, required): window end, ISO-8601 UTC, in the past

### `forecast` (~226 tokens)

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). It carries NO direction — there is no side, no median, and the band is symmetric about the last close by construction; say so, and never turn it into 'up' or 'down'. When calibration reads unmeasured or uncalibrated the deck does not draw it and you should say the band is not yet trusted. Facts only, computed in code; nothing here is a recommendation.

Input parameters:

- `at` (string): ISO-8601 UTC time the envelope must have been issued by (defaults to now); for a replay, the logical clock
- `market` (string, required): the market
- `tf` (string, required): timeframe the sidecar forecasts

### `chart_state` (~218 tokens)

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). Use it instead of reading pixels: every number is measured, not read. Past windows only; at most 600 bars.

Input parameters:

- `from` (string, required): window start, ISO-8601 UTC
- `indicators` (array): indicator ids to include, e.g. ["ema20","vwap","envelope"]; defaults to ema20 and envelope
- `market` (string, required): the market
- `tf` (string, required): timeframe
- `to` (string, required): window end, ISO-8601 UTC, in the past (the logical clock for a replay)

### `chart_image` (~166 tokens)

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. The picture is for shape; the numbers are in the JSON — quote those, never read them off the image. Past windows only; at most 600 bars.

Input parameters:

- `from` (string, required): window start, ISO-8601 UTC
- `indicators` (array): indicator ids to draw; defaults to ema20 and envelope
- `market` (string, required): the market
- `tf` (string, required): timeframe
- `to` (string, required): window end, ISO-8601 UTC, in the past

### `drawings` (~77 tokens)

The trader's own drawings on one market's chart: lines, boxes, paths and notes, each anchored at bars (UTC times) and prices. They are things the trader drew (or asked you to draw), not signals; a film of the window lets each one appear as the clock reaches it.

Input parameters:

- `market` (string, required): the market

### `draw` (~192 tokens)

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). Every point is a bar's time (ISO-8601 UTC, in the past) and a price the trader gave or the tape tool returned; never invent a level. Inks: parchment, gold, teal, brick (lime is the fire's and is refused). The drawing appears on their chart and in any film of that window.

Input parameters:

- `ink` (string): the ink
- `kind` (string, required): what to draw
- `market` (string, required): the market
- `points` (array, required): the anchors, earliest first
- `text` (string): a short word beside it (required for a note), at most 48 characters

### `erase` (~53 tokens)

Remove one of the trader's drawings by its id (from the drawings tool). Only when they ask.

Input parameters:

- `id` (string, required): the drawing's id as the drawings tool lists it (sk_ and 16 hex characters)

### `film` (~352 tokens)

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. Returns the film's public link, where it plays and can be downloaded as a video. 24 to 360 bars; the window must be in the past. A film is a replay of what printed: say so, and never present it as a forecast.

Input parameters:

- `drawings` (boolean): include the trader's drawings (default true)
- `from` (string, required): window start, ISO-8601 UTC
- `headline` (string): the headline's first part (drawn in parchment), at most 44 characters
- `headline_gold` (string): the headline's second part (drawn in gold)
- `kicker` (string): a short line at the right, e.g. price → structure
- `machine` (boolean): include the trades of the trader's rehearsed machine on this market, labelled a rehearsal
- `market` (string, required): the market
- `marks` (boolean): include the trader's marked levels (default true)
- `palette` (string): the inks
- `seconds` (number): length, 8 to 40 seconds (default 18)
- `structure` (boolean): draw the computed structure and name the chapters after it
- `tf` (string, required): timeframe
- `title` (string): a short name beside the wordmark
- `to` (string, required): window end, ISO-8601 UTC, in the past

### `replay_open` (~251 tokens)

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). The studio shows a card; pressing it opens the chart there, held and ready to play, with a way back to the studio. Use it whenever you talk about what happened in a window: show it on the chart instead of only describing it. Past windows only, ten minutes to thirty days; a replay shows what printed, never a forecast.

Input parameters:

- `focus` (string): optional: the moment inside the window to hold the clock at, ISO-8601 UTC
- `from` (string, required): window start, ISO-8601 UTC
- `market` (string, required): the market
- `note` (string): one short sentence shown beside the card: what to watch for (at most 140 characters)
- `speed` (string): how fast to play it: 60, 600 or 6000 times real time, or max (default 600)
- `to` (string, required): window end, ISO-8601 UTC, in the past

### `replay_record` (~120 tokens)

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). Use it after replay_open, or when the trader asks what they just watched, to answer from what was recorded rather than from memory.

Input parameters:

- `kinds` (array): only these sources or kinds (default: all)
- `market` (string, required): the market

### `image` (~77 tokens)

Look at a chart the trader attached (the id is in the studio state). Read what is on it — instrument, timeframe, levels, the pattern they point at — and say plainly that numbers read off a picture are READ, not measured; check the ones that matter against the tape.

Input parameters:

- `id` (string, required): the attached image's id

### `skills` (~49 tokens)

List the Cubicle skill bank: every skill's name, family, grade and status (runnable / stub / concluded). A stub is a promise, not a capability — say so when you cite one.

### `skill_read` (~61 tokens)

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.

Input parameters:

- `name` (string, required): the skill's name as the skills tool lists it

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-algotrada-cubicle-cubicle/deck-api-mcp#diagnostics

## Score history

- 2026-10-18: 70
- 2026-10-17: 70
- 2026-10-16: 69
- 2026-10-15: 69
- 2026-10-14: 68
- 2026-10-13: 68
- 2026-10-12: 67
- 2026-10-10: 66
- 2026-10-09: 66
- 2026-10-06: 65

## Common questions

### What is the Cubicle MCP server?

Cubicle is an MCP server listed in the public MCP registry as com.algotrada.cubicle/cubicle. Agent trading tools: candles, copy-trading, hire a strategy for your Robinhood vault, pay on chain. This page covers its hosted endpoint (https://cubicle.algotrada.com/deck/api/mcp).

### Is the Cubicle MCP server safe to use?

Cubicle scores 70 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Cubicle MCP server expose?

Cubicle exposes 40 tools: catalogue, account, plans, plan_claim, models, and 35 more. Their descriptions and schemas cost roughly 5,604 tokens of context every time the server is loaded.

### Does the Cubicle MCP server require authentication?

No. We connected to Cubicle without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Cubicle MCP server still maintained?

Cubicle is still listed as active in the MCP registry. We last reached this channel on 18 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://cubicle.algotrada.com/deck/api/mcp
- Website: https://cubicle.algotrada.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-algotrada-cubicle-cubicle/deck-api-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-algotrada-cubicle-cubicle/deck-api-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-algotrada-cubicle-cubicle/deck-api-mcp