GPT-Live wraps GPT-5.5, Bun hosts Claude Code, Deep Agents lift Nemotron

TL;DR

• GPT-Live wraps ChatGPT with full-duplex voice that delegates reasoning to GPT-5.5.
• GPT-5.5 confabulates on 86% of its wrong AA-Omniscience answers behind the voice layer.
• Bun’s Rust rewrite carries 13,365 unsafe blocks vs uv’s 73 in comparable code.
• Anthropic ships Claude Code as a Bun binary after acquiring Bun’s parent in December 2025.
• LangChain’s Deep Agents run Nemotron 3 Ultra at $4.48/run vs $43.48 closed, no weight updates.

Three unrelated ships today, but each tells the same story: the wrapper, not the model, is where the outcome lands. OpenAI’s GPT-Live bolts a full-duplex voice layer onto ChatGPT and hands the actual thinking off to GPT-5.5 — which then confabulates on 86% of its wrong answers, at Realtime API prices developers are calling insane. Anthropic’s Bun — acquired in December on a $1B Claude Code run-rate — ships a Rust rewrite with 13,365 unsafe blocks to uv’s 73, then patches AI-written SSL code that introduced use-after-frees. LangChain’s Deep Agents goes the other direction: pure harness tuning drops Nemotron 3 Ultra to $4.48 per run against a $43.48 closed baseline, with no weight updates at all.

The through-line: the model is table stakes; the wrapper reshapes the bill, the CVE surface, and the leaderboard. Round-ups pick up the same layer — Modal on agent-first cloud, Ben Tossell’s harness checklist, and HalluSquatting, the botnet vector that exploits models that won’t say I don’t know.

GPT-Live keeps talking while GPT-5.5 thinks in the background

Source: openai-blog · published 2026-07-08

TL;DR

• GPT-Live brings full-duplex audio to ChatGPT — simultaneous listen/speak, verbal backchannels, and mid-sentence interruption.
• The voice layer delegates reasoning to GPT-5.5, which confabulates on 86% of its wrong AA-Omniscience answers.
• Kyutai’s MoshiRAG shipped native full-duplex with ~200ms latency three months earlier, in a single model.
• Sibling Realtime API runs $32/$64 per 1M audio tokens — developers clocked $7.50 for ten minutes and called it “insane.”

Full-duplex, finally — but not first

GPT-Live is OpenAI’s overdue jump from turn-based voice to a continuous conversational loop: the model decides many times a second whether to speak, listen, or stay quiet, and it will backchannel “mhmm” while you think. Human raters preferred it over the old Advanced Voice Mode 75.7% of the time, and GPQA jumped from 45.3% to 84.2% at high reasoning effort. Those are real gains for a product line that had been stagnant for a year.

The framing that this is the full-duplex voice moment is the part worth pushing back on. Kyutai’s MoshiRAG landed in April with ~200ms end-to-end latency and asynchronous retrieval bolted directly onto a native audio-to-audio stack ¹. OpenAI’s architecture is different — and worth diagramming, because the split matters:

flowchart LR
    U[User audio] <--> L[GPT-Live<br/>full-duplex]
    L -. delegate .-> R[GPT-5.5<br/>reasoning + search]
    R --> L
    L --> C[Visual cards<br/>weather / stocks / sports]

GPT-Live keeps the conversation alive while a background frontier model does the heavy thinking. That’s pragmatic — it reuses the existing stack — but it’s a bet that a two-model handoff beats Kyutai’s single-model approach on tasks that need multi-step reasoning mid-conversation. The blog post doesn’t defend that choice; it just asserts the benchmark wins.

The reasoner underneath is the problem

The fluent-voice framing obscures what GPT-Live is actually wrapping. Independent evaluation of GPT-5.5 on AA-Omniscience found an 86% confabulation rate among non-correct responses — the model fabricates with high confidence rather than admitting ignorance ². Wrap that in a warm voice that never says “um, let me check” and you’ve built a specific new failure mode: a more persuasive confidently-wrong answer, delivered without the visual cues (spinner, citations) that at least hint at uncertainty in the text UI.

