Turn-Based AI Is Hitting a Ceiling — Inside Thinking Machines' 200ms Micro-Turn Architecture

On June 30, ByteByteGo published a technical breakdown of Thinking Machines' research preview, and the claim is blunt: real-time AI today is a turn-based language model wearing a costume. The responsiveness you hear when you talk to a voice assistant is not the model being fast. It is a stack of helper components listening for pauses, transcribing audio, generating text, and synthesizing speech fast enough that the seams do not show.

Thinking Machines' bet is that those helpers — not the language model itself — are the bottleneck. Their first release is TML-Interaction-Small, a 276-billion-parameter mixture-of-experts model with 12 billion active parameters at any moment, designed around a 200-millisecond "micro-turn" loop instead of a single-thread conversation turn.

This is a different kind of release. Not a benchmark score. Not a chatbot update. An argument that interactivity has to move inside the model.

The Harness Pattern, and Why It Has a Ceiling

A typical voice AI product in 2026 is a stack of five components glued together. Voice activity detection listens for pauses. A speech-to-text model transcribes. A language model generates a response. A text-to-speech model converts the response to audio. A dialog manager orchestrates the pipeline so the latency feels acceptable.

The setup mostly works. Voice assistants feel real-time even though the underlying language model works in turns — wait for the user to finish, generate a response, hand off. The responsiveness is the helpers hiding the turn boundary.

But there is a ceiling, and it comes from asymmetry. The voice activity detector is a much smaller and lighter model than the language model behind it. The dialog manager is hand-coded orchestration logic. These helpers handle pieces of the conversation the language model itself never sees.

This is why current voice AI struggles with capabilities that look simple. "Interrupt me when I say something wrong." The helper that decides when to speak runs on acoustic signals, while correctness is the language model's job — the helper cannot know. "Tell me when I have written a bug in my code." The helper handles audio while the screen stays beyond its reach. "Correct my mispronunciation as you hear it." A turn-based architecture handles speaking and listening as separate operations, so the correction arrives too late or in the wrong place.

The pattern is older than voice AI. Rich Sutton's Bitter Lesson argues that methods leveraging general computation and learning consistently outperform methods that bake in human-designed heuristics. The argument took hand-crafted computer vision features down in favor of deep learning, and hand-crafted game heuristics down in favor of self-play. Applied to interactivity, harness components are exactly the kind of hand-crafted heuristic that scale will eventually push out. The way past the ceiling is to put interactivity inside the model.

Micro-Turns: Replacing the Turn With a 200ms Window

Most language models work in turns. The user speaks. The model speaks. The user speaks again. Each turn is a discrete unit, processed as one complete chunk. Even when a system handles audio, the underlying logic stays turn-based. The harness simulates real-time, but the model itself perceives the world in clean, separate chunks.

Thinking Machines made a different choice. They slice time into 200-millisecond chunks, which they call micro-turns. Every 200 milliseconds, the model takes in whatever arrived across audio, video, and text streams and decides what to output across audio and text streams. Time becomes the fundamental unit, replacing the turn entirely.

This sounds like a small change. It is not. The model treats time as continuous rather than partitioned into turns, deciding micro-turn by micro-turn whether to speak, listen, jump in, or stay silent. Input and output happen at the same time.

Four capabilities emerge from the same architectural choice:

• The model can speak while listening — live translation.
• The model can watch while speaking — live sports commentary.
• The model can jump in mid-sentence when something visual happens — counting reps as someone exercises.
• The model can correct a user mid-utterance — "correct my codeswitching as I do it."

These behaviors are not features added on top of a turn-based model. They are what you get when the unit of processing stops being a turn.

Two-Model Coordination: Fast Interaction, Slow Reasoning

Micro-turns solve responsiveness. They create a new problem. How does a model that responds in 200-millisecond windows also do deep reasoning?

Some tasks genuinely need minutes of thinking — web browsing, tool use, chained reasoning steps. Building one model that handles both fast response and deep thought at the same time is hard.

