Open Managed Agents
Run Claude and OpenAI agents on your own infrastructure.
Use the SDKs you know. OpenMA supports Claude Managed Agents and OpenAI Agents API, with sessions, tools and recovery built in. Bring your own model keys and continue your work through Backchat, OMA CLI or your application.
Open source · Apache 2.0 · Hosted or self-hosted
How OpenMA runs a task.
Clients connect to OpenMA for sessions and orchestration. The harness runs the agent loop; the sandbox provides an execution environment. Your cloud choice determines where the platform is deployed.
OpenMA
Manage the conversation
- Accounts & tenants
- Sessions & event history
- Execution routing
Harness
The agent loop
Built-in · Pi · ACPSandbox
Code, files & tools
Your chosen providerStart with a working deployment.
Use the hosted service, or follow the setup guide to run OpenMA yourself.
Where OpenMA fits.
OpenMA coordinates sessions and execution across the agent ecosystem. Harnesses, sandboxes and cloud infrastructure connect through adapters, so each part can evolve independently.
Any sandbox
Choose where code executes. Connect a sandbox provider through OpenMA’s execution interfaces.
LiteBox · E2B · Daytona · BoxRun
Any harness
Choose the agent loop. Use a built-in harness, connect an ACP agent or implement your own.
Default · Pi · ACP adapters
Any cloud
Choose where you host the platform. Run Node and Docker on your infrastructure, or use a supported cloud deployment.
Self-hosted Node · Cloudflare · Hosted OpenMA
An extensible ecosystem, with concrete integrations. Available features depend on the harness, sandbox adapter and deployment. Explore supported setups.
Tools built around the platform
- OpenMAAgent platform
- Manage agents, tenant sessions, credentials and execution. Use the hosted service or run it yourself.
- Set up OpenMA
- BackchatDesktop app
- Work with local agents and continue OpenMA tenant sessions from one desktop sidebar.
- Explore Backchat
- OMA CLI & SDKDeveloper tools
- Connect from your terminal or build OpenMA into your own application with the TypeScript SDK.
- Use the SDK
- DeepSeek ACPAgent adapter
- Our DeepSeek adapter brings DeepSeek into ACP-compatible clients, including Backchat and OpenMA.
- Explore the adapter
ACP connects agents
Run compatible agents through the Agent Client Protocol. Available features depend on each agent’s capabilities.
MCP connects tools
Give agents access to your services and tools through the Model Context Protocol.
SDKs connect your app
Use the OpenMA SDK, or supported Claude and OpenAI API surfaces. See compatibility details.
Continue the conversation in Backchat.
A desktop home for your agents. Connect your OpenMA account, browse tenant sessions, and pick up a task from your desktop.
Explore BackchatLocal work. Shared conversations.
Keep local sessions alongside your OpenMA tenants in one sidebar.
Pick up where your agent left off.
Continue an OpenMA session in Backchat and keep the conversation in sync.
Get Backchat for macOSConnect the SDK you already use
OpenMA supports Claude Managed Agents and OpenAI Agents API. Start with a deployment, add your model key, and connect your application. Both examples connect to hosted OpenMA.
Claude Managed Agents
@anthropic-ai/sdk Hosted OpenMA: use your API key, configured model and an existing environment ID.
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: process.env.OPENMA_API_KEY,
baseURL: "https://app.openma.ai",
});
const agent = await client.beta.agents.create({
name: "hello",
model: { id: "your-configured-model" },
});
const session = await client.beta.sessions.create({
agent: { type: "agent", id: agent.id, version: agent.version },
environment_id: process.env.OPENMA_ENVIRONMENT_ID!,
});
await client.beta.sessions.events.send(session.id, {
events: [{
type: "user.message",
content: [{ type: "text", text: "Hello" }],
}],
}); OpenAI Agents API
openai Hosted OpenMA: use your API key and configured model. This example runs without a sandbox.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENMA_API_KEY,
baseURL: "https://app.openma.ai/openai/v1",
});
const session = await client.beta.agents.sessions.create({
agent: { model: "your-configured-model" },
environment: { type: "none" },
input: "Hello",
}); On self-hosted Node, let an agent hand off subtasks to other agents that share its files. Each child keeps its own conversation, and you can follow up or stop it. Children cannot create further children.
Hosted OpenMA supports sandbox-free OpenAI sessions. Dynamic subagent controls currently require Node; advanced environment and plugin settings remain unsupported. Check supported features before migrating.
Read the OpenAI SDK setup guide or get started with Claude Managed Agents.
Choose how you run OpenMA.
Use the hosted service or self-host with Node and Docker. Start with SQLite, then connect Postgres and S3 when your deployment needs them. Your agent execution environment is a separate choice: local runtime or cloud sandbox.
Both Node and Cloudflare expose the Claude Managed Agents and OpenAI Agents APIs. Compare deployment options.
Hosted pricing (optional)
Self-host is free forever. The hosted service at openma.ai is for teams who'd rather not run the infra themselves. BYOK for the LLM — we only charge for sandbox compute.
- $1 one-time trial credit
- localRuntime unlimited
- All integrations included
- $22 credit (10% bonus)
- ~73 hours cloud sandbox
- Auto-renewing wallet top-up
- $120 credit (20% bonus)
- ~400 hours cloud sandbox
- Priority email support
Self-host always remains free. Hosted is one packaging of the same Apache 2.0 codebase.
From the blog
All posts →Claude Tag Open-Source Alternative: Self-Hosted with OpenMA
Claude Tag is hosted and closed. Here is how Open Managed Agents becomes the open-source, self-hosted foundation for a Claude Tag-style agent.
How to Self-Host a Claude Tag-Style Agent
Claude Tag is hosted. This guide maps the same product shape onto an open-source, self-hosted Open Managed Agents deployment.
The Architecture of Open Managed Agents: Durable Objects, R2, and the Brain/Sandbox Split
How Open Managed Agents is structured under the hood. Durable Objects with embedded SQLite as the per-session log, Cloudflare Containers as the sandbox, R2 for blobs, and the deliberate split between the brain (harness) and the body (sandbox).
Get started
Self-host: clone the repo, set ANTHROPIC_API_KEY,
docker compose up. Hosted: sign in, BYOK, ship.