OpenAI’s Responses API landed in March 2025 and was immediately positioned as the recommended way to build agentic applications — replacing the Assistants API, which had been the go-to for developers building stateful AI workflows since late 2023. If you built something on Assistants, you’re probably wondering what actually changed and whether the migration is worth the effort. The short answer is: it depends on what you built, but for most agent use cases, the Responses API is genuinely better.

The problem with Assistants

To be honest, Assistants always felt like a product designed for demos rather than production. The API was stateful in a way that sounded convenient but created awkward limitations — threads, runs, and messages were separate API objects you had to manage and poll. The execution model was asynchronous in a way that required polling for run completion, which added latency and complexity to every request. Built-in tools like Code Interpreter and file search were useful but expensive, and the lack of fine-grained control over how the assistant used them frustrated developers building anything beyond simple chat interfaces.

The other issue was the async polling pattern. You’d submit a message to a thread, kick off a run, then poll the run endpoint until it completed. Every developer who used Assistants in production built some version of the same polling loop, and every one of them found some edge case where it behaved unexpectedly.

What the Responses API looks like

The Responses API is designed around a simpler mental model: you make a request, you get a response. It’s stateless at the API level — like Chat Completions — but adds first-class support for tools, streaming, and multi-turn conversation management without requiring server-side thread state.

The basic structure is similar to Chat Completions: you pass a list of messages (or a previous_response_id for multi-turn continuity) and a list of tools, and get back a response object. What’s new is that the model can call tools multiple times within a single response, and the API streams these intermediate tool call results back to you in real time rather than requiring a separate polling round-trip.

response = client.responses.create(
    model="gpt-4o",
    input="Search for the latest UK inflation figures and summarise them",
    tools=[{"type": "web_search_preview"}]
)

OpenAI’s built-in tools — web search, file search, and Code Interpreter — are now available directly in the Responses API with simpler invocation. The web search tool in particular is a significant upgrade: it uses Bing under the hood but is properly integrated with the response, with citations returned in the response object rather than as model-hallucinated prose.

Where the APIs diverge

The biggest conceptual difference is how you handle state. Assistants manages conversation history server-side — you create a thread once, add messages to it, and OpenAI stores everything. The Responses API can optionally store response history (if you pass store=True), but you’re more in control of what persists and what doesn’t.

For straightforward chatbots and single-turn tool use, that distinction barely matters. But for agents with complex multi-step workflows — where you want to checkpoint state at specific points, branch based on intermediate results, or mix AI calls with external API calls — the Responses API’s approach gives you significantly more control.

The Responses API also handles multi-step tool use within a single request much more cleanly. With Assistants, each tool call was a round-trip — the model called a tool, you processed it, you submitted the result, the run continued. With Responses, the model can make several tool calls before producing its final output, and the streaming interface shows you each step as it happens.

The thread and run model: should you miss it?

Probably not. The thread-and-run model was useful mainly for persistent chat UIs where you wanted to store history without managing it yourself. If that’s your use case, OpenAI’s store=True option in Responses handles it, and the previous_response_id parameter gives you conversation continuity without the overhead of managing thread objects.

If you were using Assistants for something more agentic — automated pipelines, scheduled tasks, multi-step reasoning chains — the Responses API is a straight upgrade. The polling loop is gone, streaming is native, and the agent loop is easier to control.

Should you migrate?

If you’re on Assistants API today, OpenAI hasn’t deprecated it yet, but new features (including the latest tool integrations) are landing on Responses first. The migration is also not huge — the object model is simpler, not more complex. For greenfield development, there’s no reason to use Assistants.

For existing Assistants-based apps: if you’re using threads primarily for conversation history storage, migrating is straightforward and the result will be a slightly simpler, faster codebase. If you’ve built complex logic around thread management or the async run lifecycle, expect a few days of refactoring. The result is almost certainly worth it — but factor in the time.

The bigger picture is that OpenAI is clearly moving the ecosystem toward the Responses API as the foundation for all agentic work. Their agent SDK, Computer Use integration, and the latest Codex functionality all build on Responses. If you’re building AI agents in 2026, that’s the API to learn.