Two people ran the same new feature this month. One made it look like the future. The other, without meaning to, showed you exactly why it isn't here yet.
Peter Yang is lying on his bed, talking to ChatGPT Voice, driving a set of Codex threads by voice alone. He calls the activity "pretty great." It is the literal promise of the paradigm: delegate the work, walk away, run a full team from a horizontal position.
Then, in the very next sentence, he tells you the cost. "To do this well I think you have to remember the names of all your long running threads."
Read that again. To make the system that was supposed to replace your working memory work, you have to become its working memory. The seduction and the crack arrive in a single breath.
To make the system that was supposed to replace your working memory work, you have to become its working memory. The seduction and the crack arrive in a single breath.
This is the thing most people get wrong about hands-free agent orchestration. They assume the blocker is model quality — that voice coding will arrive once the underlying models get smart enough. But the models are already fanning out. Per VentureBeat's reporting, OpenAI shipped this on July 23: one spoken instruction can reportedly spin up parallel threads to investigate an auth bug, review a pending PR, and generate missing unit tests at once, tracing issues across Slack, GitHub, and your local codebase.
That's not the problem. The intelligence is there. What's missing is a state model — a way for the interface to represent what's running, what finished, and which thread you're addressing right now.
Look at Yang's three failure modes, because none of them is a reasoning failure.
First, the dispatch problem. If you don't explicitly say "start new thread" or "use thread A," the orchestrator will "bundle all your random requests into one thread." You have to manually route every utterance, because voice has no ambient sense of where your words are supposed to land.
Second, the silence problem. "While the other thread is working it's just silent, which kind of breaks the immersion a bit." A thread goes quiet the moment it starts doing the thing you asked. You have no idea if it's working, stuck, or done.
Third, the notification problem. His feedback ask is simply: "let me know when the other threads finish working if I have a bunch of threads going." He is requesting the most basic property of a task queue — completion events — because the voice surface doesn't surface them.
Name the pattern. Dispatch, presence, completion. Which thread am I talking to, who's currently working, who just finished. Those are the three primitives of any concurrent system, and voice-only orchestration ships with none of them.
So the human backfills all three by hand. He memorizes thread names to solve dispatch. He mentally tracks which agents are mid-flight to solve presence. He waits and pokes to solve completion. The paradigm promised to make him the boss; instead it made him the dispatcher, the memory, and the polling loop.
One reply to Yang's thread is almost too perfect: "I name my threads 1, 2, 3, 4, 5." That is a person building a manual addressing scheme on top of a system that should own addressing natively. It's the human quietly re-implementing the state layer the interface forgot to ship.
Now put Claire Vo next to him, because her version of this actually works — and the reason it works is the whole argument.
Vo hands Codex the keys and walks away. It QA's her onboarding flow, does exhaustive mobile testing she'd never do by hand, and comes back with a specific artifact, described in the episode outline as "11 issues, one high-severity blocker, one Google Sheet with screenshots."
That Google Sheet is the tell. It is a durable, external, glanceable representation of state — eleven rows, a severity flag, screenshots as evidence. When the work finishes, there is a place where the results live and persist that isn't the ephemeral audio stream.
Yang's threads have no Google Sheet. When his thread finishes, the output exists only as a spoken line he might miss, in a channel with no memory. Vo's task produces a surface you can return to; Yang's produces a moment you have to catch.
And notice what Vo trusts the agent to do when she truly walks away: clean up her LinkedIn inbox, and shop the Free People sale — adding, per the episode outline, 10 medium-size items to her cart, breastfeeding-friendly and Hawaii-ready.
These are single-threaded and low-stakes. If the personal shopper adds the wrong dress, you delete it before checkout. If the inbox cleaner archives something, you unarchive it. There is no fleet of concurrent threads whose individual states you must hold in your head, and the cost of any error rounds to zero.
That's the contrast that matters. Vo's clean win isn't proof the paradigm works. It's proof the paradigm works when you strip out exactly the conditions that break it — concurrency, high stakes, and the need to keep track of which thread is which.
The QA task even had the one thing Yang's setup lacked: a built-in artifact of state. She didn't have to remember what Codex found. It wrote it down.
There's a deeper reason silence is disqualifying: verification is the human-owned outer loop. You can delegate the doing, but you cannot delegate the checking — the human still has to confirm the agent did the right thing.
Voice orchestration makes that outer loop harder, not easier. Verification depends on visibility, and a thread that goes silent while working has removed the very signal the human needs to verify against. You can't check work you can't see happening.
Vo's Google Sheet is verification infrastructure. Yang's silent threads are verification blackouts. That's the same outer loop, enabled in one case and quietly sabotaged in the other.
So here is the design prescription for anyone building agent interfaces right now.
The unit of UX is no longer the conversation turn. For a single chat thread, turn-taking is the right frame — you speak, it responds, repeat. But the moment you allow concurrency, the unit becomes the thread, and threads don't take turns. They run in parallel, at their own pace, and demand to be represented all at once.
Which means ambient state has to become a first-class surface, not a thing the user reconstructs from memory. Ship three things.
Presence: an always-visible indication of which threads are working, so silence stops meaning uncertainty. Completion: a completion event the human can't miss, because "let me know when the other threads finish" is table stakes, not a feature request. Dispatch clarity: a visible, unambiguous answer to which thread you're addressing right now, so voice stops bundling everything into one bucket.
Voice can be the input. It probably shouldn't be the only output, because audio is a lossy, ephemeral channel for representing the state of five parallel processes. Yang's fluid full-duplex layer is a genuinely good conversational engine bolted to a nonexistent state display.
Until those surfaces ship, hands-free multi-thread orchestration stays a demo. A gorgeous one — a person on a bed running a team by voice — but a demo, viable only for the class of tasks Vo already identified: single-threaded, low-stakes, and cheap to get wrong.
The models can already run your team. The interface still can't tell you who's on it, who's working, and who just came back with the answer. Fix the state model, and voice becomes a coding interface. Skip it, and you've just hired yourself as the dispatcher you were trying to replace.