Skip to content
openma

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

Connect your SDK

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.

Connect your way

OpenMA

Manage the conversation

  • Accounts & tenants
  • Sessions & event history
  • Execution routing

Harness

The agent loop

Built-in · Pi · ACP

Sandbox

Code, files & tools

Your chosen provider
Your infrastructureSelf-hosted Node / Docker · Cloud deployment · Hosted OpenMA
OpenMA manages connected sessions and records events. Harness and sandbox adapters determine how work executes; the deployment determines where OpenMA runs. Backchat can also run standalone local sessions.

Start 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 Backchat

Local 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 macOS

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

Free
$0/mo
  • $1 one-time trial credit
  • localRuntime unlimited
  • All integrations included
Most popular
Pro
$20/mo
  • $22 credit (10% bonus)
  • ~73 hours cloud sandbox
  • Auto-renewing wallet top-up
Max
$100/mo
  • $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 →

Get started

Self-host: clone the repo, set ANTHROPIC_API_KEY, docker compose up. Hosted: sign in, BYOK, ship.