Foundations: A Rebuilt Assistant Engine

The code that runs a single assistant conversation — reading your request, choosing tools, watching budgets and deadlines, streaming a reply back — had grown into a handful of very large files that only got harder to change safely. So we spent this release rebuilding that foundation. The behavior you see is deliberately identical. What's different is everything underneath.

The heart of the work was the conversation engine itself. A single sprawling routine now lives as a set of focused pieces: one that decides how a turn ends when it's cut short, one that tracks the arithmetic behind usage and metrics, one that governs how the assistant paces itself as it approaches a token, time, or step limit, and separate pieces for assembling context, choosing the right tools for the moment, and recording what happened. Turn timeouts, cancellation, and the contract between the assistant and each surface all moved into their own homes too. Where that logic used to be effectively unverifiable, it now carries real coverage — dozens of new automated tests pin down the tricky edges, like which kind of pressure wins when two limits close in at once.

Slack replies got the same treatment, and there the payoff is closest to the surface. Presence and message delivery, the streaming loop with its retry-on-dead-stream safeguard, and the logic that salvages a partial draft rather than abandoning it are now three distinct, tested pieces. Timeouts, retries, and soft landings used to be observable only in production; today they're exercised automatically before anything ships, which is a quiet but meaningful improvement to the reliability of the replies you actually read.

We also collapsed years of accumulated duplication. Text messaging, background runs, deep research, and Slack each carried their own near-copy of the code that consumes a model's response stream — four places to fix any bug, four places for behavior to drift apart. They now share a single stream-consumption core, with the genuinely surface-specific bits passed in rather than forked. Deep research followed suit: the long job that plans, executes, and reviews a piece of research is now a slim orchestrator sitting on top of a turn engine, a review-and-revision loop, and one clear place where its configuration lives.

Refactors like these rarely make an announcement, and we understand the temptation to skip them. But every improvement we ship to the assistant from here — smarter tool selection, better handling of long-running work, faster iteration on how conversations are paced — starts from this foundation. It's a shorter path now, with better guardrails, and that shows up in your experience as fewer regressions and features that land sooner.