Sub-Millisecond AI
AI that thinks in seconds. Systems that must act in microseconds. Psyclone AIOS™ is the bridge.
What is Sub-Millisecond AI?
Modern AI is remarkably good at reasoning — and remarkably slow at it. A frontier Large Language Model takes hundreds of milliseconds to several seconds to respond. That is fine for a chatbot. It is useless for a robot arm, a live conversation, or any system that has to react to the physical world in real time.
Sub-Millisecond AI is our name for the architectural category that solves this: a runtime where slow, deep AI reasoning and fast, deterministic real-time control coexist in a single coordinated system — with internal communication measured in microseconds, not seconds. It is what Psyclone AIOS™, CMLabs’ real-time AI operating system, was built to do.
This page is the full story: the problem, the architecture, who it is for, and why it works. No prior context needed.
The Problem: Two Speeds of Intelligence, One System
Human conversation runs on 300–500 ms turn-taking. Interrupt a beat too late and the interaction feels broken. Robotics and other physical AI run tighter still: control loops at hundreds of hertz to kilohertz rates, where a late reaction is a failed grasp or a safety incident. High-frequency decision systems — monitoring, trading, threat response — face the same physics: the world does not wait for an API round-trip.
Meanwhile, the best available reasoning — frontier LLMs — takes anywhere from half a second to many seconds per call. The standard industry answer is to chain model APIs together with Python orchestration frameworks. The result is well known to anyone who has shipped one: stacked latencies of 500 ms and up, fragile glue code, context that slips between calls, and infrastructure that was never designed for deterministic timing.
The core insight: this is not a model problem. It is an operating-system problem. You cannot make an LLM fast enough for a control loop — and you should not have to. What you need is an architecture where slow reasoning and fast reflexes are both first-class citizens, sharing state and coordinating in real time.
The Solution: The Fast/Slow Bridge
Cognitive science describes human thinking as two systems: fast, automatic System 1 reflexes and slow, deliberate System 2 reasoning. Psyclone AIOS implements exactly this split in software — inside one runtime.
Fast components — audio pipelines, sensor processing, interruption detection, actuator control — run as native modules with deterministic, microsecond-scale message passing. Slow components — deep reasoning calls to local or frontier LLMs — run alongside them, taking their seconds without ever blocking the fast path. Both sides read and write the same shared state, so a five-second reasoning result lands in a system that has stayed responsive the entire time and immediately reshapes what the fast loops do next.
For a business reader, that is the whole pitch: you get frontier-model intelligence in systems that respond at reflex speed, without the brittle latency stack that makes most production AI pipelines feel slow and fall over under load.
Under the Hood: The Architecture
For engineers and architects, here is what actually makes that possible. Psyclone is not an orchestration framework layered on top of somebody else’s runtime — it is a purpose-built, high-performance C++ AI operating system, the product of over two decades of R&D into large-scale distributed AI, refined in real-world deployments since. (Prefer skimming? Each subsection leads with the one-line takeaway.)
Sub-100µs publish/subscribe messaging
Takeaway: internal communication is ~1,000× faster than a typical HTTP microservice hop. The core of Psyclone is its message bus and blackboard system, Whiteboards™: typed messages, wildcard subscriptions, and publish/subscribe routing with end-to-end latencies under 100 microseconds. Modules never call each other directly; they publish to and subscribe from Whiteboards, which act as shared, observable state. This decoupling is what lets components of wildly different speeds — a kilohertz control loop and a five-second LLM call — coexist without one ever stalling the other.
Deterministic fast loops alongside multi-second reasoning
Takeaway: real-time guarantees on the fast path are never held hostage by slow AI calls. Fast-path modules run with deterministic scheduling and microsecond messaging; slow reasoning modules issue their LLM calls asynchronously and publish results when ready. A hierarchical context system — activation states that sequence and switch behaviours dynamically — coordinates the two, so control flow emerges from context rather than hard-wired call chains. When reasoning output arrives, it changes context; the fast loops adapt on the next cycle.
Natively distributed and scalable
Takeaway: one system image across many machines, sized to the workload. Psyclone is multi-node by design: modules communicate transparently across processes and machines over TCP/UDP, so a deployment can span an edge device doing microphone capture, a GPU box running local models, and cloud calls to frontier models — all on the same bus. Modules and nodes can join and leave a running system live, which means capacity can be added, components upgraded, or hardware swapped without stopping the world.
Engineered for stability
Takeaway: real-time AI is only useful if it stays up. A recent system-wide hardening pass closed race conditions and memory-safety issues across the C++ core, eliminated a shared-memory corruption bug, and added stall-detection to the automated test suite so regressions in timing behaviour are caught before release. This is unglamorous work, and it is exactly the work that separates a research demo from infrastructure you can put in front of customers.
Self-programming systems
Takeaway: proven live module loading is the foundation for AI-authored modules. Because Psyclone can load, test, and unload modules in a running system — a capability demonstrated in earlier Psyclone versions — it provides the foundation for an LLM Supervisor: a reasoning layer designed to author new modules, load them live, evaluate their behaviour, and refine them — so the system extends itself under supervision. This self-programming loop is an active research direction we are building on that proven live-reconfiguration foundation, not a shipped feature.
Who This Is For
?
?
?
Voice AI & Conversational Agents
The problem: production LLM pipelines break the natural 300–500 ms rhythm of human turn-taking, so voice agents feel laggy and talk over people.
With Psyclone: the entire real-time audio pipeline — microphone capture, voice-activity detection, turn-taking, interruption handling — runs on the fast path, wrapped around deep reasoning on the slow path. The result is conversation that keeps human pace while still drawing on frontier-model intelligence — the architecture behind CMLabs’ own real-time voice AI work.
Robotics & Physical AI
The problem: robots need kilohertz-rate control and split-second reactions, but the intelligence you want them to have lives in models that think in seconds.
With Psyclone: sensor fusion, perception, and motor control run as deterministic fast-path modules on the same bus as high-level reasoning and planning — an architecture proven in EU-funded human-robot collaboration research and in work with major automotive and robotics manufacturers.
High-Frequency Decision Systems
The problem: monitoring, security, and market-facing systems must ingest thousands of concurrent event streams and act before the moment passes; API-chained agent stacks lose context and time.
With Psyclone: high-volume streams are ingested and triaged on the fast path — local models handling classification in-loop — while heavier reasoning is routed to frontier models only when it earns its latency. Fast detection, deep analysis, one system.
Proven, Not Just Promised
CMLabs has been building real-time distributed systems for nearly two decades. Psyclone has powered EU-funded human-robot collaboration research, projects with major automotive and robotics manufacturers, a live commercial facial-recognition deployment, and today powers real-time voice AI built on the same runtime. The full track record is on Proven in the Field.
Licensing & AI Safety
Psyclone is open-core: LGPL/BSD open-source foundations with a commercial license option for enterprise use. Every license — open or commercial — includes the CADIA Clause, a hard restriction against use for harm, privacy violation, or warfare. Details on the Licensing page.
Build at the Speed of the World
If your AI has to keep up with a conversation, a machine, or a market, the bottleneck is your architecture — not your model.