Built with the people who trade it.

The Cubicle is AlgoTrada's core engine. It isn't a trading strategy. It's the machine that strategies get built in, tested in, and run on. Under the hood it's a deterministic decision engine, a synchronized multi-market data platform, and a validation harness, and we built all three as one system instead of stitching together separate tools.

It takes in synchronized price data from correlated markets across many timeframes and sessions, and sorts that data into time-based clusters. That's where the name comes from. Then it looks for the footprint institutions leave behind: one market pushing to a new extreme while a correlated market refuses to follow.

Every trade decision has to pass through a fail-fast ladder of gates, and every parameter that could affect a decision lives in one versioned configuration. Same data in, same decision out, byte-identical, every time. That's what lets us replay a decision months later, and it's what lets a partner or an operator actually check our work.

Underneath that ladder, each market and each time cluster runs as its own explicit state machine. Nothing is left to run loose in a script. Every instrument moves independently through a small set of named phases, from idle and scanning through armed, fired, and cooldown, and every step between those phases is triggered by a concrete rule, not a guess and not a timer ticking down. That's what makes the system's current state, and its next possible moves, something we can always point to and inspect.

What it doesn't do matters just as much as what it does. It doesn't predict prices. It doesn't run self-modifying black-box machine learning that quietly drifts once it's live. And it doesn't hold any opinion about which market to trade. That part sits in the product layer above it, where a trader actually feels the difference.

Think of it this way: an algorithm is one recipe. The Cubicle is the kitchen, the test bench, and the health inspector all at once. Skydweller and Bender are recipes. The Cubicle is why we can trust them.

Skydweller is AlgoTrada's first product, built for US index futures. It trades NQ (Nasdaq-100 futures) and watches ES and YM as confirming markets. The divergence between them is the signal.

What's unique to Skydweller is the market rulebook. The session structure of the US equity day (Asia, London, the New York open), the specific liquidity and divergence model for index futures, and its entry and exit law. None of that was assumed on day one. It was earned over months of graded live sessions.

What The Cubicle provides is everything else. Data capture and storage, the cluster engine, the gate-ladder decision architecture, backtest and replay validation, the risk brakes (a hard position cap, an automatic daily halt), and the nightly audit trail.

Could Skydweller exist without The Cubicle? As a research idea, sure. As a live, auditable, provable product, no. Every trade Skydweller takes is reproducible and reviewable, and that's only true because The Cubicle makes it so.

Bender is our second product, currently in progress. It trades Bitcoin perpetual futures, with ETH and SOL as correlated confirming markets. The crypto data engine already lives inside the platform, so getting Bender running is a matter of writing the rulebook, not rebuilding the plumbing underneath it.

Perpetual futures behave nothing like index futures. The market never closes, so there's no session open to anchor a strategy to. Funding rates replace expiry. The venues are crypto exchanges rather than CME. Volatility, liquidity, and the regulatory picture all look different too. You can't take a rulebook tuned to the New York open and drop it onto a market that has no open at all.

What's different from Skydweller is the rulebook, the venues, and how risk gets calibrated. What's shared with The Cubicle is everything underneath: data contracts, decision architecture, validation harness, risk framework, and day-to-day operations.

Here's what that looks like in practice, four layers deep:

• The data platform: a synchronized multi-market candle store with strict single-writer contracts
• The decision architecture: time-cluster engine, gate ladder, versioned configuration
• The validation methodology: deterministic replay of every change against full history, regression pins, the clean-record clock
• The execution and risk framework: position caps, daily halt, broker-confirmed accounting, nightly audit

Because a serious trader, or a technical investor, would spot a shortcut immediately. Any one piece of this, someone could build in isolation. What they can't buy is this:

"They could build a trading bot in six months. Then they'd spend years finding out, one expensive day at a time, everything our audit trail already knows."

Philosophy

• We do not predict markets. We detect what is actually happening and react by rule.
• A trade we cannot explain is a trade we do not take.
• Every fix restarts the clock. We count proof, not excuses.
• The market decides the profit. We decide the discipline.
• Nothing goes live that has not replayed history.