OpenAI's visual agent canvas closes on Monday, November 30, 2026, and the models its own safety guide told you to use stop eleven days later. Here is what breaks, how to export, and where to move each kind of agent.
On November 30, 2026, OpenAI shuts down Agent Builder, the drag-and-drop canvas it launched at DevDay in October 2025, together with the Evals platform and the reusable prompt objects behind /v1/prompts - OpenAI deprecations. That is nine days from the date of this guide. The notice went out on June 3, so most teams have had the date on a calendar for months, but a deadline that sits on a calendar is not the same as a migration that is finished, and the last week is when the gaps show: the ChatKit widget whose session still names a workflow ID, the agent nodes pinned to a model that has its own shutdown date, the eval baselines that nobody exported while they were still readable.
This guide is for anyone who built something real in Agent Builder and now has to decide where it lives next. It starts with exactly what stops working and what keeps running, because OpenAI's own replacements are narrower than the deprecation table makes them look. It then walks through the export, maps every Agent Builder node to its equivalent in code and in the main visual tools, and compares the alternatives a team leaving the canvas is actually choosing between: OpenAI's Agents SDK, its newer managed Agents API and ChatGPT Workspace Agents, the visual builders (n8n, Make, Zapier, Langflow, Dify and others), the code frameworks, and the managed agent runtimes that Anthropic, AWS, Google and Microsoft now sell. The search most people type for this is "OpenAI Agent Builder alternatives", and the honest answer is that the right alternative depends less on which product is best and more on what kind of agent you built.
This guide reflects OpenAI's, Anthropic's and Google's documentation and pricing as read on November 21, 2026. Dates, prices and product names in this field move monthly, so verify current details before you commit a migration plan to them.
Contents
- What Ends on November 30, and What Keeps Running
- The Second Deadline Inside Your Export: GPT-5 Ends December 11
- Why OpenAI Is Retiring Its Own Canvas
- First, Name the Kind of Agent You Built
- Export Everything While the Canvas Still Opens
- Node by Node: Where Each Agent Builder Piece Goes
- OpenAI's Own Replacements, Compared
- Every Alternative, Scored for an Agent Builder Migration
- Visual Builders: The Closest Thing to the Canvas
- Code Frameworks: When the Export Becomes Your Codebase
- Managed Agent Runtimes: Renting the Harness Instead
- Replacing OpenAI Evals and Prompt Objects
- Which Model Should Run the Migrated Agent
- How Agent Builder Migrations Fail
- The Migration, in the Order Things Break
- Where Agent Building Goes Next
1. What Ends on November 30, and What Keeps Running
Three products share the November 30 date, and they fail in different ways. Agent Builder is marked deprecated, with the Agents SDK or ChatGPT Workspace Agents as its named replacements and a note that ChatKit remains available - OpenAI deprecations. The Evals platform (dashboard, API and graders) is already in a stricter state: OpenAI's evals guide says it became read-only for existing users on October 31, 2026, before the November 30 shutdown - OpenAI Evals guide. And reusable prompt objects stop resolving when /v1/prompts shuts down, which OpenAI's migration note says began being de-emphasized on June 3 - OpenAI prompt migration guide.
The table below separates what each shutdown actually takes away from what survives it. The right-hand column is the one to read against your own systems, because a deprecation notice names a product while your production traffic depends on specific calls.
| Product | State on Nov 21 | OpenAI's replacement | What stops working on Nov 30 |
|---|---|---|---|
Agent Builder canvas and wf_ workflow objects | Deprecated, still opens | Agents SDK or ChatGPT Workspace Agents | Editing, publishing and running hosted workflows, including ChatKit sessions that name a workflow ID |
| Evals dashboard, API, graders | Read-only since Oct 31 | Promptfoo | Reading past runs, datasets and grader configs |
/v1/prompts reusable prompts | Deprecated | Prompt text in your own code | Any responses.create call that passes prompt: {id: "pmpt_..."} |
| ChatKit UI | Available | Not deprecated | Nothing, if it talks to your own server |
| Logs > Traces | Available | Not deprecated | Nothing; trace grading moves out with Evals |
ChatKit is the row that catches teams. OpenAI's ChatKit guide now offers two paths: a custom server integration that runs on your own infrastructure and can connect to any agent, and the "existing Agent Builder-hosted integration," which it describes as usable "during the Agent Builder transition window" - OpenAI ChatKit guide. In the hosted path, your server creates a ChatKit session by posting a workflow: {id: "wf_..."} to /v1/chatkit/sessions, which means the chat on your site is a thin client for a workflow that lives inside Agent Builder. OpenAI documents that path only for the transition window and points every new or migrating ChatKit app to the advanced integration instead, where you run a ChatKitServer and connect it to the Agents SDK - OpenAI advanced ChatKit integrations. So a ChatKit widget is safe; a ChatKit widget whose server still sends a wf_ ID should be treated as ending with Agent Builder.
The two diagrams OpenAI publishes for ChatKit show the difference in one picture. In the hosted version, OpenAI runs both the chat backend and the agent workflow:
In the self-hosted version, the same frontend talks to a server you run, and that server calls the models and tools itself:
What does not change on November 30 matters as much as what does. The Responses API, the Conversations API, file search and its vector stores, hosted tools and MCP connections do not appear in the feature-deprecation table at all, which lists only prompt objects, Evals and Agent Builder for that date, plus later shutdowns for self-serve fine-tuning job creation (January 6, 2027) and /v1/audio/translations (February 26, 2027) - OpenAI deprecations. A File search node that pointed at a vector store ID therefore loses its canvas, not its data: the same vector store can be searched from the Responses API or the Agents SDK after the move.
Traces are the other survivor. The trace grading guide still sends you to Logs > Traces, where traces from SDK-based apps appear alongside existing Agent Builder workflows "during the transition window," but its "Grade all" step hands off to the evaluation dashboard, which is the part being retired - OpenAI trace grading guide. You keep the ability to inspect what an agent did. You lose the managed way of scoring it.
2. The Second Deadline Inside Your Export: GPT-5 Ends December 11
The deprecations page has a second block of dates that most Agent Builder migration checklists skip. On December 11, 2026, OpenAI shuts down gpt-5, gpt-5-mini, gpt-5-nano, gpt-5-pro, o3 and o3-pro, with gpt-6.1-sol, gpt-6.1-terra and gpt-6-luna as the named replacements - OpenAI deprecations. That matters here because of what Agent Builder itself recommended. Its safety guide has a section titled "Use GPT-5 or GPT-5 mini," which tells builders to configure those models "at the agent node level for a more resilient default posture, especially for higher-risk workflows" - OpenAI, Safety in building agents.
So a team that followed OpenAI's own advice has agent nodes pinned to two models that stop answering eleven days after the canvas closes. The export carries those model strings straight into your new code. If you export on November 29, paste the TypeScript into a repo and ship it, you have built a system that breaks again on December 11. The fix is simple, but it has to be part of the same migration: every model: field in the exported code gets a deliberate choice, made against current models and current prices, not inherited from a canvas default set in 2025.
The replacement OpenAI names is not a like-for-like price, which is the second reason to choose deliberately. Per million tokens, gpt-5-mini cost $0.25 in and $2 out - OpenAI, gpt-5-mini model page. Its named replacement, gpt-6.1-terra, costs $1 in and $5 out, four times the input price and two and a half times the output price - OpenAI, gpt-6.1-terra model page. The same pattern holds down the line, as the chart shows: gpt-5 at $1.25/$10 maps to gpt-6.1-sol at $2/$10, and gpt-5-nano at $0.05/$0.40 maps to gpt-6-luna at $0.10/$0.50.
OpenAI's named replacement is also not the only OpenAI option. GPT-5.4 mini is still active at $0.75 input and $4.50 output per million tokens, below GPT-6.1 Terra on both, which makes it the smaller price step for a workflow that ran happily on gpt-5-mini - OpenAI, gpt-5.4-mini model page. GPT-5.4 nano is not a safe landing spot for gpt-5-nano traffic, though: it is already deprecated, with its own shutdown on April 1, 2027 and GPT-6 Luna named as its replacement - OpenAI deprecations. Moving a node to a model that is itself on the deprecations list only schedules the next migration.
Per-token price is not the whole cost, since a stronger model can finish the same task in fewer tokens and fewer retries, and section 13 works through what a realistic agent workload costs on each candidate. But the direction is clear enough to change a plan: the cheap tier you built on in 2025 does not exist at that price in OpenAI's current lineup, and the decision about which model each migrated agent runs on is worth making with the whole market in view, since the final weeks of Agent Builder's notice period also repriced the top of every major lab's lineup.
The same week holds other dates worth putting on one sheet, because a team migrating agents is usually also migrating the models behind them:
Anthropic retires claude-sonnet-4-5-20250929 on November 30 as well, with claude-sonnet-5-5 as its replacement - Anthropic model deprecations. Google's Gemini 4 Carbon and Argon move to $4 input and $20 output per million tokens starting December 1 - Gemini API pricing. We covered the Gemini 2.5 retirement that lands the same day in our Gemini 2.5 migration guide and the last round of OpenAI model shutdowns in the GPT-4 shutdown guide. The practical point is that "move off Agent Builder" and "move off last year's models" are one project this month, and doing them as two projects means touching the same code twice.
3. Why OpenAI Is Retiring Its Own Canvas
It is worth understanding why the canvas is going, because the reason predicts which alternatives will still exist in a year and which will follow it. Start with what a visual agent builder actually provides. It gives you four things at once: a way to express control flow (which step runs after which, on what condition), a place to host that flow, an interface aimed at people who do not write code, and a tight coupling to the vendor's own tools, which in Agent Builder's case meant file search, connectors, ChatKit and the Evals dashboard. Each of those four had a reason to exist in October 2025. Each was weakened by what happened next.
The first force is the models themselves. A graph editor makes you draw the control flow because, when it was designed, the model could not be trusted to plan it. By the time of the notice, OpenAI's stack had moved the planning into the model and the harness around it. The Agents API, released in public beta on September 10, 2026, gives applications "access to the Codex harness through an OpenAI-managed API," with OpenAI handling sessions, orchestration, context compaction and recovery - OpenAI Agents API overview. Less than three weeks later, GPT-6.1 Sol shipped with multi-agent support in the Responses API, letting the model "delegate work to subagents" within a single request - OpenAI changelog. When the model can decompose a task, spawn helpers and recover from its own mistakes, a hand-drawn graph stops being the main way to build an agent and becomes, for many tasks, a constraint on it.
The second force is that a canvas sits between two audiences who are each better served by something else. Developers want version control, code review, tests and CI, and a graph in a web dashboard offers none of those; a graph editor is a programming language operated with a mouse, which inherits the cost of programming (you still specify every branch) without its tools. Non-developers, meanwhile, increasingly do not want to draw anything at all. OpenAI's own split of the replacement says this plainly: the Agents SDK is "best for building agents through code," and ChatGPT Workspace Agents are "best for building agents through natural language and sharing them with teams" - OpenAI, Migrate from Agent Builder. The middle option, drawing boxes, has no constituency left in OpenAI's own plan.
OpenAI itself never published a reason. Its June 3 changelog entry simply "announced the deprecation of reusable prompt objects, the Evals platform, and Agent Builder" - OpenAI changelog. The note added to the original AgentKit announcement says only that OpenAI "is winding down the Agent Builder and Evals products," recommending the Agents SDK "for workflows that should continue as code" and Workspace Agents "for use cases better suited to natural language prompting" - OpenAI, Introducing AgentKit. When Agent Builder launched on October 6, 2025, Sam Altman described it as "like Canva for building agents" - TechCrunch. Developers on OpenAI's forum were blunter about the eight months between those two dates. "Building and oferring a tool that in around 6 months is deprecated...??? Not a sound business strategy to me," wrote one developer who had built ChatKit deployments for multiple clients on the hosted backend - OpenAI Developer Community, Agent Builder thread.
OpenAI's own launch demo from DevDay is the best record of what is being retired: it walks through the canvas the way it was pitched, as a fast visual way to wire agents, tools and logic into a workflow you could publish and embed.
The clearest statement of the structural reason came from a different vendor. Workday bought Flowise, a popular open-source visual agent builder, in August 2025 - Workday newsroom. On July 29, 2026, Flowise announced it was winding down, with end of life on August 31, and explained why: "As AI models become more capable at reasoning, we've noticed that developers are increasingly relying on new coding agents such as Claude Code/OpenClaw to handle complex tasks. The typical rigid workflow low code approach quickly hits the limit when it comes to complexity" - Flowise, The Future of Flowise. Its GitHub repository is now archived. Two general-purpose agent canvases closing within four months of each other, one from a model lab and one from an independent tool, is not a coincidence of product management. It is the same force acting on the same category.
The third force explains the other two shutdowns on the same date. Reusable prompt objects and the Evals dashboard were, like workflow graphs, pieces of an application's definition stored in OpenAI's dashboard instead of in the application's repository. OpenAI's replacement for both moves that definition back to the developer: prompts go into "your application code," which OpenAI says gives "more control over review, testing, deployment, and versioning" - OpenAI prompt migration guide. Evals go into Promptfoo, "centered on a portable configuration file and CLI workflow" that lives "alongside your application code" - OpenAI cookbook, Moving from OpenAI Evals to Promptfoo. All three retirements share one pattern: OpenAI is getting out of the business of hosting the definition of your agent.
It would be easy to read that as OpenAI giving up lock-in, and that reading does not survive a closer look. The definition is the cheap part to host and the part customers most wanted in their own repositories anyway. What OpenAI is investing in is the runtime: the managed harness, the hosted sandboxes billed per container session, durable sessions, scheduled automations and automatic review in the Agents API, and the seat-based distribution of agents inside ChatGPT. The dependency is not shrinking; it is moving from the canvas, where it was visible, to the runtime, where it compounds. That is the most useful frame for every decision in the rest of this guide. Own the parts that are cheap to own and expensive to lose (prompts, tool definitions, evals, routing logic, the choice of model), and treat the runtime as something you rent deliberately, with a clear idea of what it would take to move.
It is also the clearest argument for a principle that matters more as agents do more of a company's real work. A lab can retire a product on six months' notice, and this one did. The defence is not to avoid labs, since every serious alternative in this guide still runs on someone's model. It is to keep control of the things that define your agent, in a form you can take to another runtime and another model, so that the next notice costs a migration measured in days rather than a rebuild measured in months.
4. First, Name the Kind of Agent You Built
"Agent Builder alternatives" lists usually rank tools against each other as if every workflow were the same thing. They are not. Agent Builder was general enough that teams used it for at least five structurally different jobs, and each one has a different natural home, because each one depends on a different part of what the canvas quietly provided: a chat surface, a trigger, a deterministic control flow, a tool connection, or a long-running loop.
The first shape is the customer-facing chat agent: a support or onboarding assistant embedded on a site through ChatKit, where strangers type into a box and the agent answers with your knowledge base and your tools. What it needs from its next home is a server you control, a per-user identity on every session, guardrails on untrusted input, and a predictable cost per conversation. The second shape is the internal team assistant: a sales-prep or HR helper that employees use and that reads company data. It needs single sign-on, connectors to the systems the team already uses, and permissions, and it barely needs custom UI at all.
The third shape is the event-driven automation: an email or a form submission arrives, an agent classifies it, drafts a response, waits for a human to approve, and sends. What it needs most is triggers and connectors, which are exactly the things Agent Builder never really had and which OpenAI's migration guide lists among the behaviors that "may need manual recreation" - OpenAI, Migrate from Agent Builder. The fourth is the deterministic pipeline with model steps: classify, branch on the class with an If/else node, reshape the output with a Transform node, return structured JSON. Here the control flow is the product and the model is a component. The fifth is the long-running task agent, a research or operations agent that runs for minutes, uses a sandbox, and comes back with an artifact; it needs a harness that can compact context, recover from failure and resume.
The table maps each shape to where it usually lands best. Treat it as a starting point for your own judgment rather than a rule, since many real workflows mix two shapes.
| What you built | The part that matters most | Usually lands best on | Watch out for |
|---|---|---|---|
| Customer-facing chat (ChatKit embed) | Your server, user identity, guardrails | Agents SDK behind a self-hosted ChatKit server, or another code framework with its own chat UI | Losing the guardrail nodes in translation |
| Internal team assistant | SSO, connectors, permissions | ChatGPT Workspace Agents, Copilot Studio or Gemini Enterprise, matching the suite your team lives in | Per-seat plan costs; who can publish |
| Event-driven automation | Triggers, connectors, approvals | n8n, Make or Zapier, or the Agents SDK on your own queue | A trigger API that cannot return the agent's answer |
| Deterministic pipeline | Exact control flow, typed outputs | Plain code (Agents SDK, Responses API, LangGraph) or n8n | Turning branches into "let the model decide" |
| Long-running task agent | Sandbox, compaction, resume | OpenAI Agents API, Claude Managed Agents, Bedrock AgentCore | Runtime billing and data retention |
Two rows deserve a warning before you read any further. The deterministic pipeline is the one most likely to be damaged by the "easy" migration path, because OpenAI's own guide says that "workflows with strong determinism at their core may not migrate faithfully to a workspace agent" - OpenAI, Migrate from Agent Builder. A workspace agent is built by describing what you want in natural language, and the model then decides how to do it; an If/else node that guaranteed refunds over $500 always went to a human becomes, in that world, an instruction the model usually follows. If a branch in your workflow exists for compliance or money reasons, it belongs in code or in a workflow tool that executes it literally.
The event-driven automation has a quieter trap. ChatGPT's Workspace Agents API can trigger a published agent from your backend, but its own documentation says "the agent's response cannot currently be retrieved through the API": the trigger returns a link to a ChatGPT conversation, and run-status polling is a beta behind an extra header - OpenAI, Trigger workspace agent runs. That is fine when a person reads the result in ChatGPT. It is not fine when the next step of your pipeline needs the agent's output as data.
5. Export Everything While the Canvas Still Opens
Everything below assumes the canvas still loads, which it does until November 30. The order matters: export first, decide second. An export costs minutes and keeps every option open; a decision made without one forces you to rebuild from memory.
Export each workflow as Agents SDK code
OpenAI's export path is four clicks: open the workflow, select Code in the top navigation, choose Agents SDK, pick TypeScript or Python and copy the complete export - OpenAI, Migrate from Agent Builder. The dialog looks like this:
Export in both languages if you have not decided where the agent goes yet; the cost is a second copy-paste, and a team that later moves to a Python stack will not have to translate TypeScript by hand. Commit every export to a repository the day you make it, with the workflow ID and the version number in the commit message. Agent Builder treated each publish as a versioned snapshot and let API calls pin an older version - OpenAI Agent Builder guide, so if production pins a version other than the latest draft, export that version, not the one on screen.
Record what the export does not carry
OpenAI is explicit that the export "does not convert your workflow graph or guarantee that every behavior transfers unchanged," and it lists control flow, triggers, tools and permissions as things to review, with connected apps, authentication, publishing and permission configuration needing separate setup - OpenAI, Migrate from Agent Builder. In practice that means writing down, for each workflow, what the code cannot tell you: a screenshot of the full canvas, the list of connectors and MCP servers with the account each one is authorized as, which ChatKit deployments create sessions against this workflow ID, and which model each agent node uses. That last list is your December 11 to-do list from section 2.
Pull your prompts out of /v1/prompts
Search every codebase you own for pmpt_ and for calls that pass a prompt parameter to the Responses API. Each hit is a call that stops resolving on November 30. OpenAI's migration is to inline the prompt: replace prompt: {id, version, variables} with an explicit model and input array that carries the system and user text - OpenAI prompt migration guide. The detail people miss is that the prompt object also carried a model choice and a version, so inlining is the moment to decide both on purpose, and to put the prompt text in a file under version control rather than a string literal buried in a handler.
Download your eval history while it is still readable
The Evals dashboard is read-only now and gone after November 30, and OpenAI's own Promptfoo guide notes the move "does not require an OpenAI Evals export feature," which is a polite way of saying there is not one - OpenAI cookbook, Moving from OpenAI Evals to Promptfoo. The API's read endpoints still answer: GET /v1/evals, GET /v1/evals/{eval_id}/runs and GET /v1/evals/{eval_id}/runs/{run_id}/output_items, each paginated with after, limit and has_more - OpenAI API reference, eval run output items. A short script that walks them saves your test data and your baseline scores, which you will need to prove the migrated agent is at least as good as the old one:
# Dump every eval, run and output item to JSON files before Nov 30.
import json, os, pathlib, requests
BASE = "https://api.openai.com/v1"
HEAD = {"Authorization": f"Bearer {os.environ ['OPENAI_API_KEY']}"}
OUT = pathlib.Path("openai-evals-export")
def pages(path):
after = None
while True:
params = {"limit": 100, **({"after": after} if after else {})}
page = requests.get(f"{BASE}{path}", headers=HEAD, params=params, timeout=60).json()
yield from page.get("data", [])
if not page.get("has_more"):
return
after = page ["last_id"]
for ev in pages("/evals"):
folder = OUT / ev ["id"]
folder.mkdir(parents=True, exist_ok=True)
(folder / "eval.json").write_text(json.dumps(ev, indent=2))
for run in pages(f"/evals/{ev ['id']}/runs"):
items = list(pages(f"/evals/{ev ['id']}/runs/{run ['id']}/output_items"))
(folder / f"{run ['id']}.json").write_text(json.dumps({"run": run, "items": items}, indent=2))
Run it once now and once on November 29. The eval object holds your testing criteria (the grader definitions), the run objects hold the per-run scores, and the output items hold every input and output the graders judged, which is the raw material for the regression suite you will rebuild in section 12.
Keep a sample of real traces
The last thing to save is the most underrated: a few dozen real production traces per workflow, chosen to cover the common path, the edge cases and the failures. Logs > Traces still shows them - OpenAI trace grading guide. A trace records the model calls, tool calls, guardrail results and handoffs of one real run, which makes it the closest thing you have to a specification of what the workflow actually does, as opposed to what the canvas says it should do. Those inputs become the first test cases for whatever you migrate to.
6. Node by Node: Where Each Agent Builder Piece Goes
Agent Builder had a small, fixed vocabulary of nodes, which is what makes a systematic migration possible. OpenAI's node reference groups them into core nodes (Start, Agent, Note), tool nodes (File search, Guardrails, MCP), logic nodes (If/else, While, Human approval) and data nodes (Transform, Set state) - OpenAI node reference. Here are the logic nodes as they appeared on the canvas, since they are the ones whose behavior is easiest to lose:
The If/else and While nodes evaluated conditions written in the Common Expression Language, so every branch in your workflow is a small, inspectable expression, and that is good news for a migration: a CEL expression translates almost one to one into an if statement in Python or TypeScript, or into an IF node in a visual tool. The table maps each node to its Agents SDK equivalent and to the closest construct in a typical visual workflow tool.
| Agent Builder node | What it did | In the Agents SDK | In a visual tool (n8n-style) | What to watch |
|---|---|---|---|---|
| Start | Took the user input, exposed input_as_text and state variables | The input to run(), plus a context object | A trigger node (chat, webhook, form) | State variables become your own storage |
| Agent | Instructions, model, tools | Agent(name, instructions, model, tools) | An AI Agent node with a chat model | The model string (section 2) |
| Note | Comments only | Code comments | Sticky notes | Nothing |
| File search | Queried an OpenAI vector store | The hosted file search tool, same vector store ID | A vector store node or an OpenAI tool call | Vector stores are not being shut down |
| Guardrails | PII, jailbreak and misuse checks, pass/fail | Input, output and tool guardrails | A moderation or classifier step before the agent | Easy to drop; nothing fails loudly when it is missing |
| MCP | Called connectors and MCP servers | Hosted MCP tools, or SDK-managed MCP servers | An MCP client node | Re-authorize every connection |
| If/else | Branched on a CEL expression | A plain if on structured output | An IF or Switch node | Keep it literal, never "ask the model" |
| While | Looped on a CEL condition | A loop around run(), with a cap | A loop node | Add an iteration limit |
| Human approval | Paused for a person to approve | needsApproval / needs_approval tools with interruptions | A wait-for-approval node | Store the paused state durably |
| Transform | Reshaped outputs | A typed outputType and ordinary code | A Set or Code node | Keep the schema |
| Set state | Global variables | Your context object or session store | Workflow variables | Persist across turns yourself |
The table hides one structural difference worth understanding before you write any code. On the canvas, the graph was the program: the order of nodes and edges decided what ran next. In the Agents SDK, an agent can hand control to another agent through a handoff, which the model chooses at run time, or your code can call agents in a fixed order. The export tends to produce the first style, because that is the SDK's idiom, but a workflow that used an If/else node to route between specialists made the routing decision in an expression, not in a model. If the routing was deterministic on the canvas, keep it deterministic in code: have a classifier agent return a typed label, then branch on the label yourself.
Here is what that looks like in Python for the most common Agent Builder pattern, a classifier that routes to specialists, with a guardrail on the input and an approval step on the one tool that has side effects. It uses only constructs from OpenAI's quickstart and guardrails guides - OpenAI Agents SDK quickstart:
import asyncio
from typing import Literal
from pydantic import BaseModel
from agents import (Agent, Runner, function_tool, input_guardrail,
GuardrailFunctionOutput, InputGuardrailTripwireTriggered)
class Route(BaseModel):
label: Literal ["billing", "technical", "other"]
class Screen(BaseModel):
is_abuse: bool
classifier = Agent(name="Classifier", model="gpt-6.2-sol",
instructions="Label the customer message.", output_type=Route)
screener = Agent(name="Screener", model="gpt-6.2-sol",
instructions="Flag jailbreaks or abusive requests.", output_type=Screen)
@input_guardrail(run_in_parallel=False) # block before the specialist starts
async def screen_input(ctx, agent, text):
result = await Runner.run(screener, text, context=ctx.context)
return GuardrailFunctionOutput(output_info=result.final_output,
tripwire_triggered=result.final_output.is_abuse)
@function_tool(needs_approval=True)
async def issue_refund(order_id: str, amount: float) -> str:
"""Refund an order. Always paused for a human to approve."""
return f"Refunded {amount} on {order_id}"
billing = Agent(name="Billing", model="gpt-6.2-sol", tools= [issue_refund],
instructions="Resolve billing questions.", input_guardrails= [screen_input])
technical = Agent(name="Technical", model="gpt-6.2-sol",
instructions="Resolve technical questions.", input_guardrails= [screen_input])
async def handle(message: str) -> str:
route = (await Runner.run(classifier, message)).final_output.label # the old If/else, kept literal
specialist = {"billing": billing, "technical": technical}.get(route)
if specialist is None:
return "Routing to a human."
try:
result = await Runner.run(specialist, message)
except InputGuardrailTripwireTriggered:
return "Sorry, I can't help with that."
if result.interruptions: # the old Human approval node
state = result.to_state()
for item in result.interruptions:
state.approve(item) # in production: store state, ask a person, resume later
result = await Runner.run(specialist, state)
return result.final_output
Three choices in that snippet are deliberate and worth copying. The routing is an ordinary dictionary lookup on a typed label, so it behaves exactly like the If/else node did. The guardrail is set to run_in_parallel=False, so it finishes before the specialist starts, and it raises a specific exception, which mirrors the pass/fail behavior of the Guardrails node, where OpenAI recommended ending the workflow or returning to the previous step on failure - OpenAI node reference. And the refund tool is the only place that pauses for approval, because approvals in the SDK attach to tools rather than to a position in a graph: the run records an interruption, returns a resumable state, and continues once your application approves or rejects it - OpenAI, Guardrails and human review. In production, that state is serialized to a database while a person decides, which is the piece the canvas used to handle for you and which a migration most often forgets.
7. OpenAI's Own Replacements, Compared
The deprecations page names two replacements, but OpenAI's stack offers more landing spots than that, and the one the table does not name may be the best fit for some teams. OpenAI's own agents overview lays out the code-side options as a spectrum of how much of the agent loop you want OpenAI to run: the Agents API "for long-running tasks where OpenAI manages the agent and saves its progress," the Agents SDK "for building agents with custom tools and workflows in your application," and the plain Responses API for "calling models directly or building an agent from scratch" - OpenAI agents overview. Outside the API sit ChatGPT Workspace Agents, built in conversation inside ChatGPT, and alongside all of them ChatKit, the chat interface that survives the shutdown.
The Agents SDK: the export's native format
The Agents SDK is the path of least resistance because the export is already Agents SDK code. It is an open-source library for Python and TypeScript in which "the SDK runs inside your application," with your own storage and sessions holding state and your runtime executing tools - OpenAI agents overview. You pay only for model tokens and any hosted tools you call; there is no platform fee. What you take on is everything the canvas hosted: a server, deployment, secrets, durable state for approvals, and observability, though the SDK's built-in tracing still feeds OpenAI's Traces dashboard. The current releases are openai-agents 0.25.0 on PyPI and @openai/agents 0.22.0 on npm - PyPI, openai-agents. Despite the name, the SDK is not tied to OpenAI's models: its README describes it as "provider-agnostic, supporting the OpenAI Responses and Chat Completions APIs, as well as 100+ other LLMs" - GitHub, openai-agents-python. It also has sandbox agents, which give an agent "an isolated, Unix-like execution environment" with a filesystem and shell, running locally, in Docker or on hosted providers such as E2B, Modal, Daytona, Cloudflare and Vercel - OpenAI, Sandbox agents.
This is the right landing spot for customer-facing chat (paired with a self-hosted ChatKit server), for deterministic pipelines that need exact control flow, and for any team that wants its agent in a repository with tests. It is the wrong one for a team with no engineer who can own a deployed service, which is precisely the team that chose a canvas in the first place.
The Agents API: the managed harness the table does not name
The Agents API, in public beta since September 10, is OpenAI's answer to "I want the agent hosted, but in code." Your application creates a session with an agent definition (model, instructions, tools and MCP servers), sends it tasks and receives events, while OpenAI runs "a managed Codex harness" that handles orchestration, compaction and recovery, with an optional sandbox that can be OpenAI-hosted, self-hosted or absent - OpenAI agents overview. It has gained a long feature list since launch: scheduled automations that start sessions on a cron expression and let an agent schedule its own follow-ups - OpenAI, Scheduled automations. It has also added automatic review of tool and permission requests, and computer use in an OpenAI-hosted browser - OpenAI changelog.
Pricing has no separate platform line: model usage is billed at the model's API rates, OpenAI tools at their standard rates, and OpenAI-hosted sandboxes at container rates - OpenAI Agents API overview. Those container rates run from $0.03 to $1.92 per 20-minute container session depending on memory, billed by the minute with a five-minute minimum - OpenAI pricing. The diagram from OpenAI's overview shows the split of responsibilities:
OpenAI's launch video for the Agents API, published the day the public beta opened, shows the managed-harness model in action, which is the clearest way to judge whether your workflow wants a harness that plans its own steps:
The Agents API suits the long-running task agent and the event-driven automation better than the SDK does, because durable sessions, schedules and recovery are exactly what a team would otherwise build itself. Two cautions apply. It is a beta, so its API can still change, and it is more opinionated than the SDK: a workflow whose value lies in strict, deterministic control flow fits it less well than one that benefits from the harness planning its own steps.
ChatGPT Workspace Agents: the no-code successor
Workspace agents are OpenAI's no-code destination, described at launch as "an evolution of GPTs" and "powered by Codex" - OpenAI, Introducing workspace agents. You build one by describing it in a conversational builder, and you can add "tools, apps, custom MCPs, skills, and files" - OpenAI Help Center, workspace agents. The migration guide's second option is to paste your exported code into a new workspace agent with the prompt "Please help me convert this workflow into an agent," then review what the builder flags before creating it - OpenAI, Migrate from Agent Builder.
OpenAI's launch video shows how a workspace agent is built by conversation rather than by wiring nodes, which is the core difference an Agent Builder user should see before choosing this path:
They require a ChatGPT Business, Enterprise or Edu workspace. ChatGPT Business lists a standard seat at $20 a month billed annually or $25 monthly, a premium seat at $100 or $125, and workspace agents as a Business and Enterprise feature - OpenAI, ChatGPT Business pricing. Runs consume credits on token-based pricing, and OpenAI's rate card says "a typical end-to-end Workspace Agent run using GPT-5.6 may consume between 5 and 25 credits," drawn from a pool shared with ChatGPT Work, Codex and the Office add-ins - OpenAI Help Center, credit rate card. Admin controls are real: workspace agents start off by default for Enterprise workspaces, which admins enable - OpenAI Help Center, workspace agents. The Compliance API shows every agent's configuration, updates and runs, with the power to suspend an agent - OpenAI, Introducing workspace agents.
For the internal team assistant, this is the most natural successor: the people who use the agent already live in ChatGPT, and the agent inherits its sign-in and connectors. For anything customer-facing, deterministic or pipeline-shaped, the two limits covered in section 4 rule it out: it migrates deterministic flows imperfectly, and its trigger API cannot hand the agent's answer back to your code.
ChatKit on your own server
ChatKit itself survives, and for a customer-facing chat agent it is often the cleanest migration: keep the front end your users already see, and replace the hosted workflow behind it with your own ChatKitServer (pip install openai-chatkit) that streams responses from an Agents SDK agent through helpers like stream_agent_response - OpenAI advanced ChatKit integrations. Storage for uploaded files and images costs $0.10 per GB-day after 1 GB free - OpenAI pricing. The work is a server, a thread store and authentication; the payoff is that nothing your users touch changes on November 30.
| OpenAI path | Who runs the agent loop | Build style | Price beyond tokens | Best for |
|---|---|---|---|---|
| Agents SDK | Your application | Code (Python, TypeScript) | None | Chat agents, deterministic pipelines, teams with engineers |
| Agents API (beta) | OpenAI's managed Codex harness | Code, hosted sessions | Containers $0.03 to $1.92 per 20 min, if used | Long-running and scheduled task agents |
| Workspace Agents | OpenAI, inside ChatGPT | Natural language | Business seat $20 to $25, credits per run | Internal team assistants |
| ChatKit, self-hosted | Your server (plus SDK) | Code | File storage after 1 GB | Keeping an existing chat UI |
| Bedrock Managed Agents (preview) | Amazon Bedrock, OpenAI harness | Code, AWS IAM | AWS resources used | AWS-first teams wanting OpenAI's harness |
The last row is the newest. Amazon Bedrock Managed Agents "adapts the Agents API for AWS," running OpenAI's harness and model inference inside Bedrock, with AgentCore Runtime or self-hosted compute executing commands and tools and AWS IAM handling authentication - OpenAI, Bedrock Managed Agents. AWS lists it as a preview in three US regions and says you pay for model inference and the AWS resources your application uses - AWS, Bedrock Managed Agents documentation. OpenAI's own page adds that "shared concepts don't imply identical API contracts or feature availability," so treat it as a separate product that shares ideas with the Agents API, not a mirror of it.
8. Every Alternative, Scored for an Agent Builder Migration
The table below scores twenty-four options on the five things that decide how well a migration off Agent Builder goes. It is a ranking for the general case, a team with a mix of workflows that wants one sensible next home; section 4's shape-by-shape guidance overrides it for a specific agent, which is why a tool can rank low here and still be the right answer for one kind of agent (ChatGPT Workspace Agents for an internal assistant is the clearest example).
The weights follow from what actually costs teams time and money in this migration. Migration fit (30%) carries the most weight because it measures how much of an existing workflow carries over without being redesigned: whether the exported code runs as is, and whether the nodes you relied on (branches, approvals, guardrails, MCP tools, an embeddable chat) have direct equivalents. Model freedom (20%) matters because the shutdown is itself a lesson in single-vendor dependence and because, as section 13 shows, the cost of an agent depends heavily on picking the right model for each step. Cost to run (20%) covers what you pay beyond model tokens. Production readiness (15%) reflects whether the product is generally available and governable, since moving a production workflow onto a beta trades one risk for another. Exit and portability (15%) asks how hard the next migration would be: open-source licenses, self-hosting and exportable definitions score high, configuration that lives only inside a hosted product scores low.
| # | Option | Category | Migration fit (30%) | Model freedom (20%) | Cost to run (20%) | Production readiness (15%) | Exit and portability (15%) | Final |
|---|---|---|---|---|---|---|---|---|
| 1 | OpenAI Agents SDK | Code framework | 10 - the export is native SDK code | 8 - OpenAI plus 100+ LLMs via LiteLLM | 9 - MIT, tokens only | 8 - 30.8k stars, still 0.x | 9 - MIT code in your repo | 8.95 |
| 2 | n8n | Visual builder | 8 - Agent node, IF, tool approvals, MCP, chat embed | 9 - OpenAI, Anthropic, Gemini, Bedrock, Ollama | 7 - Starter €20/mo annual, 2.5K runs | 8 - mature; Agents mode in preview | 8 - self-host, JSON export, not OSI | 8.00 |
| 3 | Langflow | Open-source visual | 7 - agent canvas, deploy flows as MCP | 9 - all major LLMs | 9 - MIT, self-host free | 6 - hosted Astra version removed Apr 2026 | 9 - MIT | 7.95 |
| 4 | Dify | Open-source visual | 8 - workflow canvas, agents, RAG, MCP | 9 - hundreds of LLMs | 8 - free Sandbox; Pro $590/yr per workspace | 7 - 1.20.0, Gartner MQ niche player | 7 - modified Apache, no multi-tenant resale | 7.90 |
| 5 | LangGraph + LangSmith | Code framework | 7 - explicit graphs mirror deterministic flows | 9 - any model via LangChain | 8 - MIT; LangSmith free tier, Plus $39/seat | 8 - 1.x releases | 8 - MIT code, platform proprietary | 7.90 |
| 6 | AWS Bedrock AgentCore | Managed runtime | 8 - runs the exported SDK code as is | 9 - any framework, any model | 7 - $0.0895/vCPU-h plus memory, gateway | 8 - available, identity built in | 7 - your code, AWS infrastructure | 7.85 |
| 7 | Pydantic AI | Code framework | 6 - published Agents SDK migration skill | 9 - dozens of providers | 9 - MIT | 7 - 2.x, weekly releases | 9 - MIT | 7.80 |
| 8 | Vercel AI SDK | Code framework | 5 - ToolLoopAgent, port by hand | 9 - provider-agnostic | 9 - Apache-2.0 | 8 - 7.x | 9 - Apache-2.0 | 7.65 |
| 9 | Google ADK | Code framework | 5 - rewrite; Visual Builder experimental | 8 - Gemini, Claude, OpenAI, local | 9 - Apache-2.0 | 8 - 2.x, five languages | 9 - Apache-2.0 | 7.45 |
| 10 | Mastra | Code framework | 6 - TS agents and workflows, port the TS export | 9 - 40+ providers | 8 - core Apache; cloud $0 to $250/mo | 7 - 1.x since Jan 2026 | 7 - ee/ parts under separate license | 7.30 |
| 11 | Microsoft Agent Framework | Code framework | 5 - rewrite from the export | 8 - Foundry, OpenAI, Claude, Gemini | 9 - MIT | 8 - 1.0 production release | 8 - MIT | 7.30 |
| 12 | CrewAI | Code framework | 5 - role-based crews, different idiom | 8 - many, incl. local | 8 - MIT; AMP free tier 50 runs/mo | 7 - 1.15, mature | 8 - MIT | 6.95 |
| 13 | Gemini Enterprise Agent Platform | Managed runtime | 5 - rebuild in ADK or Agent Studio | 8 - Gemini, Claude, 200+ in Model Garden | 7 - $0.085/vCPU-h, idle free | 8 - Vertex AI's successor | 6 - state on Google Cloud | 6.60 |
| 14 | Make | Visual builder | 6 - agent inside scenarios; approvals Enterprise beta | 7 - Make AI provider; own keys on paid | 8 - Core $12/mo at 10k credits | 6 - AI Agent in open beta | 4 - cloud only, blueprint export | 6.30 |
| 15 | Claude Agent SDK | Code framework | 5 - rewrite to an embedded Claude Code agent | 3 - Claude only | 9 - library free, tokens only | 8 - the loop behind Claude Code | 7 - your code, Anthropic terms | 6.15 |
| 16 | Zapier (AI by Zapier) | Visual builder | 6 - AI step in Zaps, approvals, chat embed | 8 - OpenAI, Anthropic, Google, more; own key | 6 - Pro from $19.99/mo, MCP call = 2 tasks | 7 - mature; Agents being folded in | 3 - no self-host or code export | 6.10 |
| 17 | OpenAI Agents API | Managed runtime | 7 - agent defs map over; no graph | 3 - OpenAI models | 8 - no platform fee; containers if used | 6 - public beta since Sep 10 | 5 - sessions held by OpenAI | 5.95 |
| 18 | Relevance AI | Visual builder | 6 - Workforce canvas, approvals, embeds | 7 - OpenAI, Gemini, Anthropic, BYOK | 6 - Pro $19/mo annual, 2,500 actions | 6 - evals Enterprise only | 3 - no self-host | 5.75 |
| 19 | Microsoft Copilot Studio | Suite builder | 5 - visual canvas, rebuild by hand | 7 - GPT, Claude, Grok, external models | 5 - $0.05 per agent action at PAYG | 9 - Entra Agent ID, Agent 365 | 3 - lives in Power Platform | 5.70 |
| 20 | Claude Managed Agents | Managed runtime | 5 - redefine agent via API | 3 - Claude only | 8 - $0.08 per running session-hour | 6 - beta; self-hosted by request | 6 - self-hosted edition holds state | 5.50 |
| 21 | Bedrock Managed Agents | Managed runtime | 6 - OpenAI harness concepts on AWS | 3 - OpenAI models | 7 - AWS resources plus inference | 4 - preview, three US regions | 5 - state in your AWS account | 5.15 |
| 22 | Gumloop | Agent platform | 4 - agent-first; workflows now legacy | 7 - Anthropic, OpenAI, Google, more | 5 - $37/mo plus 8% orchestration fee | 6 - approvals, built-in grading | 3 - no self-host | 4.95 |
| 23 | Lindy | Agent platform | 3 - no canvas; chat-driven AI employee | 7 - OpenAI, Claude, Gemini, DeepSeek | 6 - $29.99 per user/mo, 3,000 credits | 6 - approvals on outside actions | 2 - no export or self-host | 4.70 |
| 24 | ChatGPT Workspace Agents | No-code (ChatGPT) | 5 - paste export; deterministic flows lossy | 2 - OpenAI models | 6 - $20 to $25/seat plus credits | 7 - admin controls, Compliance API | 3 - lives inside ChatGPT | 4.60 |
Scores reflect each vendor's own documentation, pricing pages and package registries as read on November 21, 2026; the final score is the weighted average of the five criteria. n8n's prices were served in euros to this guide's location. Make's figure comes from its own August 2026 guide because its pricing page renders in the browser.
Three things stand out once the table is sorted. First, the export's native home wins clearly, which is the honest result: when the migration is about keeping production running before a deadline, the option that runs your code unchanged on any model, under an MIT license, is hard to beat, and the remaining work (a server, durable approvals, tracing) is work you would do on most of the alternatives anyway. Second, the strongest visual alternatives are the ones that are either open source or built around an integration catalog: n8n, Langflow and Dify all score well on exit and model freedom, which is exactly where Agent Builder was weakest. Third, the managed runtimes cluster in the lower middle not because they are poor products but because they are young (the OpenAI Agents API, Claude Managed Agents and Bedrock Managed Agents are all beta or preview) and because, by design, they hold your agent's state, which costs them on portability. For a long-running task agent, their harness may be worth that trade; the table simply makes the trade visible.
Two names are missing on purpose. Flowise reached end of life on August 31, 2026, with its repository archived - Flowise, The Future of Flowise. Vellum, which once sold a visual workflow builder, now runs a personal assistant product that is itself shutting down, with exports available until December 13, 2026 - Vellum shutdown notice. Neither is a place to move a production workflow this month.
9. Visual Builders: The Closest Thing to the Canvas
For a team whose Agent Builder users were not developers, the natural question is which canvas to move to. The answer starts with a pattern that the table above only hints at: the general-purpose agent canvas is a shrinking category. In the space of a few months, OpenAI announced the end of Agent Builder, Workday's Flowise reached end of life, and DataStax removed its hosted Langflow from Astra and pointed users to the open-source version - DataStax Langflow release notes. Gumloop relabelled its workflow product "Workflows (Legacy)" on its pricing page in favor of agents - Gumloop pricing. Zapier folded its standalone Agents product into an "AI by Zapier" step inside ordinary Zaps - Zapier blog. Even n8n, the strongest canvas in this guide, added a new kind of agent in September that you set up by describing what it should do, after which "it works out the steps itself" - n8n blog, Introducing n8n Agents.
The canvases that remain healthy share one trait: the canvas is the front end of something harder to copy, either a large integration and trigger system, or an open-source codebase you can run and fork. That is the lens for choosing among them.
n8n: the strongest like-for-like replacement
n8n is the closest thing to what Agent Builder should have been for many teams: a mature workflow canvas with an AI Agent node that takes a chat model and a set of tools - n8n AI Agent node docs, and around it the pieces Agent Builder never had, triggers and hundreds of app integrations. Almost every Agent Builder node has a direct counterpart. Branches become IF and Switch nodes. Human approval exists per tool: "You can make an AI agent wait for human approval, in Slack, n8n Chat, or another channel, before it runs a specific tool" - n8n, Human-in-the-loop for tools. MCP works in both directions: an MCP Client Tool node calls outside servers, and an MCP Server Trigger lets n8n "act as a Model Context Protocol (MCP) server, making n8n tools and workflows available to MCP clients" - n8n, MCP Server Trigger. The Chat Trigger offers hosted chat or an embedded widget, which covers the ChatKit use case - n8n Chat Trigger docs. It also has evaluations built in, light ones before deployment and metric-based ones after - n8n evaluations overview.
On pricing, n8n's page served this guide euro prices: Starter at €20 a month billed annually for 2,500 workflow executions with unlimited steps, Pro at €50 for 10,000 executions, and Business at €667 for 40,000, with every plan including unlimited users, workflows and integrations - n8n pricing. The self-hosted version is free, which is the main reason n8n scores well on exit, with one caveat a careful buyer should read: it is distributed under the Sustainable Use License, which allows use "only for your own internal business purposes or for non-commercial or personal use" - n8n Sustainable Use License. That is fine for running your own agents and not fine for reselling n8n as a hosted service. Workflows export as JSON files, so a definition never has to live only in n8n's cloud. The company itself looks durable: SAP invested in May at a valuation of $5.2 billion - n8n blog.
The migration itself is a rebuild by hand, since n8n has no Agent Builder importer, but it is a mechanical one when you work from the node table in section 6 and the canvas screenshots from section 5. Model choice is broad, with chat-model nodes for OpenAI, Anthropic, Google, Bedrock, Mistral, Groq, DeepSeek, Ollama and others (the Anthropic Chat Model node is one example), so the December 11 model decision can be made per node.
Langflow and Dify: open-source canvases you run yourself
Langflow looks the most like Agent Builder of anything in this guide: an agent component with model, instructions and tools wired to chat input and output on a node canvas. It is MIT-licensed, describes itself as supporting "all major LLMs, vector databases and a growing library of AI tools," and can turn any flow into a tool for MCP clients - Langflow on GitHub. IBM owns it through its acquisition of DataStax - DBTA, and since DataStax removed the hosted version from Astra, the practical way to run it is on your own infrastructure. Here is its starter agent flow, which a former Agent Builder user will recognize at a glance:
Dify is the more complete platform of the two, with a visual workflow canvas, agents, retrieval and MCP, and a hosted cloud alongside self-hosting. Its cloud runs from a free Sandbox tier to Professional at $590 a year per workspace and Team at $1,590 - Dify pricing. Its license is the detail to read before you commit: it is a modified Apache 2.0 that forbids using the source "to operate a multi-tenant environment" without written authorization and forbids removing the Dify logo from its console - Dify license. For an internal deployment that is no obstacle; for a product that resells agents to many customers, it is a conversation with Dify before it is a technical decision.
Make and Zapier: agents inside automation platforms
Make puts agents inside its scenarios, the branching visual automations it is known for, so an agent sits between a trigger and the tools it can call:
The current Make AI Agent was released on February 2, 2026 and is still "available in open beta, so product functionality and pricing may change" - Make Help Center. Two gaps matter for Agent Builder refugees: the Human in the Loop app is limited to the Enterprise plan and "currently in closed beta," available only to invited customers - Make, Human in the Loop, and this guide found no embeddable chat widget. Make's own August guide prices it "from $12 a month for Core, $21 for Pro, and $38 for Teams at the 10,000-credit tier," with a free plan of 1,000 credits - Make blog. It is a strong fit for event-driven automations and a weak one for customer-facing chat.
Zapier is the right answer when the agent's real job is to act across many business apps. Its AI by Zapier step lets you pick a model tier (Standard at 1x, Advanced at 3x and Premium at 5x task cost, Premium being the default) or bring your own API key at 1x - Zapier Help Center, AI model tiers. Any tool can be set to "Require approval before running" so the run pauses for a person - Zapier Help Center, AI by Zapier. The Professional plan starts from $19.99 a month billed yearly, and Zapier MCP is available on every account, with each MCP tool call using two tasks - Zapier pricing. What Zapier does not offer is any way to self-host or export your automations as code, which is why it scores lowest on exit among the integration platforms.
Relevance AI, Gumloop and Lindy: agent platforms moving away from canvases
Three popular "build an agent without code" products show where the no-code market is going. Relevance AI still has a visual canvas, its Workforce view for teams of agents with conditions and approvals - Relevance AI docs. It has, however, retired its free plan for new and existing accounts, and its self-serve Pro plan starts at $19 a month billed annually for 2,500 actions - Relevance AI pricing docs. Gumloop raised a $50 million Series B in March - Gumloop blog. It now configures agents through a panel of model, connectors, skills and subagents rather than a canvas, and its $37-a-month Pro plan carries an 8% orchestration fee - Gumloop pricing. Lindy has gone furthest: it presents an "AI employee" you message in chat, Slack or email, priced at $29.99 per active user a month for 3,000 credits - Lindy pricing, with no canvas at all. All three can be good products for their audience. None of them is a place to rebuild a deterministic Agent Builder graph.
Copilot Studio and Gemini Enterprise: the suite builders
For companies that live inside Microsoft 365 or Google Workspace, the suite builders are the equivalent of Workspace Agents for the other two ecosystems. Microsoft Copilot Studio has a visual canvas, supports OpenAI and Anthropic models and lets makers add "external AI models from Anthropic, xAI, or Mistral" - Microsoft Learn, choose an agent model. It bills in Copilot Credits, and an agent action costs 5 of them - Microsoft Learn, Copilot Studio billing. On pay-as-you-go, a credit costs $0.01 - Microsoft Learn, pay-as-you-go meters, so each agent action is five cents. Its strongest card is governance, and Ignite this week sharpened it: connected agents from other platforms, including Anthropic's Claude Managed Agents, Amazon AgentCore and OpenAI, "now automatically receive a Microsoft Entra Agent ID," with support completing in December - Microsoft Tech Community, Agent 365 at Ignite 2026. Microsoft also announced that makers can now build and edit Copilot Studio agents "locally with artifacts backed by GitHub repositories" - Microsoft Copilot blog, which addresses the exit problem this guide keeps raising.
On Google's side, Workflow Builder in Gemini Enterprise is "an interactive no-code, low-code platform for creating, managing, and turning on chat agents and workflows" - Google Cloud, Workflow Builder. Gemini Enterprise's Business edition starts at $21 per seat per month - Google Cloud, Gemini Enterprise Business. For both, the deciding factor is rarely the builder; it is which suite your team's identity, documents and email already live in.
10. Code Frameworks: When the Export Becomes Your Codebase
Once you accept that the export is code, the question becomes whether it should stay in the OpenAI Agents SDK or move to another framework. Staying is the default for good reasons: the export already runs there, the SDK is provider-agnostic, and nothing in this migration forces a rewrite. Moving makes sense in three situations: your team already runs another framework in production, you want a model lab's own harness rather than a general one, or you need something the SDK does not do well, such as a durable graph of long-running steps.
The frameworks below are the ones a team leaving Agent Builder realistically compares. Versions were read from the package registries on November 21, and they move weekly.
| Framework | Languages | Current version | License | Models | Fits a migration when |
|---|---|---|---|---|---|
| OpenAI Agents SDK | Python, TypeScript | 0.25.0 / 0.22.0 | MIT | OpenAI plus 100+ others | You want the export to run as is |
| Claude Agent SDK | Python, TypeScript | 0.2.187 / 0.3.330 | Anthropic terms | Claude only | The agent should work like Claude Code |
| Google ADK | Python, TS, Go, Java, Kotlin | 2.15.0 (Python) | Apache-2.0 | Gemini, Claude, OpenAI, local | You are on Google Cloud |
| LangGraph | Python, TypeScript | 1.2.24 | MIT | Any, via LangChain | You need durable, explicit graphs |
| Pydantic AI | Python | 2.71.0 | MIT | Dozens of providers | You want typed, testable Python |
| CrewAI | Python | 1.15.44 | MIT | Many, including local | Role-based multi-agent crews |
| Mastra | TypeScript | 1.85.0 | Apache-2.0 (core) | 40+ providers | A TypeScript team wants batteries included |
| Vercel AI SDK | TypeScript | 7.0.179 | Apache-2.0 | Provider-agnostic | The agent lives in a Next.js app |
| Microsoft Agent Framework | Python, .NET | 1.26.0 | MIT | Foundry, OpenAI, Claude, Gemini | You are a Microsoft shop |
The Claude Agent SDK is the most different of these, and the difference is worth understanding. It gives you "the same tools, agent loop, and context management that power Claude Code" as a library, with built-in file, shell and web tools, hooks, subagents, MCP, permissions and sessions - Claude Agent SDK overview. Where the OpenAI SDK is a toolkit for composing agents, the Claude SDK is a finished agent you embed and constrain. That makes it a strong home for task agents that work on files and systems, and a heavier one for a simple classifier-and-route workflow. It runs Claude models only, through Anthropic's API or the major clouds. Current releases are claude-agent-sdk 0.2.187 on PyPI and @anthropic-ai/claude-agent-sdk 0.3.330 on npm - PyPI, claude-agent-sdk.
Google's Agent Development Kit has grown into the broadest of the lab frameworks by language, with Python, JavaScript and TypeScript, Go, Java and Kotlin listed on its documentation site - Agent Development Kit. Its model list includes Gemini, Claude, OpenAI and local models through LiteLLM and Ollama, and its current Python release is 2.15.0 - PyPI, google-adk. It also has a Visual Builder, which its own docs mark as experimental, so it is not yet a like-for-like replacement for a canvas.
LangGraph is the right tool when the thing you want to keep is the graph itself. Its model is explicit nodes and edges with persisted state, which is the closest code equivalent to the deterministic Agent Builder workflow, and its current release is 1.2.24 - PyPI, langgraph. LangChain also has the closest thing to a no-code successor inside a framework vendor: what it launched as Agent Builder is now LangSmith Fleet, whose docs state that "Agent Builder is now LangSmith Fleet" and that existing agents keep working - LangSmith Fleet docs. LangSmith's Developer plan is free with 5,000 base traces a month, and Plus costs $39 per seat per month - LangChain pricing.
Pydantic AI deserves a mention for one practical reason: it publishes a migration skill named migrating-openai-agents-sdk-to-pydantic-ai, installed with uvx library-skills --all, that a coding agent can use to port Agents SDK code, which is exactly the format Agent Builder exports - Pydantic AI, migrate from other frameworks. Its current release is 2.71.0. CrewAI (1.15.44) suits workflows that were really a team of role-based specialists, and its hosted platform starts with a free tier of 50 workflow executions a month - CrewAI pricing. Mastra (1.85.0) is a full TypeScript agent framework whose cloud runs from a free tier to $25 and $250 a month - Mastra pricing. Everything under its ee/ directories, its agent builder included, sits under a separate enterprise license rather than Apache 2.0 - Mastra license. The Vercel AI SDK (7.0.179) has a ToolLoopAgent class for agent loops - AI SDK, Agents overview, which makes it the lightest option when the agent is one feature inside a Next.js product. Microsoft Agent Framework reached version 1.0 for .NET and Python as "the production-ready release" - Microsoft, Agent Framework 1.0. Microsoft describes it as "the next generation of both Semantic Kernel and AutoGen" - Microsoft Learn, Agent Framework overview.
The honest default for most teams leaving Agent Builder is still to stay in the OpenAI Agents SDK, run the export, fix the model strings, and move frameworks later only if a specific need appears. A framework migration on top of a platform migration doubles the surface for regressions in a month when the evals that would catch them are being deleted.
There is also a route that skips the framework question entirely. When what you built in Agent Builder was really the core of a product (a support agent on your own site, an intake flow, an internal tool), an AI coding agent can rebuild it as ordinary application code from the export, the canvas screenshots and the saved traces, with the agent's logic living in your repository next to everything else. Claude Code, Codex and Cursor all do this well, and we have written about the pattern in building a support agent for your site and running Claude Code unattended. Founden works at the level of a whole product: its desktop app drives Claude Code or Codex on the founder's own machine and AI plan, and keeps the company's full source as a git repository on that disk, so an agent rebuilt there is code the founder holds rather than configuration on a platform.
11. Managed Agent Runtimes: Renting the Harness Instead
Between "write it yourself in a framework" and "describe it in ChatGPT" sits the category that grew fastest this year: the managed agent runtime, where a vendor runs the agent loop, the sandbox and the session state, and you define the agent through an API. Section 3 argued that this is where the labs are now competing, and the pricing models show what that competition looks like. They are not priced per workflow or per seat. They are priced on tokens plus time.
| Runtime | Who runs it | Models | Price beyond tokens | Status |
|---|---|---|---|---|
| OpenAI Agents API | OpenAI (Codex harness) | OpenAI | Hosted containers $0.03 to $1.92 per 20 min, if used | Public beta |
| Claude Managed Agents | Anthropic, or your own infrastructure | Claude | $0.08 per session-hour while running | Beta; self-hosted by request |
| Amazon Bedrock AgentCore | AWS | Any framework, any model | Runtime from $0.0895 per vCPU-hour plus memory | Available |
| Bedrock Managed Agents | AWS, OpenAI harness | OpenAI | AWS resources used | Preview |
| Gemini Enterprise Agent Platform | Google Cloud | Gemini, Claude, 200+ | Agent Compute $0.085 per vCPU-hour | Available |
Claude Managed Agents is Anthropic's counterpart to OpenAI's Agents API: "a pre-built, configurable agent harness that runs in managed infrastructure," aimed at long-running and asynchronous work - Claude Managed Agents overview. It bills two things: tokens at normal model rates, and $0.08 per session-hour of runtime, measured to the millisecond and accrued only while the session is running, so time spent idle waiting for a message or an approval is free - Anthropic pricing. Anthropic's own worked example puts a one-hour coding session on Claude Opus 5.5 at $0.58, of which $0.08 is runtime. Since November 12 there is also a self-hosted edition in which you run the service, its database and the sandboxes, and model calls can go to Anthropic or to Bedrock, Google Cloud, Microsoft Foundry or your own gateway, with access through your Anthropic account team - Anthropic, Self-hosted Claude Managed Agents. For a team that wants a managed harness but cannot let session history leave its own infrastructure, that is currently a rare combination.
Amazon Bedrock AgentCore takes the opposite stance from the lab runtimes: it runs whatever framework you bring. AWS names "LangChain, OpenAI Agents SDK, Claude Agent SDK, Strands SDK" as examples under the headline "any framework, any model" - AWS, Amazon Bedrock AgentCore. That makes it a natural host for an exported Agents SDK workflow that you want to run on AWS without rewriting it. Its pricing is granular: Runtime at $0.0895 per vCPU-hour and $0.00945 per GB-hour on its first-generation microVMs, Gateway at $0.005 per 1,000 tool invocations, and memory and identity priced separately - AWS, AgentCore pricing. AWS re:Invent runs from November 30 to December 4 in Las Vegas - AWS re:Invent, which means the AgentCore picture may change within days of this guide; check its announcements before committing.
Google has renamed its platform as well as extending it. Vertex AI is now the Gemini Enterprise Agent Platform, with Google stating that "all Vertex AI services and roadmap evolutions will be delivered exclusively through the Agent Platform" - Google Cloud blog. Its runtime bills Agent Compute at $0.085 per vCPU-hour and Agent Memory at $0.009 per GiB-hour, and idle time between turns is not billed - Google Cloud, Agent Platform pricing.
How should a team choose among these? The structural question is where the agent's long-lived state should live, because that is what is hard to move later. A runtime that holds your sessions, memory stores and scheduled automations is doing real work for you, and the price of that work is that leaving means migrating state, not just code. The lab runtimes (OpenAI's and Anthropic's) give the strongest harness for their own models; the cloud runtimes (AgentCore, Google's Agent Platform) give more freedom over framework and model and fit wherever your data already lives. Our guides to giving an agent its own identity and to letting an agent spend money safely cover two of the controls that matter most once an agent runs unattended on any of them.
12. Replacing OpenAI Evals and Prompt Objects
The Evals platform and prompt objects close on the same day as the canvas, and they deserve their own migration plan, because they are what makes the rest of the migration safe.
Evals: Promptfoo, and why OpenAI's pick is less neutral than it looks
OpenAI's recommended destination is Promptfoo, which it describes as "an open-source CLI and library for evaluating and red-teaming AI apps and agents" - OpenAI cookbook, Moving from OpenAI Evals to Promptfoo. The context matters: OpenAI announced it would acquire Promptfoo on March 9, 2026 - OpenAI, OpenAI to acquire Promptfoo. Promptfoo's own site now says it "is now part of OpenAI" and "remains open source" - Promptfoo, About. Its code is MIT-licensed - Promptfoo on GitHub. Its Community tier is free, with Enterprise and on-premise tiers priced on request - Promptfoo pricing. For agents specifically, Promptfoo ingests trace spans for trajectory assertions on Agents SDK runs - Promptfoo, Evaluate OpenAI Agents. It also has a provider for the new Agents API - Promptfoo, OpenAI Agents API provider.
None of that makes Promptfoo a bad choice; it is genuinely portable, because the eval lives in a promptfooconfig.yaml in your repository and can point at any provider. It does mean the "vendor-neutral" eval tool is now owned by one of the vendors whose models it evaluates, which is worth knowing if neutrality is why you wanted an external eval layer in the first place. The migration is manual. A developer reported in July that the export button the cookbook once mentioned was missing, and OpenAI staff replied that "not every evaluation type currently supports exporting as a Promptfoo configuration" - OpenAI Developer Community, Evals thread. That is why the dump script in section 5 matters: your datasets and grader definitions become the input to a hand-built config.
The other credible homes for agent evals are observability platforms that score traces, since an agent's quality lives in its trajectory rather than in one output. The table compares them on what a migrating team needs: whether they can evaluate whole agent traces, whether you can self-host, and what they cost to start.
| Tool | License | Agent and trace evals | Entry pricing |
|---|---|---|---|
| Promptfoo | MIT, owned by OpenAI | Yes, trajectory assertions | Free Community; Enterprise on request |
| Langfuse | MIT, owned by ClickHouse | Yes, online and offline | Free self-hosted; Core $29/month |
| Braintrust | Proprietary platform, MIT SDK | Yes, trace scorers | Free Starter; Pro $249/month |
| LangSmith | Proprietary platform, MIT SDK | Yes, trajectory evals | Free Developer; Plus $39/seat/month |
| Arize Phoenix | Elastic License 2.0 | Yes, trace evals | Free self-hosted; AX Pro $50/month |
Langfuse is a natural choice for teams that want open source and self-hosting: ClickHouse acquired it in January 2026 and said there were "no planned changes to licensing" - Langfuse blog. Its cloud starts free, with Core at $29 a month for 100,000 units - Langfuse pricing. Braintrust's Pro plan is $249 a month with 50,000 scores included - Braintrust pricing. Its trace scorers run "once on an entire trace after it completes, with access to all of its spans" - Braintrust docs, scorers. Arize's Phoenix is free to self-host, but its license is the Elastic License 2.0, which is source-available rather than open source in the strict sense - PyPI, arize-phoenix. Its managed AX Pro plan costs $50 a month - Arize pricing.
Whichever tool you choose, the shape of a good agent eval suite after this migration is the same: the inputs from your saved traces and your dumped datasets, graders rebuilt as explicit assertions, and the suite run in CI on every change to a prompt, a model string or a tool. The old Evals dashboard let a team skip that discipline. Its shutdown is a good reason to adopt it.
Prompt objects: back into the repository
For prompts, OpenAI's own advice is the cheapest option and usually the right one: inline the content, "move versioning to your repo using git commits, PR review, and tests or evals," and keep prompts in a small module of named builder functions with eval fixtures beside them - OpenAI prompt migration guide. What teams lose is the ability to edit a prompt in a dashboard and roll it out without a deploy, and that loss is real. One developer on OpenAI's forum summed it up as "What we win: Nothing... What we loose: A lot of speed," and OpenAI's support account replied in September that it hears "the loss of hosted editing and quick rollback" but has no timeline "for an equivalent hosted replacement" - OpenAI Developer Community, prompt objects thread.
If hosted editing genuinely matters to your team, prompt-management tools fill the gap. Langfuse's prompt management is included in its free and paid plans and caches prompts client-side, so a prompt service outage does not take your agent down - Langfuse prompt management. PromptLayer starts free and charges $49 a month for Pro - PromptLayer pricing. Braintrust manages prompts as "versioned Braintrust objects" you can roll out without redeploying - Braintrust docs, prompts. The trade-off is the one this whole guide keeps returning to: a hosted prompt store is faster to iterate on and is one more definition of your agent living on someone else's platform. If you choose one, pick one that syncs to git, so the repository stays the source of truth.
13. Which Model Should Run the Migrated Agent
Every exported workflow arrives with model strings in it, and section 2 showed why those cannot simply be kept. The good news is timing: the top of every lab's lineup was repriced in the same few weeks the canvas was closing, so the choice you make now is made against a fresh market. Anthropic released Claude Fable 5.2 on November 9 at $8 input and $40 output per million tokens, down from $10/$50 for Fable 5.1 - Claude release notes. OpenAI answered on November 17 with GPT-6.2 Astra for demanding reasoning and coding and GPT-6.2 Sol for "everyday coding and agent workflows" - OpenAI changelog. They cost $8/$40 and $2/$10 respectively, against $10/$50 for the earlier GPT-6 Astra - OpenAI pricing. Both GPT-6.2 models list a 1,050,000-token context window and 128,000 maximum output tokens - OpenAI, GPT-6.2 Sol model page.
For an agent, the most useful way to compare these is not a leaderboard but the cost of one realistic conversation and how strong the model is for that price. The table uses Founden's model catalog for live prices and the Artificial Analysis Intelligence Index score the catalog carries; a higher index means stronger on that index, not best at every task.
| Model | Input $/M | Output $/M | Intelligence Index | Where it fits a migrated agent |
|---|---|---|---|---|
| Claude Fable 5.2 | $8 | $40 | 64.6 | The hardest long-horizon task agents |
| GPT-6.2 Astra | $8 | $40 | 62.1 | Hard reasoning steps on the OpenAI stack |
| Gemini 4 Neon | $3 | $15 | 61.4 | Near-frontier strength at mid-tier price |
| GPT-6.2 Sol | $2 | $10 | 57.3 | The default specialist on the OpenAI stack |
| Claude Sonnet 5.5 | $2 | $10 | 54.5 | The default specialist on the Claude stack |
| Gemini 4 Hydrogen | $1.50 | $7.50 | 53.9 | Specialists where cost matters |
| GPT-6.1 Terra | $1 | $5 | 51.3 | OpenAI's named replacement for gpt-5-mini |
| Claude Haiku 5.5 | $0.10 | $0.50 | 36.5 | Classifiers, screeners, routers |
| GPT-6 Luna | $0.10 | $0.50 | 27.9 | The cheapest OpenAI classifier |
To turn those rates into a budget, take a typical Agent Builder support workflow of the kind section 6 rebuilt: an input screen, a classifier and a specialist that makes one tool call, adding up to roughly 12,000 input tokens and 1,500 output tokens per conversation. That is an assumption for illustration, not a measurement of your workflow, so substitute your own figures from the traces you saved in section 5. At 10,000 conversations a month with no caching, the monthly model bill comes out as follows, with the two models being retired on December 11 included for reference:
Two things stand out. First, a team that ran this workflow on gpt-5-mini and accepts OpenAI's named replacement pays about three times as much for the same token volume, $195 instead of $60, while a team that moves the cheap steps to Claude Haiku 5.5 or GPT-6 Luna pays a third of what it paid before. Second, the gap between the frontier and the mid-tier is four times, so the most valuable design decision is not which lab to pick but which steps deserve the expensive model. A screener and a classifier rarely need frontier reasoning; a specialist that negotiates a refund policy might. Mixing tiers inside one workflow is exactly what the Agents SDK makes easy, since every Agent carries its own model, and our guide to cutting agent costs with model routing works through that pattern in depth.
Caching changes the picture again, because an agent sends the same instructions and tool definitions on every call. OpenAI prices cached input for GPT-6.2 Sol at $0.10 per million tokens against $2 uncached - OpenAI pricing. Anthropic prices cache hits on Sonnet 5.5 at $0.10 and on Fable 5.2 at $0.20, which it describes as 0.05x and 0.025x of base input - Anthropic pricing. For a workflow whose fixed prefix is most of its input, caching can cut the input bill by an order of magnitude, which our prompt caching guide covers. For automations that do not need an answer within seconds, OpenAI also added two-hour and eight-hour background completion windows on November 17, at 30% and 40% below standard rates - OpenAI changelog.
The last lever is who pays at all. For a customer-facing agent, Anthropic put linked billing into beta on November 17: a customer links their own Claude organization, your requests set a billing_policy to choose who pays, and the customer can set a spend cap for your app - Claude release notes. OpenAI's closest equivalent, ChatGPT plan usage inside Sign in with ChatGPT, is documented for open-source and locally hosted apps, with an interest form for paid or remotely hosted ones - OpenAI, ChatGPT plan usage. Both are covered in our guides to Claude linked billing and Sign in with ChatGPT, and both are worth a look for an agent whose usage grows with your users. For a fuller model comparison than this section has room for, see Claude Sonnet 5.5 vs GPT-6.1 Sol and Fable 5.2 vs Gemini 4 Carbon.
14. How Agent Builder Migrations Fail
Migrations off a visual builder rarely fail because the new tool cannot do the job. They fail because the canvas was doing things nobody wrote down, and the export carries the visible parts while dropping the invisible ones. The failure modes below are the ones that follow directly from how Agent Builder worked, and each comes with the check that catches it.
The guardrail that quietly disappears. A Guardrails node on the canvas was a visible box in the flow. In code, an input guardrail is one line in an agent's configuration, and a hand-rewritten agent that omits it still works perfectly on every normal input. Nothing fails loudly; the agent simply becomes easier to jailbreak. The check is to keep the abusive and PII-laden inputs from your saved traces in the test suite, so the guardrail is tested rather than assumed.
Branches that become suggestions. Section 4 covered OpenAI's warning that deterministic workflows may not migrate faithfully to a workspace agent - OpenAI, Migrate from Agent Builder. The same thing happens in code when a developer replaces an If/else on a typed label with a handoff and lets the model choose. It works in the demo and fails on the case the branch existed for. The check: every branch that existed for money, compliance or safety reasons should still be an if statement after the migration.
The forgotten chat widget. A ChatKit embed looks like front-end code, so it is easy to assume it has nothing to do with Agent Builder. If its session request names a wf_ workflow, it runs on the hosted path that OpenAI only documents for the transition window - OpenAI ChatKit guide. Search your servers for chatkit/sessions and wf_ today.
The inherited model string. The export inherits model strings, and the safety guide's recommended gpt-5 and gpt-5-mini stop answering on December 11. Search the exported code for gpt-5 and o3 before you deploy it, and choose replacements with the cost picture from section 13 in front of you.
No baseline to compare against. With the Evals platform read-only and then gone, a team that did not export its datasets and baselines has no way to show that the new agent is as good as the old one. That is how a regression ships: the new system "seems fine" in a few manual tests. The check is the eval dump from section 5 plus a rebuilt regression suite (section 12) that runs before the cut-over, not after.
The approval that times out. On the canvas, a Human approval node could wait while a person decided. In code, the run returns an interruption and a resumable state - OpenAI, Guardrails and human review. If that state lives only in the memory of a serverless function that times out after a minute, every approval that takes longer is lost. Persist the serialized state in a database and resume from it when the decision arrives.
Connectors on someone else's account. MCP connections in Agent Builder were authorized inside OpenAI's platform. After the move, every one has to be re-authorized in the new runtime, often by a person with the right account. Inventory them before the shutdown, with the account each one used, so the re-authorization is a checklist rather than an archaeology project.
User text in system prompts. Inlining prompts is where a subtle security regression creeps in. Agent Builder's safety guide warned against putting untrusted variables in developer messages, because developer messages take precedence and give an attacker "the highest degree of control" - OpenAI, Safety in building agents. A prompt object with a {customer_issue} variable often gets inlined as an f-string into the system prompt. Keep user-supplied values in the user message, as OpenAI's own prompt migration example does.
The cost shape that changes. A canvas workflow billed model tokens and tool calls. A managed runtime can add metered time: OpenAI's hosted containers cost from $0.03 to $1.92 per 20-minute session depending on memory - OpenAI pricing. Claude Managed Agents adds $0.08 per session-hour of running time - Anthropic pricing. Neither is large per run, but both scale with usage in a way a workflow that used to cost only tokens did not, so put them in the budget before the first invoice does it for you.
15. The Migration, in the Order Things Break
The safest way to run this migration is in the order the deadlines fall, not in the order that is most interesting to build. Each step below ends with something that keeps working after its deadline.
Before November 30: keep production running. First, find every production path that depends on a hosted workflow: ChatKit servers that send a wf_ ID, and any backend that calls a published workflow. Those, together with any call that still passes a pmpt_ prompt ID, are what go dark on the 30th, so they come first. Export every workflow in both languages and commit the code, dump the evals with the script in section 5, copy every prompt object into version-controlled files and replace the pmpt_ calls, and save a few dozen real traces per workflow. Then stand up the replacement for each hosted path, even if it is a straight lift of the exported SDK code behind a self-hosted ChatKit server, because a faithful lift that works on December 1 beats an elegant rebuild that is half finished.
Before December 11: repoint the models. Search the exported code and your own services for gpt-5, gpt-5-mini, gpt-5-nano and o3, and choose each replacement deliberately with the cost figures from section 13. Run the saved traces and the dumped eval inputs through the new model choices and compare against the old baselines before switching traffic, which is also what OpenAI's own migration guidance says: run representative requests against both models and compare outputs, latency and cost - OpenAI deprecations.
After the deadlines: build the version you want. With nothing about to break, rebuild the evals as a suite that runs in CI (section 12), decide whether each agent's long-term home is code, a visual tool, a workspace agent or a managed runtime (sections 7 to 11), and harden the parts the lift carried over loosely: durable approval state, re-authorized connectors, and a per-agent model choice that matches the step's difficulty. This is also the point to ask the larger question that the shutdown raises, which the last section takes up: how much of your agent's definition should live on someone else's platform at all.
16. Where Agent Building Goes Next
The Agent Builder shutdown is a small event with a large signal, and the signal is about where value sits in the agent stack. A year ago the visible product was the canvas, the thing a person used to describe an agent. Today the labs are competing on the runtime underneath it, and the evidence is in what each of them shipped this autumn. OpenAI put a managed Codex harness behind an API, then added scheduled automations, automatic review of tool calls and computer use in an OpenAI-hosted browser - OpenAI changelog. Anthropic's Managed Agents gained session budgets, dynamic workflows that run many agents in phases, and, on November 12, a self-hosted edition in which "you run the whole Managed Agents service" on your own infrastructure and send model requests "to the provider that you choose" - Claude release notes. And OpenAI's own harness now runs inside AWS as Amazon Bedrock Managed Agents, "powered by OpenAI," with AgentCore Runtime or self-hosted compute running the commands and tools - OpenAI, Bedrock Managed Agents.
Three consequences follow from that, and each one is useful when choosing where to move.
Portable definitions, rented runtimes. The definition of an agent is becoming portable, and the runtime is becoming the product. Prompts in files, tools exposed over MCP, skills as folders of instructions, evals as config in a repository: every one of those travels between runtimes with little or no change, and every lab now supports them. The lock-in that remains lives in sessions, sandboxes, memory stores and the state of long-running work. A team that keeps its agent's definition in its own repository can move runtimes in days; a team whose agent exists only as configuration inside a hosted product is exactly where Agent Builder users found themselves in June. If there is one structural lesson from this shutdown, it is to keep the definition on your side of the line, whatever runtime you rent. Our guide to one AGENTS.md for Claude Code, Codex and Cursor and to shipping an MCP server for your product cover two of the portable layers in more depth.
Canvases follow the connectors. Visual building is not dying; it is moving to where triggers and connectors live. The canvas that is closing was a general-purpose agent canvas attached to a model vendor. The canvases that are thriving are attached to something else that is hard to replicate: hundreds of connectors and a trigger system (n8n, Make, Zapier), or a company's own documents and seats (Copilot Studio, Gemini Enterprise, workspace agents). For those, drawing the flow is not the product; it is the interface to an integration catalog. That is a more durable reason for a canvas to exist, and it is why the visual alternatives in section 9 are not simply waiting to suffer Agent Builder's fate.
Migrations now cost evidence. The cost of a migration is now mostly about evidence, not code. Rewriting an exported workflow into another framework takes hours with a capable coding agent. What takes longer is proving that the new version behaves at least as well as the old one, which needs the datasets, traces and baselines that this shutdown deletes from OpenAI's dashboard. The teams that will move fastest the next time a vendor retires something are the ones that treat their eval suite as the real asset, run it in their own CI, and can point it at any model and any runtime. That is a cheap habit to start this week, and it is the one most migration plans skip.
Pressure-testing that view is worth a paragraph, because "own your definitions, rent the runtime" can be taken too far. For many teams, especially small ones, renting more of the stack is the right call: a managed harness that compacts context, recovers from failures and runs sandboxes safely is genuinely hard to build, and building it yourself to avoid a hypothetical future migration is a poor trade. The point is not to self-host everything. It is to know which of your dependencies would hurt to lose, and to keep the cheap-to-own ones in your own hands so that the expensive ones are a choice rather than a trap.
For a team leaving Agent Builder this month, that translates into a short list. Export everything while the canvas opens. Move the hosted paths first, because they are the only ones that go dark on November 30. Choose models deliberately before December 11 rather than inheriting a canvas default. Put prompts, tool definitions and evals in your repository. And pick the next home for each agent by the shape of what it does, not by which vendor's logo is most familiar, because the shape of your agent is the one thing the next deprecation notice cannot change.
What this article rests on
Every model figure linked above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.
- GPT-5.4 Mini (OpenAI): $0.75 in and $4.50 out per million tokens, cached input $0.075, a 400K token window, listed 17 March 2026.
- Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.
- GPT-6.2 Astra (OpenAI): $8 in and $40 out per million tokens, cached input $0.40, a 1.05M token window, listed 17 November 2026.
- Gemini 4 Neon (Google): $3 in and $15 out per million tokens, cached input $0.15, a 1M token window, listed 18 November 2026.
- GPT-6.2 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 17 November 2026.
- Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
- Gemini 4 Hydrogen (Google): $1.50 in and $7.50 out per million tokens, cached input $0.075, a 1M token window, listed 12 November 2026.
- GPT-6.1 Terra (OpenAI): $1 in and $5 out per million tokens, cached input $0.05, a 1.05M token window, listed 26 October 2026.
- Claude Haiku 5.5 (Anthropic): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1M token window, listed 7 October 2026.
- GPT-6 Luna (OpenAI): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1.05M token window, listed 22 September 2026.
In this topic: AI agents
- Claude Browser Use: Automate Web Tasks With the SDK (2026)
- Orchestrate Multiple AI Agents: 2026 Playbook
- AI Agent Corporate Cards: Spend Money Safely 2026
- AI Agent Identity, Not an API Key: 2026 Guide
- Run Claude Code Unattended: Auto Mode 2026
- Build a Support Agent for Your Site 2026
- Hire an AI Workforce to Run Your Company 2026
- Automate Your Startup Back Office With AI (2026)