Thinking Machines' answer is to use two models working together. The interaction model is fast, present, and handles real-time conversation. The background model is slower and handles sustained reasoning, tool use, browsing, and longer-horizon work. They share context with each other, so both have the same picture of what has been said and what is happening.

The coordination works like this. When the interaction model encounters something that needs deeper reasoning, it sends a rich context package over to the background model — the full conversation rather than a standalone query. The background model runs asynchronously, with results streaming back as it produces them. The interaction model weaves those results into the conversation when the moment fits, rather than dropping them in as an abrupt context switch.

From the user's perspective this is one continuous conversation, with one AI thinking, responding, occasionally pausing to dig deeper, and weaving back in smoothly. Behind the scenes two systems coordinate throughout.

The same logic shows up across computing — fast paths paired with slow paths, foreground processes paired with background ones, all through web browsers and operating systems. Thinking Machines applied the pattern to AI inference in a principled way, instead of treating reasoning latency as a problem the user has to absorb.

The Benchmarks Existing Models Fail On

The architecture is the claim. The benchmarks are the evidence. Existing benchmarks for voice AI struggle to capture the qualitative jumps this design enables, so Thinking Machines built their own.

• TimeSpeak — measures whether the model can initiate speech at user-specified times with the correct content. Example task: "remind me to breathe in and out every 4 seconds until I ask you to stop."
• CueSpeak — measures whether the model speaks at the right moment while the user is still talking. Example task: "every time I codeswitch, give me the correct word in the original language."
• RepCount-A — streams video of someone doing reps after the instruction "count out reps for pushups."
• ProactiveVideoQA — streams videos with questions whose correct answers depend on what is happening visually at specific moments.

The result is striking. Across these benchmarks, all existing models stay silent or give wrong answers. This is the strongest evidence Thinking Machines presents that the architectural shift unlocks a new capability class, rather than just speeding up old behavior.

Lower latency is not the win. Capabilities the harness cannot fake are the win.

What This Architecture Does Not Solve

The research preview is honest about its limits. Three problems remain open.

Long sessions are a real challenge. Continuous audio and video accumulate context very quickly. The streaming-session design handles short and medium interactions well, but very long sessions still require careful context management.

Connectivity is a hard requirement. Streaming audio and video at low latency demands a reliable internet connection. A poor connection causes the experience to degrade significantly — there is no fallback to turn-based behavior that gracefully degrades.

Scaling the model size is constrained by latency targets. TML-Interaction-Small is the size it is partly because Thinking Machines' larger pretrained models are currently too slow to serve in this setting. Bigger models will need either better serving infrastructure or different architectural choices.

The roadmap is limited research preview in the coming months (as of late June 2026), wider release later this year, and a research grant for interaction model research. No timeline for the larger variants.

Beyond Voice AI

The interesting question is not whether Thinking Machines wins this round. It is whether the architectural argument scales.

The Bitter Lesson pattern shows up whenever a capability is scaffolded outside the model. Voice activity detection sits outside the language model because the language model could not handle audio. Tool use sits outside the language model because the language model could not call APIs. Retrieval sits outside the language model because the language model could not search a corpus.

Each time, the scaffold works for a while. Each time, scale inside the model eventually overtakes it.

Scaffolding is what you build when you cannot yet put the capability in the model. Scaffolding always loses.

Voice AI is the next instance of the same pattern. Interaction models are the first sign that interactivity itself is moving inside.

The labs that treat voice AI as a UX problem are optimizing the harness. The labs that treat voice AI as a modeling problem are working on TML-Interaction-Small's successors. One of these bets compounds. The other one stays a costume.

---

Source: ByteByteGo, "Inside Thinking Machines' Interaction Models" (2026-06-30). Technical detail from Thinking Machines Engineering Team research preview under their Connectionism publication name. TML-Interaction-Small specifications, micro-turn design, two-model coordination scheme, and benchmark descriptions are from the publicly shared research preview.