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.

Yours or asleepcamelRun's or running

camelRun by camelAI is an open source, hosted runtime for AI agents.

Read the LangGraph migration guide

LangGraph to camelRun

LangGraph concepts in camelRun

Threads, checkpoints, interrupts and workers move into camelRun. Pick a LangGraph concept to see where it lands.

LangGraphcamelRun
agent
key
history
human input
sub-agents
tools · your code
files
fork
traces
Migration guide01 / 12

create_react_agentin camelRun:agent

LangGraph

create_react_agent

In camelRunagent

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 needsApproval stops the run before each call, and the agent sleeps until a person answers.
Read about human input
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 start
Allow 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 export
run.camelai.com/console/telemetry
Console

Set up export

PresetLangSmith
Endpointhttps://api.smith.langchain.com/otel/v1/traces
Start exporting
Trace · thread-9f2c
OTLP/HTTP
  1. invoke_agent Trip plannerserver
  2. chat claude-sonnet-5-5client
  3. execute_tool delegateinternal
  4. invoke_agent flightsserver
  5. execute_tool delegateinternal
  6. invoke_agent hotelsserver
  7. chat claude-sonnet-5-5client
  8. execute_tool book_tripinput_requiredinternal
  9. await_human_inputinternal
  10. invoke_agent Trip plannerserver
  11. execute_tool book_tripinternal
  12. 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.

One day00:00 to 24:00

Your LangSmith deployment

Uptime counted while its database is live, for all its threads

Uptime counted all day: the deployment's database is live around the clock.

camelRun: one agent per thread

Each metered while it is in a run

thread-9f2c
waiting · approvalthread-9f2c: asleep most of the day, with short runs, and asleep through the afternoon while book_trip waits for an approval.
thread-41ab
thread-41ab: asleep most of the day, with short runs.
thread-c07e
thread-c07e: asleep most of the day, with short runs.
00:0003:0006:0009:0012:0015:0018:0021:0024:00
LangSmith Deployment

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, 2026
camelRun

camelRun 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

  1. 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.

  2. 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.

  3. 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.

  4. How do interrupts and approvals work in camelRun?

    Mark a tool needs_approval, or have it call context.confirm or context.ask. The run ends input_required and the agent sleeps, with nothing billed while it waits. Answer days later from any process, and the turn picks up where it stopped.

  5. 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.

Read the full migration guide
Keep reading

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.

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.