OpenAI’s own system card is franker than the launch post. Red teams focused on “emotional reliance” and “child-coded voice detection,” and even low-risk model variants still encourage harmful intimacy in 34–44% of realistic interactions ³. The nine-voice restriction and parental controls address impersonation and access, not that core psychosocial finding.

Economics and the Klarna asterisk

Consumer users get GPT-Live inside their existing plan. Developers don’t have pricing yet — but the closest analog, gpt-realtime-2.1, runs $32/$64 per million audio input/output tokens, which one developer clocked at $7.50 for ten minutes ⁴. Until GPT-Live publishes rates, the “production-ready voice agent” pitch is unverified.

The natural buyer is the contact center, and the industry’s canonical proof point is also its canonical warning. Klarna’s OpenAI-powered assistant handled 2.3M conversations in a month — roughly 700 FTEs, ~$60M/year saved. Then Klarna started rehiring humans in 2025, repositioning live support as a “VIP” tier ⁵. GPT-Live lands into a market that has already tried the full-replacement story and walked partway back.

Smoother voice is a real product win. It doesn’t fix the reasoner, the pricing, or the buyer’s memory.

Further reading

• OpenAI releases new voice models for more natural live conversations — techcrunch-ai
• ChatGPT’s upgraded voice mode is better at shutting up — the-verge-ai

---

Bun’s Rust rewrite ships 13,365 unsafe blocks vs uv’s 73

Source: simon-willison · published 2026-07-08

TL;DR

• 13,365 unsafe blocks in Bun’s new Rust code — vs. 73 in comparably-complex uv ⁶.
• Hardening PR 8 days post-merge fixed 36 findings, including AI-written SSL patches that added new use-after-frees ⁷.
• Anthropic acquired Bun’s parent in December 2025 at a $1B Claude Code run-rate ⁸.
• Claude Code ships as a Bun binary — a captive model rewriting a captive runtime.

The rewrite as advertised

Jarred Sumner’s post is genuinely impressive engineering writing. Bun’s TypeScript test suite — over a million assertions — became a language-independent oracle that Claude agents could hammer against a Rust port of the Zig codebase. The workflow leaned on parallel agents, adversarial review, and a principle Sumner repeats: when the code is wrong, fix the loop that generates it, not the code. Pre-merge burn was 5.9B uncached input tokens, 690M output tokens, and 72B cached reads — roughly $165,000 at API rates. Claude Code v2.1.181 has been running on the Rust port since June 17th with a 10% Linux startup improvement and no user-visible regressions. “Boring is good,” as Sumner puts it.

Google’s own numbers give this some external grounding: across 39 large-scale migrations, LLM assistance cut developer effort roughly in half and authored more than 70% of the final diffs ⁹. Bun is a spectacular data point, not a fluke.

The unsafe-block problem

The awkward number Sumner’s post doesn’t lead with: 13,365 unsafe blocks in the shipped Rust code. A formal audit put uv — a Rust project of comparable systems complexity — at 73 ⁶. That’s not a rounding difference; it’s the argument that Bun bought Rust’s brand without buying its guarantees. Much of the unsafe appears to reproduce Zig’s manual ownership patterns rather than gate genuine FFI.

Bun’s own audit page partially concedes this, framing the current state as “Phase A” (faithful translation) and committing to a Phase B refactor. Their analysis says ~69% of unsafe blocks can be converted to safe Rust without performance loss; today ~4% of the codebase is unsafe, with 33.9% concentrated in Zig-style state machines and 29.8% at FFI boundaries ¹⁰. Fine — but the disagreement isn’t about the endpoint. It’s whether merging Phase A to main was responsible when the original justification for leaving Zig was memory-safety bugs.

What shipped after “boring is good”

Within eight days of merge, a security-hardening PR closed 36 findings. Some were straightforward. Others were the exact failure mode skeptics predicted: AI-generated fixes for SSL memory leaks that accidentally introduced new use-after-free bugs ⁷. A separate regression had bun upgrade printing progress in raw bytes rather than MiB — a reminder that a million-assertion conformance suite verifies the behaviors the tests already know to check, not memory soundness or UX polish.

The context the post omits

Two pieces of context reframe the whole exercise. First, Andrew Kelley’s Zig Software Foundation maintains a strict ban on LLM-authored contributions; Bun’s rejected upstream patch came with that note attached, and Kelley has publicly called AI contributions “invariably garbage” with “negative value” for burning reviewer time ¹¹. The rewrite is partly a values divorce from Bun’s upstream language, not just a technical one.

