Open source · camelRun by camelAICompare · Open source · camelRun by camelAI
LangGraph Platform alternative
Your graph becomes one AI agent
For agents on LangSmith Deployment, formerly LangGraph Platform.
camelRun by camelAI is an open source, hosted runtime for AI agents.
Read the LangGraph migration guideLangGraph to camelRun
LangGraph concepts in camelRun
Threads, checkpoints, interrupts and workers move into camelRun. Pick a LangGraph concept to see where it lands.
create_react_agentin camelRun:agent
create_react_agent
One upsert makes the agent, with its model, tools and instructions.
The port
Port a LangGraph agent to camelRun
A LangGraph agent made with create_react_agent is a model, tools and a prompt. In camelRun it is one upsert under a key, and the runtime runs the tool loop.
- Your tools stay in your code. camelRun calls them in your process.
- Key each agent by its thread.
agents.upsert(`thread-${threadId}`, config) - An interrupt becomes an approval. Like book_trip, a tool with
needsApprovalstops the run before each call, and the agent sleeps until a person answers.
import { mkdir, readdir, rm, writeFile } from "node:fs/ promises";
import { basename } from "node:path";
import { createInterface } from "node:readline/ promises";
import { Agents, schema, tool } from "@camelai/run";
// A throwaway folder for the agent to tidy.
const dir = "playground";
await mkdir( dir, { recursive: true });
for ( const f of ["notes.md", "build.log", "cache.tmp", "old-draft.tmp"]) await writeFile( `${dir}/${f}`, "x");
const agents = new Agents( );
const agent = await agents .upsert( "approval-ts", {
model: "openrouter/ openai/ gpt-6-luna",
instructions: "You tidy the user's playground folder with your tools.",
tools: {
list_files: tool( {
description: "List the files in the playground",
input: schema .Object( {}),
execute: ( ) => readdir( dir),
}),
delete_file: tool( {
description: "Delete a file from the playground",
input: schema .Object( { name: schema .String( ) }),
needsApproval: true, // the run stops and waits for a person before each call
execute: async ( { name }) => ( await rm( `${dir}/ ${basename( name)}`), { deleted: name }),
}),
},
});
const cli = createInterface( { input: process .stdin, output: process .stdout });
let run = await agent .run( process .argv .slice( 2) .join( " ") || "Delete the temporary files.", { user: "me" });
while ( run .status === "input_required") {
const input = run .inputs[0];
const yes = ( await cli .question( `${input .message} ${input .detail .argumentsPreview ?? JSON .stringify( input .detail .arguments)} [y/N] `)) .trim( ) === "y";
run = await input .answer( yes, { from: "me" });
}
console .log( run .text, "\nleft:", await readdir( dir));
cli .close( );
await agents .close( );npm install
export CAMELAI_ API_ KEY= art_ ...
npm startAllow delete_file to run? {"name":"cache.tmp"} [y/N] y
Allow delete_file to run? {"name":"old-draft.tmp"} [y/N] n
Deleted `cache.tmp`. I couldn't delete `old-draft.tmp` because that deletion was declined.
left: [ 'build.log', 'notes.md', 'old-draft.tmp' ]Tracing
Keep LangSmith for your agent traces
camelRun sends every run to LangSmith as an OpenTelemetry trace, with sub-agents under the call that started them. Choose the LangSmith preset in the console and add your API key. Prompts and replies stay out of your traces unless you turn content on.
Read about trace exportSet up export
- invoke_agent Trip plannerserver
- chat claude-sonnet-5-5client
- execute_tool delegateinternal
- invoke_agent flightsserver
- execute_tool delegateinternal
- invoke_agent hotelsserver
- chat claude-sonnet-5-5client
- execute_tool book_tripinput_requiredinternal
- await_human_inputinternal
- invoke_agent Trip plannerserver
- execute_tool book_tripinternal
- chat claude-sonnet-5-5client
Pricing
Pay for AI agent time, not deployment uptime
camelRun meters an agent only while it is in a run. Between messages it sleeps, and idle and sleeping agents cost only storage.
Your LangSmith deployment
Uptime counted while its database is live, for all its threads
camelRun: one agent per thread
Each metered while it is in a run
LangSmith Deployment's Plus plan is $39 per seat a month and includes one small Serverless deployment. More deployments are billed for the vCPU and memory their runtime and database use.
LangChain's pricing page, read October 23, 2026camelRun is $0.01 per agent-hour while an agent is in a run, and $0.10 per GB-month of storage, with $0 for tokens on your own provider keys. It's prepaid, with no subscription, no seats and no per-agent fee.
Choosing
Should you move off LangSmith Deployment?
Stay on LangSmith Deployment if
- You want to deploy your LangGraph code as it is, graph and all.
- Your team builds and debugs in LangSmith Studio.
- You want LangChain to run your agent servers, or its Enterprise plan to self-host them.
Move to camelRun if
- You'd rather describe the agent than build its graph.
- Each user or thread should be its own agent that sleeps between messages.
- You want Slack, Discord, Telegram and GitHub built in, on Claude, GPT, Gemini and more.
Open source under the AGPL. Self-host it with one container and Postgres, or export everything as one zip.
FAQ
LangGraph Platform alternative FAQ
What replaced LangGraph Platform?
LangChain renamed LangGraph Platform to LangSmith Deployment in October 2025. For an alternative, camelRun by camelAI is a hosted, open source runtime where each thread becomes an AI agent with its own key.
How do I move a LangGraph agent to camelRun?
Create each agent with
upsert, keyed by your thread id, with your graph's model, tools and instructions. Interrupts become approvals or asks in your tools, and a supervisor becomes a lead agent with sub-agents.What happens to my checkpointer and threads?
Each thread becomes an agent keyed by its thread id, and camelRun keeps its history, files and pending work, so there's no checkpointer to run. To carry on a LangGraph conversation, create its agent with the earlier messages.
How do interrupts and approvals work in camelRun?
Mark a tool
needs_approval, or have it callcontext.confirmorcontext.ask. The run endsinput_requiredand the agent sleeps, with nothing billed while it waits. Answer days later from any process, and the turn picks up where it stopped.Is there an open source LangGraph Platform alternative?
Yes. camelRun by camelAI is open source: the runtime is AGPL and runs anywhere with Docker as one container and Postgres, and the SDKs are MIT. Export everything as one zip, any time.
One AI agent per LangGraph thread
Bring your prompt and your tools. camelRun runs the loop, keeps each agent's history, and picks the turn back up when a person answers.
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.