Compare · camelRun by camelAI

Agent Builder shuts down Nov 30November 30. Move your agents

OpenAI Agents API alternative

Keep your agent. Choose your model.

camelRun by camelAI runs your agent's loop and keeps its history and files under a key you pick. Keep OpenAI's models on your own OpenAI key, or pick Claude, Gemini, an open model or your own model server. Your tools stay in your code.

Get an API key
Read the quickstartPrepaid, no subscription

One agent, user-123, with its instructions, tools, history and files, and its model beside it. Its history starts with an imported OpenAI chat, and each line is stamped with the model that wrote it: OpenAI's gpt-6-sol, then Claude, Gemini or a model server of your own.

Model
const agent = await agents.upsert("user-123", { model, instructions, tools });
Agentuser-123

The Agents API and camelRun, set up side by side

Both run the agent loop for you. On camelRun the agent is named by your own key, so the runtime keeps track of it and your app doesn't have to.

  1. quickstart.py
    agent = await agents.upsert("quickstart", instructions="You are a concise assistant.", tools=[weather])
  5. Also in this code
Steps from OpenAI's quickstartPorting guide
quickstart.py
import asyncio
from camelai_run import Agents, tool

@tool
def weather(city: str) -> dict:
    """Today's weather in a city"""
    return {"city": city, "forecast": "sunny", "highC": 24}

async def main():
    async with Agents() as agents:  # reads CAMELAI_API_KEY
        agent = await agents.upsert("quickstart", instructions="You are a concise assistant.", tools=[weather])
        run = await agent.run("Should I bring an umbrella in Lisbon today?")
        print(run.text)

asyncio.run(main())

Your OpenAI key

Bring your OpenAI key and keep OpenAI's models

Add your key on the console's Models & keys page. camelRun checks it with OpenAI, stores it encrypted, never shows it again and never gives it to the model. Your agents call OpenAI's models with it.

Want Claude or Gemini for some agents? Add that provider's key, or use camelAI's keys from your credit at the provider's price, with no markup on tokens. One account can mix them.

Models and keys in the docs
run.camelai.com/console/models
Console

The camelRun console's Models & keys page. Adding an OpenAI key: The key is checked with openai, then stored encrypted. It is never shown again; your agents use it for openai models and usage bills to it.

Name a model per agent
Shell
npx -y @camelai/camelrun models --available
Python
agent = await agents.upsert("support-triage", model="anthropic/claude-sonnet-5-5", instructions="...")

At a glance

OpenAI Agents API vs camelRun

The Agents API side is from OpenAI's docs, checked October 21, 2026. It's in beta, so check there for the latest.

OpenAI's Agents API docs
OpenAI Agents API compared with camelRun
QuestionOpenAI Agents APIcamelRun
ModelsOpenAI's models.OpenAI's, Anthropic's, Google's, open models, or a model server of your own.
FilesIn the session's sandbox while it exists. Files in /workspace/outputs are kept as artifacts.Kept with the agent until you delete it.
Slack and other chatsYour Slack app maps each thread to a session and posts the answers back.Slack, Telegram, Discord and GitHub reach the agent directly, one agent per conversation.
Where it runsOpenAI's service. The sandbox can be your own.run.camelai.com, or your own servers: the whole runtime is open source.Source on GitHub

Coming from the OpenAI Agents SDK

Your instructions and tool functions carry over. The runner and the session store become one call and a key.

The full porting guide
The same agent, ported
migrating.md
from camelai_run import Agents, tool

@tool
def lookup_order(order_id: str) -> dict:
    """Look up an order by id."""
    return orders.get(order_id)

async with Agents() as agents:  # reads CAMELAI_API_KEY
    agent = await agents.upsert("user-123", instructions="You help with orders.", tools=[lookup_order])
    run = await agent.run("Where is order 42?")
    print(run.text)
In your codecamelRun's
Agent(name, instructions, tools, model)
camelRun's: agents.upsert(key, …)
Models are provider/model ids from the catalog.
Runner.run(agent, input)
camelRun's: agent.run(text)
run.text is the answer.
Runner.run_streamed
camelRun's: agent.stream(text)
Text, tool calls and results as they happen.
@function_tool
In your code: @toolTypeScript: tool({ input, execute })
Arguments are checked against the schema first.
Sessions (SQLiteSession, Redis)
camelRun's: the agent's key
History is durable, and compacted when it gets long.
needs_approval
In your code: @tool(needs_approval=True)TypeScript: needsApproval: true
Answer from any process, days later if need be.