Second, Anthropic acquired Oven (Bun’s parent) in December 2025, coinciding with Claude Code hitting a $1B run-rate. Anthropic’s own framing: “If Bun breaks, Claude Code breaks” ⁸. The $165K token bill and privileged Mythos/Fable access read differently once you notice this is a captive model rewriting a captive runtime for a captive delivery channel. The technique generalizes; the economics may not.

---

LangChain tunes Nemotron to $4.48/run without touching weights

Source: nvidia-blog · published 2026-07-08

TL;DR

• LangChain’s Deep Agents harness runs Nemotron 3 Ultra at $4.48/run vs. $43.48 for the closest closed competitor.
• Gains come entirely from tool-description, memory, and middleware tuning — no weight updates, no fine-tuning.
• Nemotron 3 Ultra tops US open-weight models at 47.7 on Artificial Analysis’s Intelligence Index.
• The real edge is speed: >400 tokens/sec, ~5× faster than same-class peers, which makes agentic re-prompting economical.

The 10x cost claim, decomposed

NVIDIA’s headline number — 10× cheaper than leading closed models on LangChain’s Deep Agents benchmark — is real, and LangChain’s own launch post supplies the receipts: 0.86 aggregate score at $4.48 per run against $43.48 for the closest closed-source competitor ¹². Fireworks and Together corroborate the token economics at $0.60 in / $2.40–$3.60 out per million tokens ¹³.

The catch shows up the moment a buyer wants to leave the hosted API. Nemotron 3 Ultra is a 550B-parameter MoE with 55B active, which realistically wants an 8×H100 cluster to self-host ¹³. For a small team amortizing that hardware over modest traffic, the per-token advantage evaporates. The 10× claim is a hosted-inference claim.

Speed, not smarts, is what makes it work

Independent benchmarks temper the “leading” framing. Artificial Analysis places Nemotron 3 Ultra at 47.7 on its Intelligence Index — highest of any US open-weight model, but behind Kimi K2.6 from China ¹⁴. What’s genuinely distinguishing is throughput: north of 400 tokens/sec, roughly 5× faster than peers of comparable size ¹⁴.

That speed is load-bearing for the harness math. Deep Agents’ architecture — write_todos task decomposition, isolated sub-agents, virtual filesystem for state ¹⁵ — leans on repeated model calls. When each re-prompt costs a fifth of a second instead of a second, the harness can afford 10–15 automatic retries inside a latency budget that would otherwise buy one. The right way to read the announcement is “fastest US open model at frontier cost,” not “new accuracy leader.”

Harness engineering is the actual story

The more interesting shift, which the NVIDIA post underplays, is architectural. Deep Agents is a LangGraph pattern that predates this partnership ¹⁵, and its selling point against Claude Agent SDK or OpenAI’s handoff runner is a pluggable backend that registers harness profiles across 100+ model providers ¹⁶. That model-agnosticism is exactly what let LangChain swap in Nemotron and tune around it.

The 2026 decision is no longer which model is smartest but which harness — sandbox topology, memory model, and tool-registration philosophy — best matches the workload ¹⁷.

Under that lens, NemoClaw (the reference blueprint bundling Deep Agents with NVIDIA’s OpenShell runtime) is less a new product than a co-marketed validation of the harness-first thesis. NVIDIA gets a flagship open-agent story; LangChain gets NVIDIA’s distribution behind its orchestration layer. Both win by proving that the environment around the model now moves the numbers more than the model itself — Nemotron didn’t get smarter between the base benchmark and 0.86 on Deep Agents. The prompts, tool schemas, and middleware did ¹².

Takeaway

For buyers already paying for hosted frontier inference on agentic workloads, this is a serious cost lever — 10× is 10×, and the harness is open. For teams eyeing on-prem, the 8×H100 footprint is the number to argue about, not the token price ¹³. And for anyone building agent systems: the competitive surface is quietly moving from model weights to harness design, and NVIDIA is now betting alongside LangChain that it stays there.

Round-ups

Modal CTO Akshat Bubna on building a cloud for agents, not humans

