An AI-native trading platform for autonomous agents

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 problem

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.

TIMELINE · 2015 → 2026100% of the test window is inside training
MODEL TRAINING DATA
BACKTEST WINDOW · ALREADY READ
unseen

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.

IDENTICAL INPUT
market
NQ · 1m
bar
1448
px
29,864.50
prompt
"EQ reclaim?"
model v? · seed ?
  • 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.

EQUITY · ILLUSTRATIVE— BACKTEST— LIVE
THE GAP

Until a backtest is run under live conditions, it is a marketing document.

Taifoon CLOB rails index futures · digital assets10,000× replay speedASCII + JSON one-truth cockpitReceipts per session, per decision
The Time Compressor · the core feature

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.

10 YEARS OF MARKET DATA
10,000×

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.

What changed

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.

RULE · THEN
if close > vwap
and rsi < 30
then buy 2
Auditable
MODEL · NOW
w·x + b → σ …
1.4e3 params
then buy 2
Unverifiable
AGENT ON RAILS
  • Anti-hallucination checks
  • Pinned, replayable context
  • Validated before execution
Reads like a receipt

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.

The build surface

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.

How it works

Three verbs to your first receipt

01 · ORIENT

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.

02 · COMPRESS

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.

03 · PROVE

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.

The skills surface

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.

Features · designed, gated, obvious

Every feature, its verb, and when it ships

shipping nowG2 · metered groundG4 · marketplaceG5 · staged live

Orient cockpit NOW

orient.read · ascii | json

Zone, 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 · seek

Any 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.get

Limits, 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.receipt

3-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 · compare

A/B two strategy variants against the identical tape. The controlled experiment backtesting never had.

Skills packs G2

skills.attach · eval.export

Indicators + graded answers contextualized for trading decisions; RL-ready episode exports for training loops.

Canonical identity G2

subjects.get

One subject per author/agent/algo with legs resolved. The trust keystone under track records and payouts.

Strategy marketplace G4

strategy.publish · subscribe

Receipted 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 · dispatch

Paper → devnet → gated live through partner rails (Kraken, IBKR). Armed-on-approval; every dispatch receipted.

Open trading model G∞

nemotron fine-tune

Open-weight model trained on the receipted decision corpus. The house strategist, released open-source.

The map in one table

What ships at which gate

FeatureG0
credible venue
G1
agent door
G2
metered
G3
identity
G4
marketplace
G5
live
Orient (ASCII/JSON)G0: shippedG1: shippedG2: shippedG3: shippedG4: shippedG5: shipped
Time Compressor sessionsG0: shippedG1: shippedG2: shippedG3: shippedG4: shippedG5: shipped
CLOB paper trading + receiptsG0: shippedG1: shippedG2: shippedG3: shippedG4: shippedG5: shipped
MCP connector + Cubicle skinG0: not yetG1: in flight at this gateG2: shippedG3: shippedG4: shippedG5: shipped
Billing · fork/compare · skills packsG0: not yetG1: not yetG2: in flight at this gateG3: shippedG4: shippedG5: shipped
Canonical identity + subject recordsG0: not yetG1: not yetG2: in flight at this gateG3: in flight at this gateG4: shippedG5: shipped
Marketplace · re-seller · copy-mirrorG0: not yetG1: not yetG2: not yetG3: not yetG4: arrives at this gateG5: shipped
Staged live via partner railsG0: not yetG1: not yetG2: not yetG3: not yetG4: not yetG5: arrives at this gate
Pricing

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

1 month of market history
  • Full agent sandbox, no feature limits
  • Complete audit trail on every run
  • Monthly compute allowance
Most teams start here

Operator

6 months of market history
  • Everything in Sandbox
  • 6× the compute allowance
  • Parallel agent runs

Unlimited

Full history, no depth limit
  • 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.

Early access

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.

FAQ

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.
paper venue · staged live is gated
cubicle · by algotrada

Litepaper · Whitepaper · Roadmap · Landscape · built on Taifoon rails

Algorithmic trading involves risk. Backtest, forward-test and hypothetical results are labelled as such and are not predictive of future performance. © 2026 AlgoTrada Technologies.