Import your OpenAI conversation history

Create the agent with its old history, in OpenAI's Chat Completions or Responses format, tool calls included, and name the model that wrote it. It picks up where the conversation left off.

Import an OpenAI conversation
await agents.upsert(`thread-${thread.id}`, { importMessages: { format: "openai-chat", messages: thread.messages, model: "openai/gpt-6-sol" } });

OpenAI Agent Builder alternative · shuts down November 30

A new home for Agent Builder agents

OpenAI shuts down Agent Builder on November 30, 2026. camelRun is an Agent Builder alternative that keeps your agent running. Here's how to move it.

OpenAI announced the deprecation on June 3, 2026, and Agent Builder shuts down on November 30, 2026.

Move an Agent Builder agent before November 30

  1. Export the workflowIn Agent Builder, open the workflow, choose Code, then Agents SDK, then TypeScript or Python, and copy the export.OpenAI's export steps
  2. Port it to camelRunThe export is Agents SDK code, so the map above applies. Your instructions and tool functions carry over, and the key takes the session's place.The porting map
  3. Set it up in the console with no codeIn the console, a definition holds the model, the prompt, built-in tools like web search, and MCP servers. Slack, Telegram and Discord channels answer with it.Open the console

Your agents stay yours: export them as one zip any time, or run the open-source runtime yourself.

How export worksThe full migration guide

FAQ

Questions about moving from the Agents API

  1. Is there an OpenAI Agents API alternative that works with any model?

    Yes. camelRun by camelAI is a hosted runtime for AI agents that runs the agent loop for you, like the Agents API, on the model you pick: OpenAI's, Anthropic's, Google's, open models, or a model server of your own. You can change an agent's model between runs, and its history carries over.

  2. Can I bring my OpenAI key?

    Yes. Add it on the console's Models & keys page. camelRun checks it with OpenAI, stores it encrypted, never shows it again and never gives it to the model. Your agents then call OpenAI's models with it, and camelRun charges nothing for those tokens.

  3. What replaces OpenAI Agent Builder after the shutdown?

    OpenAI set November 30, 2026 as Agent Builder's shutdown date, and points its users to the Agents SDK or ChatGPT workspace agents. camelRun is another home: port the workflow's Agents SDK export, or set the agent up in the camelRun console with no code when its tools are built in or come from MCP servers or OpenAPI specs.

  4. Where does agent state live on camelRun?

    In camelRun, under a key you choose. Each agent keeps its history, its files and any pending work until you delete it, and deleting it purges them. Self-host the runtime and it all stays on your own servers.

  5. How is camelRun priced?

    camelRun is prepaid. You pay $0.01 for each hour an agent spends in a run, and $0.10 per GB-month of storage. Tokens cost nothing extra on your own provider keys, and the provider's price with no markup on ours. Idle and sleeping agents cost only storage. There's no subscription, no seats and no per-agent fee.

  6. Can I bring my existing conversations over?

    Yes. Create the agent with importMessages and the history comes in as it is, in OpenAI's Responses or Chat Completions format, tool calls included. The agent picks up the conversation where it left off.

  7. Which should I choose, the Agents API or camelRun?

    Choose camelRun when you want to pick the model for each agent, name agents by your own keys, reach them from Slack, Telegram, Discord or GitHub, or keep the option to self-host. If your team is set on OpenAI's models and wants OpenAI to host the sandbox, the Agents API is built for that.

  8. Can I take my agents with me if I leave camelRun?

    Yes. Export every agent, with its full history and files, as one zip from the console's Account page, any time. The runtime is open source, so you can also run it on your own servers with one container and Postgres.

Keep reading

camelRun by camelAI

Bring your agent over

Sign in with GitHub or Google, create an API key, and run your agent on the model you choose.

Get an API key Read the quickstart

Prepaid, with no subscription and no seats.

Set up with your coding agent

Read https://run.camelai.com/SKILL.md and set up camelRun in this project. Ask me what the agent should do.

Paste into Claude Code, Codex, Cursor or any coding agent. It asks what your agent should do, then builds it.