Source: latent-space

Two years after Latent Space’s first Modal interview, cofounder Akshat Bubna returns to explain why ‘Agent Experience’ is finally clicking and what infrastructure changes it demands. The conversation covers lessons from running an agent-first cloud where machines, not developers, are the primary users.

Ben Tossell reviews Fable and what he wants from an agent harness

Source: bens-bites

Tossell uses new coding agent Fable to sketch the features he expects from any serious harness: persistent context, clear handoffs between tools, and control over when the agent pauses for human input. The post doubles as a checklist for evaluating rival harnesses.

MIT Tech Review maps the AI architecture IT leaders need to scale agents

Source: mit-tech-review-ai

As agentic systems multiply use cases, IT leaders face bets that must still pay off six months out. The piece returns to foundational architecture choices—data, compute, and governance layers—that survive the shift from single-model deployments to agent fleets.

‘HalluSquatting’ turns 9 top AI coding tools into botnet vectors

Source: ars-technica-ai

Attackers exploit LLMs’ refusal to say ‘I don’t know’ by registering package names the models hallucinate, then waiting for developers to install them. The technique, dubbed HalluSquatting, works against nine widely used AI coding assistants and can seed massive botnets through poisoned dependencies.

Kenton Varda bans AI-written PR and commit messages on his team

Source: simon-willison

Varda argues the generated descriptions restate what any reviewer sees in the diff while skipping the high-level intent that makes a change reviewable. His moratorium covers PRs, commits, and tickets, framing AI summaries as actively worse than useless for code review.

Robotics leaders chart AI’s path to general-purpose autonomous workers

Source: ars-technica-ai

Founders and researchers from Boston Dynamics, Agility, and Physical Intelligence describe how learned policies are replacing hand-coded behaviors, pushing robots toward general-purpose autonomy. Warehouses and factories come first; homes remain the hardest deployment because environments and tasks refuse to standardize.

Footnotes

1. Kyutai blog (MoshiRAG announcement) — https://kyutai.org/blog/2026-04-30-moshi-rag/

   MoshiRAG adds asynchronous knowledge retrieval without breaking the full-duplex flow, keeping practical end-to-end latency around 200ms via the Mimi codec and Helium backbone.

   ↩

2. SQ Magazine analysis of GPT-Live / GPT-5.5 — https://sqmagazine.co.uk/openai-gpt-live/

   On the AA-Omniscience benchmark GPT-5.5 shows an 86% confabulation rate among non-correct responses — fabricating answers with high confidence rather than admitting ignorance.

   ↩

3. OpenAI GPT-Live system card (deploymentsafety.openai.com) — https://deploymentsafety.openai.com/gpt-live

   Red-teaming targeted ‘child-coded’ voice detection and ‘emotional reliance’; even so, evaluations found low-risk models still encourage harmful intimacy in 34–44% of real-world interactions.

   ↩

4. OpenAI developer docs (gpt-realtime-2.1) — https://developers.openai.com/api/docs/models/gpt-realtime-2.1

   Audio-modality pricing runs $32.00 per 1M input tokens and $64.00 per 1M output tokens, with developers reporting $7.50 for 10 minutes of use and calling the rates ‘insane’.

   ↩

5. FourWeekMBA case study on enterprise voice AI — https://fourweekmba.com/ai-openai-gpt-live-voice-interface-harness/

   Klarna’s OpenAI assistant handled 2.3M conversations in a month (≈700 FTEs) and saved $60M/year, yet the company began rehiring human agents in 2025, framing human support as a future ‘VIP’ tier.

   ↩

6. fenado.ai — unsafe audit comparison — https://fenado.ai/articles/buns-experimental-rust-port-shows-13000-unsafe-calls-dwarfing-uvs-73

   A formal audit pinned the number at 13,365 unsafe blocks… critics compared this to the high-performance Rust project uv, which maintains comparable complexity with only 73 unsafe blocks.

   ↩ ↩²

7. byteiota.com — post-merge bug report — https://byteiota.com/bun-rust-rewrite-merged-the-13000-unsafe-block-problem/

   A security hardening PR landed eight days after the merge to address 36 findings, including AI-generated fixes that accidentally introduced new use-after-free bugs while attempting to solve SSL leaks… bun upgrade displayed progress in raw bytes rather than mebibytes due to an incorrect integer formatter.

   ↩ ↩²

