Nanoconda Roadmap Through the End of 2026

Gathering for the last stretch of the year is a natural strategic window: enough data to reflect on from H1 and build an argument about where this market is going. DMA has always been a trade-off. Retail platforms get you trading in a day, then you hit a wall: not enough depth, no room to tune anything, or no real line to the exchange. Going professional gets you past that wall, but it costs months of onboarding and a budget more reasonable for a firm than an individual. We sit on the professional side of that line, running a low-latency market segment gateway (MSGW) connection to CME. What we're building through H2 comes down to one thing: that access shouldn't be that gated.

The market is moving toward smaller participants. The infrastructure isn't.

The exchanges have already picked a direction. CME's Micro E-mini complex — the small-sized contracts aimed at individual traders — hit a record 5.1 million contracts a day in June 2026, half of all CME equity index volume. Roughly 4.5 billion Micro E-mini contracts have traded since the 2019 launch. On August 24, CME went a step further, launching E-nano futures at one-tenth the Micro size, citing that the barrier to entry for individual traders had grown enough to justify an even smaller contract.

So contract sizing has been democratized twice over. Access infrastructure hasn't kept pace. The individual trying to reach CME directly today walks roughly the same path as a twenty-person firm: exchange approval, licensing, conformance testing, weeks of process. All of it before deploying a single line of strategy code.

That gap can't be closed by handing people a slower, simpler pipe, because speed still decides outcomes at the margin. The best public measurement of this is a study of latency-arbitrage races on a major equity exchange: races for the same trading opportunity happen about once a minute per symbol, the typical race is decided in 5–10 microseconds, and races account for roughly 20% of trading volume. At that margin, a slower connection offers no advantage at all.

Here's what our strategy looks like, direction by direction.

Direction 1. Real low latency + keeping the charts: Sierra Chart integration

Our own GUI was built to control algorithms: start, stop, watch the P&L, hit the kill switch. It was not meant for charting or manual trading. Many of the traders we talk to already live in Sierra Chart, and our task was to merge the two services and make the transition as smooth as possible.

This shipped in the September 2 release. Sierra Chart connects to Nanoconda over DTC, on the same host and port that the GUI, the Remote API, and FIX already use. Once connected, it sees the same account as every other client: the same positions, open orders and order book.

What works over the connection:

• Session, reference data, and market data — top-of-book and full depth, with live incremental updates
• Order entry from the chart or DOM: market, limit, stop and stop-limit, plus cancel, cancel/replace and flatten
• Account queries: positions, open orders, balances and fill history
• Historical tick-level price data, from which Sierra Chart builds its own bars

The strategy does not move. It keeps running on the colocated server in Aurora, on the shared-memory API, at the same latency as before. Sierra Chart is a network client that shows what the strategy is doing and lets you trade by hand alongside it. We're taking this further with a new option: hosting Sierra Chart itself in Aurora, not just connecting to it. A user gets a colocated instance and remotes into it, rather than running Sierra Chart at home and reaching across the internet.

Direction 2. Independent traders, under our license

We've worked through CME approval so that an individual can reach the non-display trading under the Nanoconda license instead of running their own multi-week ILA onboarding. What matters here is what doesn't change. This is the same stack our enterprise clients run: single-digit microsecond order-to-wire, the same colocated servers in CME's Aurora data center, same feed handler, same pre-trade risk layer underneath.

If you've been running strategies on a retail platform and hit its ceiling, or porting an algo from another venue and found that queue dynamics punish the latency you inherited, this tier is for you.

Direction 3. Self-service on the cloud

Self-service reporting is the kind of feature a small team tends to postpone. We chose to prioritize it in this roadmap segment. The new cloud suite puts that data in your hands directly: the trade log and audit trail that already go to your clearing firm, latency reports built from the same trace files our own team reads, P&L by account and by algo, and the account side — risk limits, users and roles.

An AI assistant sits next to it for the day-to-day questions:

• What a Nanoconda service does and how it fits your setup
• What a CME error or reject code means when something breaks (FIX rejects, session drops, and other messages that arrive instead of a fill)
• Code samples for the API, in C++ or Rust, or for a Wasm plugin in another language
• Search and help across our documentation

Direction 4. WASM plugins: write strategies in your language of choice

People write trading logic in many languages, and forcing everything through C++ has mostly been a tooling decision. The platform supports client-provided WebAssembly plugins: compile a strategy to a sandboxed .wasm guest and run it under nanoconda-cli -a pluginloader, using the same dmasession/listener model as a native plugin.

WebAssembly is the right vehicle for this: it's a mature standard now (Wasm 3.0 was completed in September 2025), with the memory model and garbage-collection support that let high-level languages compile cleanly. Its security model also fits trading infrastructure unusually well. A Wasm module starts with zero permissions: no filesystem, no network, no system calls unless we grant them. Your code runs inside our latency-critical path without either side having to trust the other blindly.

The same release includes a Rust guest SDK: same host, same dmasession/listener model, same field and method names as the C++ SDK. Rust is no longer an outsider in market infrastructure: Databento's DBN encoding, the market-data format we already replay, is implemented in Rust - and Rust compiles to Wasm as a first-class target.

Direction 5. FIX gateway

If a strategy already trades over FIX, it can now trade through Nanoconda without being rewritten for our API. The FIX 4.x gateway shipped in the September 2 release. An OMS, an execution platform, or an algo built on a FIX engine connects on the same host and port as the GUI, the Remote API, and Sierra Chart, and trades the same account.

A trading session supports:

• New orders, cancel, cancel/replace, and mass cancel
• Order status, for a single order or all of them
• Market, limit, stop, and stop-limit orders, Day or IOC
• Market data as a snapshot plus incremental updates
• Security lists and definitions, positions, and trade-capture reports

Clearing firms and risk desks get a read-only session instead. It shows every order, fill, position, and trade on the account in real time, regardless of which session sent it, and it cannot place or cancel anything. Data starts arriving at login; the stream comes from Nanoconda rather than the exchange, so it can be reconciled against CME's own drop copy.

The cost is latency. FIX runs through the kernel's TCP stack and adds tens of microseconds per message; the shared-memory API is about one microsecond order-to-wire. Strategies that compete for queue position belong on shared memory. Everything else can trade over FIX. Tags and message layouts are in the FIX reference.

What this adds up to

None of these is a separate product. The September release starts this roadmap: what shipped keeps getting built on. A chart front end, a FIX gateway, strategies in more than one language, an individual license, and self-service reporting are parts of one thing: a complete colocated trading stack, available on a subscription, that does not require a firm behind it. Each release this half moves it one step closer. Exchanges are opening the market to smaller participants; this is the access infrastructure following them.

If any of this is the ceiling you're hitting, book a call. If you'd rather test first, the Simulator runs the same API against recorded market data, with no exchange connection and no capital at risk.