The agent API you built on last year already has a shutdown date
On 3 June 2026 OpenAI began retiring Agent Builder, Evals and reusable prompts — all gone 30 Nov 2026 — and the Assistants API sunsets 26 Aug 2026. We build agents a different way: a portable core you own with a thin vendor adapter, so the next sunset costs you a day, not a quarter.
Your no-code agent workflow now has an expiry date — here's exactly what changed
OpenAI is winding down the visual, no-code way of building agents and pointing everyone back to code. Here's the full, dated picture — current as of 8 August 2026, and worth re-checking against OpenAI's own deprecations page before you plan.
| Product | Key date | What to use instead |
|---|---|---|
| Agent Builder (visual no-code canvas) | 30 Nov 2026 | Agents SDK — the same logic, written as code |
| Evals platform | 31 Oct read-only 30 Nov 2026 gone | Datasets, or open-source Promptfoo |
| Reusable prompts (v1/prompts) | 30 Nov 2026 | Prompts managed in your own code |
| Assistants API | 26 Aug 2026 | Responses API + Conversations API |
| ChatKit | staying | Keep it — the embeddable chat UI is not affected |
Why this is an architecture problem, not an OpenAI problem
Fast-moving platforms deprecate things — that's not a knock on OpenAI. The lesson generalizes to every major provider: any of them can retire a convenience layer. The real question isn't "which provider is safest?" It's "where did I put my logic?" If your agent's reasoning, tools and evaluation live inside a vendor's product, you've quietly made their roadmap your roadmap. If they live in your code, a deprecation is a config change.
Notice OpenAI's own tell: for workflows that should last, it now recommends the Agents SDK as code, and describes the Responses API as the future direction. Code survives; hosted canvases are products, and products get retired.
If one of these is your week right now, you're in the right place
These are the situations teams bring us when a provider changes the rules. Every one has the same root cause — valuable logic living somewhere you don't control — and the same fix.
We built our whole support flow in Agent Builder. Now there's a shutdown date and no one knows how to move it.
The fix → We lift the workflow into the Agents SDK as code, add an eval set to prove it behaves the same, and hand it back as yours.
Our agent's on the Assistants API and I just learned it's being retired. I don't even know what "Responses API" means for us.
The fix → We migrate to the Responses + Conversations API before 26 Aug, with a thin adapter so the next change is painless.
Every time OpenAI changes something, our whole roadmap stops for a week while engineering scrambles.
The fix → A thin vendor adapter turns those scrambles into a one-file change — your core logic never moves.
The demo was flawless. In production the agent takes weird paths and we can't tell why.
The fix → Tracing plus an eval set you own makes reasoning drift visible and catchable — before your users see it.
A vendor doubled a price and we had no way to switch — everything was wired to them.
The fix → A provider gateway routes to OpenAI, Anthropic, Google or local models, so a price change is a config edit, not a crisis.
We paid an agency and got a black box we can't maintain or move. We don't even have the eval sets.
The fix → Everything we build is yours — code, prompts, adapters, eval sets — on open frameworks with no lock-in.
You keep hearing "agent API" and "chat API" as if they're the same — they're not
A chat API talks; an agent API acts. A plain chat/completions endpoint takes a prompt and returns text, statelessly, every turn. An agent API (or "ai agents api") adds the machinery that turns a chatbot into a doer: tool calling, state that persists across steps, and often built-in tools and hosted execution.
- Tool calling — invoke functions, search or systems you define, then use the result
- State across steps — it remembers the task instead of replaying the whole transcript
- Built-in tools — on the Responses API: web search, file search, code interpreter, computer use, remote MCP
- Orchestration — multi-step plans, handoffs, guardrails and tracing
The major "api ai agents" options — OpenAI's Responses API and Agents SDK, Anthropic's tool use, Google's Gemini tooling, Mistral's Agents API — are all converging on this shape. Which is exactly why the durable question isn't "which is best?" but "how do I build so that answer can change without hurting me?"
You're no longer sure which OpenAI API you're even supposed to build on
Build the core on the Responses API and orchestrate with the Agents SDK — OpenAI's own recommended, code-first path, and the migration target for anyone leaving Agent Builder. Use the others only for what they're actually for.
| Surface | Use it for | Status today |
|---|---|---|
| Responses API | The agent primitive — "own the loop," built-in tools, direct control | Current foundation |
| Agents SDK (open-source) | Orchestration in code: multi-step, handoffs, guardrails, tracing | Recommended path |
| ChatKit | Dropping a chat UI into your product | Staying |
| Assistants API | — | Retiring 26 Aug 2026 → move now |
| Agent Builder (no-code) | — | Gone 30 Nov 2026 → migrate to Agents SDK |
One provider decision shouldn't be able to cost you a quarter of rework
The pattern that survives deprecations is simple to say and easy to get wrong: keep everything valuable in your own code, and keep the vendor surface as small as you can. Thick core, thin adapter.
Your core — portable
Agent reasoning, tool definitions, business rules, data grounding, eval sets and guardrails — in your repository, on open frameworks. This is the valuable part, and it never moves.
The adapter — disposable
A thin layer that translates your calls into one provider's format. When the provider changes, you rewrite this — not the agent.
Multi-provider routing
One internal interface, several backends. Route each task to the best model and fail over when a provider has an outage.
Your own eval set
Accuracy measured by tests you own, so you can prove a provider swap didn't degrade quality — the thing that makes migration safe.
The eval set is the piece most teams skip, and it's what makes the rest real. Without your own tests, switching providers is a leap of faith — nobody can prove the new setup is as good, so nobody signs off, and you stay locked in by uncertainty rather than by contract. With a solid eval set, migration becomes a measurable engineering task. More on this in our agent frameworks guide.
You've been told to choose "hosted API or open framework" — in production you use both
This is usually framed as a fork in the road. In real systems it's a layering decision: an open orchestration layer holds your logic, and it calls provider APIs for the commoditized parts — model inference and some hosted tools.
| Open framework (your logic) | Hosted agent API | |
|---|---|---|
| Speed to first build | Slower to start | Fastest |
| Infrastructure work | You run it | Handled for you |
| Control over behavior | Full | Limited to their model |
| Portability | Moves with you | Tied to the provider |
| Deprecation exposure | Low | High if logic lives there |
You keep the speed of a hosted API for the parts that are genuinely interchangeable, while the irreplaceable part — your logic — stays in code you control. That's not a compromise; it's the setup that gets both benefits.
Every provider looks the same on the pitch slide — here's how to actually choose
Pick the provider per task, not as a religion — and keep your architecture portable so the choice can change. All the major agent APIs are converging, so provider choice matters less than most vendors imply, and architecture matters more than almost anyone admits.
- OpenAI (Responses API + Agents SDK) — broadest tooling, fastest-moving, which cuts both ways as the Agent Builder wind-down shows. A strong default, provided your logic lives in your code.
- Anthropic (tool use + agent SDK) — strong on long-context reasoning and careful tool use; chosen where instruction-following quality matters most.
- Google (Gemini agent tooling) — attractive when you're already in Google Cloud and want tight data-platform integration.
- Mistral (Agents API) and open-weight models — worth it for cost control, self-hosting, or European data-residency needs.
- AWS Bedrock / Azure OpenAI — less "distinct agent product," more governed access paths, chosen for procurement, residency and compliance.
- Open frameworks (LangGraph and similar) — not a provider at all, but the orchestration layer that calls the others. This is where your logic should live.
Your agent nails the demo and falls over in production — here's why
Three failure surfaces show up over and over in real agent workflows, and each has an architectural answer, not a prompt-tweak answer.
1. Reasoning drift
The agent takes a path that looks plausible and is wrong. It's invisible without tracing and unfixable without an eval set that catches the regression. The fix is instrumentation plus tests you own — not a cleverer prompt.
2. Tool & integration failures
The agent calls a tool that errors, times out or returns something odd, and the whole run collapses. Production agents need retries, fallbacks and explicit failure handling on every tool.
3. Vendor-surface changes
The provider deprecates a product, moves pricing or shifts a model's behavior. With a thin adapter that's contained. Without one it's a rewrite under deadline — exactly where Agent Builder users are now.
You've been quoted anywhere from $5K to $400K and nothing explains the gap
A focused, single-workflow production agent typically runs $10,000–$40,000 to build, plus a real monthly run cost most quotes forget. The spread is about scope: a rule-based helper and a multi-agent RAG platform are not the same animal.
| Scope | Representative build |
|---|---|
| Simple / rule-based agent | $5K–$25K |
| Focused custom workflow agent (most common) | $10K–$40K |
| RAG knowledge / multi-agent systems | $80K–$400K+ |
| Ongoing run cost (tokens, vector DB, monitoring, tuning) | $3.2K–$13K / mo |
What does an honest agent-API quote look like?
A representative $21,000 portable build on the Responses API — the typical shape, not a past client invoice. Notice that the adapter and eval lines are the ones that make a future deprecation cheap.
| Line item | Cost |
|---|---|
| Discovery + workflow & tool design | $3,500 |
| Portable agent core (logic, tools, grounding) | $8,500 |
| Provider adapter + gateway | $3,000 |
| Eval set, tracing & observability | $4,000 |
| Integrations, deployment & handover | $2,000 |
| Representative total | ~$21,000 |
What the tokens themselves cost — the major agent APIs compared
Build cost is one-time; token cost is forever, and it's where your model choice lands on the invoice. Standard first-party API pricing per 1M tokens — a snapshot as of 8 Aug 2026. These move fast, so confirm on each provider's live pricing page before you commit.
| Provider | Model (tier) | Input /1M | Output /1M |
|---|---|---|---|
| OpenAI | GPT-5.6 Sol · flagship | $5.00 | $30.00 |
| GPT-5.6 Terra · mid | $2.00 | $12.00 | |
| GPT-5.6 Luna · budget | $0.20 | $1.20 | |
| Anthropic | Claude Opus 5 · flagship | $5.00 | $25.00 |
| Claude Sonnet 5 · mid (intro → $3/$15 on 1 Sep) | $2.00 | $10.00 | |
| Claude Haiku 4.5 · budget | $1.00 | $5.00 | |
| Gemini 2.5 Pro · flagship | $1.25 | $10.00 | |
| Gemini 2.5 Flash · mid | $0.30 | $2.50 | |
| Gemini 2.5 Flash-Lite · budget | $0.10 | $0.40 | |
| Mistral | Large 3 / Medium / Small | See mistral.ai/pricing — often the low-cost / self-host option | |
Snapshot as of 8 Aug 2026, standard first-party API rates. Prices change often — OpenAI cut its budget tier sharply in mid-2026 and Anthropic's Sonnet intro rate reverts on 1 Sep 2026 — so always verify on the provider's live pricing page before budgeting.
The tools cost extra — budget for them too
Built-in tools are billed on top of tokens, and they add up on a busy agent:
- Web search — about $10 per 1,000 calls (OpenAI and Anthropic both)
- File search — about $2.50 per 1,000 queries plus ~$0.10 / GB / day storage (OpenAI)
- Code interpreter — from $0.03 per session, rising with container size (OpenAI)
This is exactly why the multi-provider gateway earns its keep: route cheap, high-volume steps to a budget model and reserve the flagship for the hard reasoning, and the same agent can cost a fraction of a single-model build. We tune that routing as part of every build. Full method in our development-cost breakdown.
See the market rate, then see ours
Comparable US agencies price agent-API builds well into five and six figures. We deliver the same senior engineering at 50–70% less — the savings are structural, a global senior team, not offshore juniors — and you own everything at the end.
Starter agent
- One agent on the Responses API
- Portable core + thin adapter
- Eval set & tracing included
- Live in 2–4 weeks — you own it
Custom build + integrations
- Multi-tool agent, real systems wired in
- Provider gateway + failover
- Full observability & guardrails
- Agent Builder migration included
Multi-agent / enterprise
- Multi-agent orchestration
- Knowledge base + RAG
- Compliance-ready architecture
- Dedicated delivery lead
The API is just plumbing — these are the things it has to plumb
The provider API is the easy part. The value is in what you connect it to and how safely it runs. That's the work we do.
Agent-to-system integration
Wiring agents into your CRM, ERP, databases and internal APIs so they act on real systems.
Custom tool layers
Defining the tools your agent can call — the part that decides what it can actually do.
Provider gateways
One internal endpoint routing to OpenAI, Anthropic, Google, Bedrock, Azure or local models.
Observability & tracing
Spans and logs so you can debug why an agent chose a branch — essential in production.
Migrations off deprecated products
Moving workflows out of Agent Builder into maintainable code before the deadline.
Guardrails & PII filtering
Policy enforced before a request leaves your environment, not after.
You don't want to hand your business logic to a vendor's roadmap again
So don't. We're a US-registered custom AI agent development company with a global senior team, deliberately model-agnostic — we resell no provider, so the recommendation you get is about your task, not our margin.
You own it
Code, tools, prompts, adapters and eval sets, on open frameworks with no lock-in — the same principle the portable architecture protects at the technical level.
Model-agnostic by design
We resell no provider and route to whatever fits the task — OpenAI, Anthropic, Google, Mistral or local — so a price or policy change at one vendor is never your emergency.
Proven before you pay
A working demo on your real workflow before any money changes hands — at 50–70% less than a comparable US agency, because the savings are structural.
Built to outlive the API
Portable core, thin adapter, your own eval set — one of 8+ agent types we build, live in 2–4 weeks, engineered so the next deprecation costs you a day.
Before you write a single line of integration code, answer these five
Each item is cheap to get right now and expensive to fix later. Fail more than one line and that's exactly the work we scope.
| Check | Why it matters |
|---|---|
| Where does the business logic live? | If the answer is "the vendor's product," you've inherited their deprecation schedule. |
| Do you have an eval set? | Without one you can't prove a migration or model change is safe — so you never make it. |
| Is every provider call behind an adapter? | Decides whether a sunset is a day of work or a quarter. |
| Is tracing on from day one? | Reasoning drift is invisible without it, and retrofitting observability hurts. |
| Do you own the code and data? | Portability is theoretical if you can't take the artifacts with you. |
Should you build on an agent API at all? Sometimes the honest answer is no
Build on an agent API if
- You need tool calling and state, not one-shot completions
- You want hosted infrastructure for the commodity parts
- You'll keep your logic in your own code
- You'll want multi-provider flexibility later
Reconsider if
- A simple completion call already solves it
- You'd put business logic in a vendor canvas
- You have no eval set and no plan for one
- Compliance requires fully local models
The questions buyers actually ask about agent APIs
What is an AI agent API?
A provider interface for building agents that reason toward a goal, call tools, keep state across steps, and take actions — instead of returning a single block of text. Next to a plain chat endpoint, an agent API adds tool calling, conversation state, and often connectors, hosted execution and evaluation. Examples include OpenAI's Responses API and Agents SDK, Anthropic's tool use, and Google's Gemini agent tooling.
What's the difference between an agent API and the Chat Completions API?
Chat Completions is stateless and single-turn — you send the whole conversation each time and get text back. An agent API is stateful and action-oriented: it tracks the task across steps, calls tools, and can run built-in tools like web or file search. Put simply, chat APIs talk; agent APIs act.
Is the OpenAI Assistants API actually going away?
Yes. OpenAI notified developers on 26 August 2025 that the Assistants API would be removed one year later, on 26 August 2026. The replacement is the Responses API together with the Conversations API, which OpenAI describes as the future direction for building agents on its platform.
Is Agent Builder being retired — and what do I build on instead?
Yes. On 3 June 2026 OpenAI announced it is winding down Agent Builder, the Evals platform and reusable prompts, all unavailable from 30 November 2026 (Evals turns read-only on 31 October first). OpenAI recommends the Agents SDK — the same workflow written as code. ChatKit is not affected and stays available.
How do I stop an API deprecation from breaking my agent?
Keep the agent's reasoning, tools, data grounding and evaluation in your own code, and put every provider-specific call behind a thin adapter. When a provider retires a product, you rewrite the adapter, not the agent. Avoid building core logic inside a vendor's visual builder or hosted workflow object — that's the hardest part to move and the most likely to be lost in a sunset.
OpenAI Agents SDK vs Responses API — which should I use?
Use both, at different layers. The Responses API is the low-level agent primitive where you "own the loop" and call built-in tools. The Agents SDK is the higher-level, open-source orchestration runtime for multi-step workflows, handoffs, guardrails and tracing. For a code-owned agent you build on the Responses API and orchestrate with the Agents SDK.
Should I use a hosted agent API or an open framework?
Most production systems use both — an open orchestration layer holding your business logic, calling provider APIs for the model and hosted tools. Hosted APIs are faster to start and remove infrastructure work; open frameworks like LangGraph give more control and portability. Layering them keeps the speed of a hosted API without putting irreplaceable logic inside a product that could be deprecated.
Can one agent use more than one provider API?
Yes, and multi-provider designs are increasingly common. A gateway or adapter layer routes calls to OpenAI, Anthropic, Google, Bedrock, Azure or local models through one internal interface. That lets you use the best model per task, fail over during an outage, and stop a pricing or policy change at one vendor from becoming an emergency.
Is an agent API free? How much does it cost to run?
The APIs themselves are usage-priced — you pay per token, and built-in tools such as web search, file search and code interpreter are billed separately. For a production agent, plan on roughly $3,200–$13,000 per month in run costs (tokens, vector database, monitoring, tuning) on top of the build, depending on volume.
How much does it cost to build an agent on an agent API?
A focused single-workflow production agent typically costs $10,000–$40,000 depending on integrations, data preparation and evaluation depth. Simple rule-based agents can be less; multi-agent or RAG platforms run higher. Building portably adds only a small share up front and is far cheaper than the rewrite that follows an unexpected deprecation.
Can you migrate our existing Agent Builder workflows?
Yes — it's a common request given the 30 November 2026 shutdown. We move the workflow into maintainable code (typically the Agents SDK or an open orchestration framework), rebuild the logic so it's portable rather than tied to a canvas, add an eval set so you can verify behavior matches the original, and hand you the result as code you own.
OpenAI vs Claude vs Mistral vs Google — which agent API is best?
There's no permanent winner — they're converging and all still moving. OpenAI has the broadest tooling, Anthropic is strong on careful reasoning, Google fits Google Cloud shops, and Mistral or open-weight models suit cost control and self-hosting. Choose per task and keep a portable core so the choice can change without a rewrite.
Do we own the code and eval sets you build?
Yes. You own the agent code, tool definitions, prompts, adapters and evaluation sets, on open frameworks with no lock-in. That ownership is what makes portability real — an architecture designed to let you switch providers isn't much use if you can't take the code with you. Maintain it in-house or keep us on by choice.
Build an agent that survives the next deprecation
Tell us what you're building — or what you need migrated off Agent Builder before 30 November. We'll design a portable core with a thin provider adapter, prove it with a working demo on your real workflow, and hand you code you own outright.
AI Agent Frameworks
LangGraph, CrewAI & the rest — which to build your logic on.
Explore →Custom AI Agent Development
A custom agent you own, proven in a demo before you pay.
Explore →Multi-Agent Systems
Several agents that coordinate — without sharing one brittle brain.
Explore →Enterprise AI Agents
Governed, compliant agents wired into real enterprise systems.
Explore →AI Agent Consulting
Honest advice on where agents pay off — and where they don't.
Explore →All AI Agents
Browse the full range of agents we design and hand over to you.
Explore →