A model can make the trade. It cannot prove the trade.
Cubicle is an AI-native trading venue. Its core feature, the Time Compressor, drops an agent into any moment in the data with no knowledge of what comes next, replays years of history at up to 10,000×, and leaves with an audit trail that reads like a receipt. Deterministic execution. Explainable by design.
Paper venue · no capital at risk · your keys stay yours
NQ · 1m · cockpit.v1 · hi 29797.00 lo 28408.25 ORIENT — 14:30 ET · px 28768.25 · RS BEARISH ──────────────────────────────────────────── 29050.25 ◄─ ▲ dayHI · distrib 77 28795.50 ◄─ EQ P3:729[2187] 28768.25 ◄═ YOU ARE HERE 28598.67 ◄─ 23 accum 28350.88 ◄─ ▼ dayLO · 0.111 -ext ──────────────────────────────────────────── # session sid_7f2a · speed 100× · clock owns the tape order.place { side:BUY qty:2 reason:"EQ reclaim" } session.receipt → causality_ok:true · pnl:+3.1R
The model already knows how the story ends.
An agent trained on data through 2024, then backtested across 2019 to 2024, is not forecasting. It is remembering. That is why the curve is spectacular and the live account is not.
Selection on noise
Run 200 variants, keep the winner. You picked the luckiest sample, not the best strategy.
Fill fantasy
Filled at mid, every time. No queue position, no slippage, no partials, no spread.
One regime
The agent learned one tape's personality and calls it a market.
The same question, asked three times. Three different answers.
Ask why it sold at 14:32:07 and you are handed a log line and a chart. That is testimony, not evidence. A hosted model is resampled, retrained and silently replaced; the market data underneath it gets revised. Nothing about the answer is anchored.
- market
- NQ · 1m
- bar
- 1448
- px
- 29,864.50
- prompt
- "EQ reclaim?"
- RUN 01BUY 2 @ 29,864.50
- RUN 02SELL 1 @ 29,871.25
- RUN 03NO TRADE
The curve that wins the mandate is not the curve that trades.
Revised prices, survivorship, fills at levels that never traded, and a model that quietly saw tomorrow. The backtest is not lying on purpose. It is just not a rehearsal of anything real.
Until a backtest is run under live conditions, it is a marketing document.
Years of testing in one session. Backtesting that behaves like live.
The Time Compressor replays a decade of market history bar by bar at up to 10,000×, with the future withheld until the clock releases it. Your strategy drops into any moment in the dataset without knowing what happens next, so the results you get are the results your edge would have produced.
Drop into any moment, in the past
The agent only sees what existed at that timestamp. No lookahead, no hindsight, no accidental knowledge of the outcome.
One venue, every tape
Index futures and digital assets sit behind identical verbs, on one clock, in one schema. markets.list carries tick specs and calendars for all of them, so an agent built against NQ runs against BTC untouched.
Years of testing in one session
Time compression replays a decade of market history overnight, at live fidelity, before a single unit of real capital is deployed.
Ten years of market data compress into a single replay session running at up to 10,000 times speed.
Compressed time, not compressed rigour. Still one bar at a time.
The rules became models. So we built the rails they run on.
A rule you can read. A model you can only trust. We do not take the model away. We give the agent a defined skill set and hard rails: anti-hallucination checks, pinned context, and validation before anything is allowed to execute.
if close > vwap and rsi < 30 then buy 2
w·x + b → σ … 1.4e3 params then buy 2
- Anti-hallucination checks
- Pinned, replayable context
- Validated before execution
The model still decides. The rails decide what it is allowed to decide — which is what makes an agent something you can build with, not just something you hope about.
There was never a place to build one of these. So the venue is the workbench.
Every other route to an algorithmic strategy asks you to assemble it yourself: data from one vendor, a backtester from another, an execution shim you wrote, and a notebook that agrees with none of them. Nothing is connected, so nothing is comparable, and the thing you finally ship was never tested as a whole.
Cubicle is the missing surface. Connect any agent through one MCP server and it arrives with the market already readable, the clock already honest, the book already live, and the proof already wired. You build the strategy; the venue supplies everything the strategy needs to exist.
Without a venue
- Stitch data, backtester and broker yourself
- Your harness, your bugs, your lookahead
- “Trust the notebook”
- Rebuild per market
On Cubicle
- One MCP server, ten verbs
- The clock owns the tape
- A receipt per session
- Same verbs, every market
You bring the edge. Everything else an agent needs to exist is already here.
Three verbs to your first receipt
Read the market as text
The cockpit renders zone, range ladder, session bands and regime as ASCII and JSON from one Rust core. The result is an artifact your agent parses natively and can be graded against.
Trade any moment in history
Open a session on any recorded window. The clock owns the data: at 100×, a candle exists only after dispatch. Fills, stops, fees and PnL accrue on a real order book.
Leave with the receipt
Session ends → causality receipt: every tick dispatched, every decision's causal bar, determinism hashes, zero look-ahead. The PnL line and the proof travel together.
One MCP server. Ten verbs. Any agent.
# connect once — Claude, ChatGPT, Gemini, ElizaOS, your own stack markets.list tick specs · calendars orient.read cockpit.v1 as ascii | json session.open { market, from, to, speed_x } order.place limit · market · stops · reasons attached log.pin reasoning pinned to t_logical session.receipt 3-actor causality proof session.fork A/B on the identical tape · soon strategy.publish receipted listing · 70/30 split · soon live.arm armed-on-approval partner routing · later
Build → backtest → prove today. Publish to the re-seller program and staged live execution ship behind evidence gates. See the roadmap.
Every feature, its verb, and when it ships
Orient cockpit NOW
orient.read · ascii | jsonZone, range ladder, session bands, SMT wall, regime. One Rust truth, three projections. The chart an agent can quote.
Time Compressor sessions NOW
session.open{from,to,speed_x} · pause · seekAny recorded window, up to 10,000×. The clock dispatches candles at speed, and the future does not exist until released.
CLOB trading NOW
order.place · cancel · positions.getLimits, markets, stops, fees and positions on a real Taifoon CLOB book, with CME index futures + crypto side by side. Paper by default.
Causality receipts NOW
session.receipt3-actor cross-check (dispatcher · strategy · book), causal bar per decision, determinism hashes. The audit of the information set.
Log pinning NOW
log.pin{t_logical, note}Agent reasoning attached to the exact market moment it describes. Situational awareness becomes replayable.
Fork & compare G2
session.fork · compareA/B two strategy variants against the identical tape. The controlled experiment backtesting never had.
Skills packs G2
skills.attach · eval.exportIndicators + graded answers contextualized for trading decisions; RL-ready episode exports for training loops.
Canonical identity G2
subjects.getOne subject per author/agent/algo with legs resolved. The trust keystone under track records and payouts.
Strategy marketplace G4
strategy.publish · subscribeReceipted track records listed; subscribers copy under caps + kill-switch; author / platform revenue split.
Re-seller program G4
split{author:70,platform:30}Authors and white-label operators resell strategies and skills; the venue meters, settles, and receipts the flow.
Staged live execution G5
live.arm · dispatchPaper → devnet → gated live through partner rails (Kraken, IBKR). Armed-on-approval; every dispatch receipted.
Open trading model G∞
nemotron fine-tuneOpen-weight model trained on the receipted decision corpus. The house strategist, released open-source.
What ships at which gate
| Feature | G0 credible venue | G1 agent door | G2 metered | G3 identity | G4 marketplace | G5 live |
|---|---|---|---|---|---|---|
| Orient (ASCII/JSON) | G0: shipped | G1: shipped | G2: shipped | G3: shipped | G4: shipped | G5: shipped |
| Time Compressor sessions | G0: shipped | G1: shipped | G2: shipped | G3: shipped | G4: shipped | G5: shipped |
| CLOB paper trading + receipts | G0: shipped | G1: shipped | G2: shipped | G3: shipped | G4: shipped | G5: shipped |
| MCP connector + Cubicle skin | G0: not yet | G1: in flight at this gate | G2: shipped | G3: shipped | G4: shipped | G5: shipped |
| Billing · fork/compare · skills packs | G0: not yet | G1: not yet | G2: in flight at this gate | G3: shipped | G4: shipped | G5: shipped |
| Canonical identity + subject records | G0: not yet | G1: not yet | G2: in flight at this gate | G3: in flight at this gate | G4: shipped | G5: shipped |
| Marketplace · re-seller · copy-mirror | G0: not yet | G1: not yet | G2: not yet | G3: not yet | G4: arrives at this gate | G5: shipped |
| Staged live via partner rails | G0: not yet | G1: not yet | G2: not yet | G3: not yet | G4: not yet | G5: arrives at this gate |
You are not buying tokens. You are buying how far back you can look.
Every tier is the same sandbox. What changes is how much history the agent can reach, and how long it can run. Running years of market history through an agent costs real compute, so the price tracks usage rather than seats.
Sandbox
- Full agent sandbox, no feature limits
- Complete audit trail on every run
- Monthly compute allowance
Operator
- Everything in Sandbox
- 6× the compute allowance
- Parallel agent runs
Unlimited
- Everything in Operator
- Runs continuously, no cooldown
- Priority compute
Tiers are in private beta and priced per usage. Hit your ceiling mid-run and you buy the next block rather than waiting: the cooldown is a choice, not a wall. Ask for current pricing.
First 100 operators shape the venue
Free tier at launch: metered replay sessions on crypto tapes, full receipts. CME futures tapes and the design-partner program are invite-first. Tell us what you’re building.
Email info@algotrada.com. One line about your agent is enough.
Straight answers
- Is this live trading?
- No. The venue is paper: real book mechanics, zero capital at risk. Live execution arrives later in staged, armed-on-approval form through partner rails. Your money stays where you keep it.
- How is replay not cheating?
- The clock owns the data. Candles are dispatched only at the selected speed; each decision is stamped with its causal bar and a determinism hash; the session receipt cross-checks dispatcher, strategy and book. If anything saw the future, the receipt fails, visibly.
- What are the fills actually running against?
- A real central limit order book — the Taifoon CLOB — with queue position, partials, spread and fees. That is the difference between a backtest that fills you at mid every time and a rehearsal of something real. Paper by default: real mechanics, zero capital at risk.
- Where does the market data come from?
- One venue, one schema. Index futures (CME) and digital assets are live today, served through the Taifoon CLOB rails with tick specs and session calendars exposed via markets.list. You do not assemble a data stack to use Cubicle: the tape, the book and the clock are the same system, so an agent built against one market runs against the next without rebuilding anything. Further tapes extend the same surface — new markets, not a new platform.
- Which agents can connect?
- Anything that can call an MCP tool or a REST/WS API: Claude, ChatGPT, Gemini, open-source agent stacks, or plain code.
- What does it cost?
- Free tier for orientation; paid tiers meter session-hours × speed, parallel sessions and premium skills. Authors earn a revenue share when the marketplace opens.
- Who is behind this?
- AlgoTrada, the team behind the Skydweller futures engine, building on the Taifoon venue rails. Receipts are the house discipline: every claim a user can verify.