One socket.
Every agent provider.
OpenAct is the switchboard for managed agents. Call one API and send work to OpenAI, Anthropic, Google, Amazon Bedrock, Mistral, or your own open-source runtime, with automatic failover, a sandbox on every run, and one invoice, whichever provider ends up doing the work.
# one endpoint, any provider curl https://api.openact.dev/v1/agents/run \ -H "Authorization: Bearer $OPENACT_KEY" \ -d '{ "agent": "auto", "task": "Refund order #4471 and email the customer", "tools": ["stripe", "gmail"], "sandbox": true }' // 200 — routed automatically { "run_id": "run_8f2a1c3d", "provider": "anthropic/claude-agent", "status": "completed", "steps": 6, "cost_usd": 0.042 }
// one endpoint, any provider import { OpenAct } from "openact"; const client = new OpenAct({ apiKey: process.env.OPENACT_KEY }); const run = await client.agents.run({ agent: "auto", task: "Refund order #4471 and email the customer", tools: ["stripe", "gmail"], sandbox: true, }); // run.provider -> "anthropic/claude-agent" (chosen for you) console.log(run.status, run.cost_usd);
# one endpoint, any provider from openact import OpenAct client = OpenAct(api_key=os.environ["OPENACT_KEY"]) run = client.agents.run( agent="auto", task="Refund order #4471 and email the customer", tools=["stripe", "gmail"], sandbox=True, ) # run.provider -> "anthropic/claude-agent" (chosen for you) print(run.status, run.cost_usd)
Route it. Sandbox it. Watch it.
Every provider talks a different protocol for tools, memory, and execution. OpenAct sits in front of all of them so your product only has to speak one.
Send a task, not a vendor
Route by cost, latency, or capability. If a provider throttles, errors, or degrades mid-run, OpenAct fails over to the next capable agent in the same session. No restart, no lost context.
Every run gets its own machine
Each session boots an isolated cloud sandbox (filesystem, headless browser, code execution, controlled network egress) regardless of which provider is doing the reasoning.
One trace, every provider
Every reasoning step, tool call, browser action, and file write lands in a single ordered timeline, whether the agent ran on GPT, Claude, Gemini, or your own stack.
Six runtimes. One panel.
Live status, capabilities, and pass-through pricing for every provider OpenAct routes to. Pin one, let auto pick, or mix per task.
What one API call actually buys you
Four things every provider makes you build yourself, that OpenAct gives you for free the moment you route through it.
Switch providers without rewriting your agent
The task definition doesn't change when the backend does. Pin a provider to benchmark or negotiate pricing, then swap it back to auto in one line.
Sandboxed by default
Agents don't just talk: they act, running code, clicking through UIs, writing files. Every run gets its own ephemeral sandbox, torn down the moment it ends.
One trace across every provider
Debugging an agent shouldn't mean five vendor dashboards. Every step lands in one ordered timeline, tagged with the provider that produced it.
Approve before it acts
Some actions shouldn't run unattended. Set policy on any tool (refunds over $500, production deploys, outbound email) and OpenAct pauses the run for a human, the same way on every provider.
Pay per run, not per vendor
Every provider bills differently: per token, per request, per compute-second. OpenAct meters what a run actually costs and passes provider charges through at cost.
- No markup on provider cost: you pay what OpenAI, Anthropic, or Bedrock would charge directly
- One flat routing fee per run, regardless of steps or providers touched
- Sandbox compute billed by the second it's actually running, not reserved
- One consolidated invoice and one usage dashboard, however many backends you use
Tell OpenAct what you need, not who runs it
Append a modifier to any run instead of naming a vendor. OpenAct resolves it to whichever provider qualifies right now.
You already know what N providers feels like
Building agents today
- A different SDK, auth model, and error shape per provider
- One rate limit and your whole product stalls
- Tool calls and screenshots scattered across vendor consoles
- Manual sandboxing, or none at all
- A separate invoice, and a separate anomaly, per provider
Building on OpenAct
- One API, one auth token, one request shape
- Automatic failover to the next capable provider, mid-session
- One trace for every step, every provider
- A sandbox on every run, by default
- One invoice, one dashboard, every provider
What people route through OpenAct
Support agents
Resolve tickets, issue refunds, and escalate to a human the moment policy says so.
Coding agents
Read a repo, open a pull request, and run tests, all inside a disposable sandbox.
Research agents
Browse, synthesize, and cite sources across sessions that checkpoint for hours.
Ops & RPA agents
Drive internal UIs your APIs don't cover, sandboxed so a bad click can't reach production.
Fits the stack you already run
Ship with your tools
- SDKs: TypeScript, Python, and Go clients, all generated from the same API.
- Framework adapters drop OpenAct in as the execution backend for LangGraph, CrewAI, or AutoGen.
- Infrastructure as code: a Terraform provider for routing policy, tool grants, and approval rules.
- Async callbacks fire via webhook when a long-running agent finishes, pauses, or fails over.
Built for agents that act, not just talk
- Isolated sandbox per run: no session ever shares a filesystem or process with another.
- Full action audit log records every tool call and file write, not just tokens generated.
- SOC 2 Type II: annual third-party audit across the routing and sandbox layers.
- Regional data residency pins sandbox and log storage to the region your compliance needs.
Stop wiring up agent SDKs one at a time.
Point one API at every provider and start routing today.