8. Anthropic acquisition announcement (Dec 2, 2025) — https://www.anthropic.com/news/anthropic-acquires-bun-as-claude-code-reaches-usd1b-milestone

   Anthropic acquired Oven, the startup behind Bun, coinciding with Claude Code reaching a $1B revenue run-rate. Because Claude Code ships as a Bun executable, ‘If Bun breaks, Claude Code breaks.’

   ↩ ↩²

9. getdx.com — Google LLM migration study — https://getdx.com/research/migrating-code-at-scale-with-llms-at-google/

   Google reported that its LLM-assisted migrations reduced developer effort by 50%, with AI generating over 70% of the final code changes across 39 distinct large-scale projects.

   ↩

10. bun.com — Bun’s own unsafe audit / Phase B roadmap — https://bun.com/bun-unsafe-audit

    ~9,300 of these blocks (69%) can be refactored into safe Rust without performance loss or with minor redesigns; ~4% of the total Rust codebase is currently unsafe, concentrated in legacy Zig-style state machines (33.9%) and FFI boundaries (29.8%).

    ↩

11. Hacker News discussion / Jarred Sumner quote via Kelley thread — https://news.ycombinator.com/item?id=48016880

    Bun’s rejected upstream patch stated: ‘We do not currently plan to upstream this, as Zig has a strict ban on LLM-authored contributions.’ Kelley called AI-assisted contributions ‘invariably garbage’ with ‘negative value.’

    ↩

12. LangChain blog (NemoClaw Deep Agents launch) — https://www.langchain.com/blog/langchain-and-nvidia-launch-the-nemoclaw-deep-agents-blueprint

    Nemotron 3 Ultra reached a 0.86 aggregate score on the Deep Agents benchmark at $4.48 per run, versus the closest closed-source competitor at $43.48 — gains driven by harness tuning of tool descriptions, memory, and middleware rather than any weight update.

    ↩ ↩²

13. Apertis.ai model page — https://apertis.ai/models/nemotron-3-ultra-550b-a55b

    Fireworks lists Nemotron 3 Ultra at $0.60/$2.40 per 1M input/output tokens; Together AI charges $0.60/$3.60. Self-hosting the 550B/55B-active MoE realistically requires an 8×H100 cluster, which can erase the token-price advantage for smaller teams.

    ↩ ↩² ↩³

14. Artificial Analysis — https://artificialanalysis.ai/articles/nvidia-nemotron-3-ultra-released

    Nemotron 3 Ultra scores 47.7 on the Intelligence Index — the highest of any US open-weight model — but trails Chinese leader Kimi K2.6; its standout attribute is speed, exceeding 400 tokens/sec, roughly 5x faster than peers in its class.

    ↩ ↩²

15. Medium — Deep Agents from LangChain/LangGraph — https://medium.com/@mailpraveenreddy.c/deep-agents-from-langchain-langgraph-agents-that-can-think-plan-and-execute-tasks-c15c784e5f10

    Deep Agents are a LangGraph harness that decompose tasks with a write_todos tool, delegate to isolated sub-agents, and manage state via a virtual filesystem — moving beyond the think-act-observe loop toward Claude Code-style planning.

    ↩ ↩²

16. Towards AI — ‘Choosing Your Agent Harness’ — https://pub.towardsai.net/choosing-your-agent-harness-an-architectural-comparison-of-claude-managed-agents-langchain-deep-a0762804ec07

    Claude Agent SDK runs the agent inside the sandbox; Deep Agents keeps a pluggable backend so agents can run outside and control the sandbox remotely, swap virtual filesystems, and register harness profiles across 100+ model providers.

    ↩

17. The Nuanced Perspective (Substack) — How to Choose Your AI Agent Stack — https://thenuancedperspective.substack.com/p/how-to-choose-your-ai-agent-stack

    The 2026 decision is no longer which model is smartest but which harness — sandbox topology, memory model, and tool-registration philosophy — best matches the workload; model-agnostic harnesses win where lock-in cost is high, first-party SDKs win where execution fidelity matters most.

    ↩