open-managed-agents

Open Managed Agents

Any model. Any harness. Any sandbox. Any cloud.

OpenMA handles sessions, execution and recovery, so you can build and run agents with any model, any harness, any sandbox, on any cloud. An open-source, self-hostable alternative to Claude Managed Agents and OpenAI Agents API.

Your choice of infrastructure, too. Use built-in adapters or plug in your own database, queue, and object storage.

Try hosted · Self-host · For agents · API examples · Documentation · Apache-2.0 · 中文

Model configuration	Execution environment

Actual Console UI with synthetic demo data. Integration statuses and configurations are illustrative. Click a screenshot to view it at full size.

Build on managed execution

Create an agent, give it work, and return to the same session later. OpenMA provides:

• Durable sessions and recovery. Preserve conversation history, stream progress, and coordinate execution attempts without tying the session to one process. Workspace checkpoints and retained outputs support recovery with the configured runtime.
• Tools and integrations you can reuse. Start with shell, file, web, and browser tools. Add MCP services and Skills, then connect agents to the platforms where your team works.
• Control over your deployment. Choose the model, harness, sandbox, and backend services independently. Operate through the Console, CLI, or API.
• Evals on the same sessions. Import Harbor benchmarks from GitHub, Hugging Face, a Harbor registry or an uploaded archive as immutable revisions, and score agents on managed Sessions on Node and Cloudflare. See Evals.

If OpenMA is useful to you, give the repository a Star. Use Watch → Custom → Releases for release notifications.

For agents

Install the deployment skill for your coding agent:

npx skills add openma-ai/open-managed-agents --skill deploy-openma

Then ask: “Deploy OpenMA on this machine.” Your agent checks the environment, prepares configuration, deploys the platform, and verifies the Console and an agent task. It asks for the target, login or credentials when needed, and confirms paid cloud resources before creating them. The command installs the guide; deployment starts when you ask your agent.

Choose your stack

Use the included adapters or implement an extension. “Any” means you can extend these interfaces; available features and setup depend on the selected adapters. Follow the linked provider and deployment guides for requirements.

Architecture: platform, harness, sandbox

OpenMA is a meta-harness: it manages the resources and lifecycle around an agent loop. Choose the execution path that fits your agent.

Harness outside the sandbox: independent lifecycles

Run the model loop outside the sandbox and use the sandbox to execute tools. Keep session history separate from both, so a sandbox failure does not erase the conversation and a replacement harness can rebuild context from durable events. Manage execution resources without coupling them to the lifetime of the agent loop.

Use the built-in Pi harness or implement the host-side harness interface. Workspace restoration depends on the configured persistence and provider; the Runtime Host guide describes ownership and recovery.

Harness inside the sandbox: reuse a mature agent

Bring Claude Code, Codex, or another established harness into a managed sandbox. Reuse its agent loop, context management, tools, and skills rather than rebuilding those capabilities. OpenMA supplies the surrounding work lifecycle, workspace persistence, and output collection.

The ACP runtime provides existing integrations, including versioned harness installation independent of the sandbox image. Custom harnesses can use the supervisor contract; ACP is one option. Native features and session resume depend on the selected adapter.

Tools and integrations, already connected

Combine repository tools with GitHub for issue investigation, or web tools with Slack for a research assistant. Reuse the same tools and skills across more agents instead of building a new integration stack for each workflow. Configure the required service credentials and permissions; in-sandbox harnesses use their native tools and adapter-provided capabilities.

Built-in tools · Browser · MCP and Skills · Integrations

Scale the execution as your workloads grow

Tool reuse helps you add workflows. For more concurrent sessions, Node deployments can use shared PostgreSQL or MySQL and compatible storage/runtime services across replicas. For harnesses outside the sandbox, replicas claim different sessions in parallel through a durable execution outbox, renewable leases, and fencing; work within a session stays ordered. In-sandbox harnesses use the separate Environment Work claim, rather than nesting a second Session execution claim.

The single-host SQLite quickstart is a separate deployment choice. Capacity depends on the database, storage, sandbox provider, and model limits; see session execution and scaling.

Complete the work loop with OpenMatter

Integration status: OpenMatter implements the Loop runtime. Unified Bond/Loop hosting in this OpenMA revision remains a proposed integration.

OpenMatter connects work events to authorized context, agent turns, and recorded results delivered back to the work system. OpenMA supplies the agent execution infrastructure.

Work event → authorized context → agent execution → result delivery
     ↑                                                   │
     └──────────────── follow-up feedback ────────────────┘

An issue-to-PR workflow can investigate an issue, prepare a change, post the result, then use review feedback for the next turn. The same pattern can support OpenMA’s own development. This is a workflow to compose with application-defined permissions and approvals, not a preconfigured auto-merge bot.

Support and boundaries

• API coverage: Claude Managed Agents and OpenAI Agents API have separate contracts. Both use OpenMA’s native infrastructure; the OpenAI adapter’s limits do not describe the entire platform. See API examples and compatibility.
• Delegation: Node’s OpenAI path supports creating, messaging, waiting on, interrupting, closing, and resuming subagents with independent histories and a shared sandbox. Its execution baseline is single-level delegation; hosted Cloudflare coverage differs. See the compatibility report.
• Credentials: Model Cards encrypt provider keys at rest. Vault-backed gateways support scoped access to private services; enforced credential isolation depends on the provider and runtime profile. See credential egress requirements.
• Backend extensions: New adapters must preserve required transaction, claim/retry, and conditional-write semantics. Background queues, Session execution claims, and Environment Work have distinct contracts. See Node composition and architecture.

Self-hosting

Node / Docker

Use the deployment skill to let your coding agent handle setup, or follow the manual steps below.

git clone https://github.com/openma-ai/open-managed-agents.git
cd open-managed-agents
cp .env.example .env

docker compose up -d --build
curl --fail http://localhost:8787/health

Quick start: Cloudflare deploy

Use the Node version in .node-version, the repository’s pinned pnpm version, Docker for container builds, jq, and openssl. Authenticate to a Cloudflare account with the required Workers/Containers services enabled.

git clone https://github.com/openma-ai/open-managed-agents.git
cd open-managed-agents
pnpm install --frozen-lockfile
npx wrangler login
pnpm setup:cloudflare

The script provisions Cloudflare resources, updates the local Wrangler configuration, sets secrets, and deploys the Workers. It currently prompts for an Anthropic API key unless supplied in the environment. Review scripts/setup-cf.sh and the deployment guide before running it; this creates cloud resources and may incur charges. Use the URL printed by your deployment, not OpenMA’s hosted domain.

APIs and compatibility

OpenMA is an independent implementation. Check the API and runtime coverage before migrating.

Kimi Hosted Agents on Node

Use a source build containing the experimental adapter and set OMA_KIMI_KHA_COMPAT=1 on the Node server. Point KHA CLI 0.4.2 at http://localhost:8787/kha and use an OpenMA API key as KIMI_API_KEY. The CLI adds /v1; do not append it yourself. Create the agent natively first. This is a tested protocol subset, not full Hosted Agents parity or a claim of hosted availability. See the quickstart, compatibility matrix and verification limits.

Claude Managed Agents API

First create an OpenMA API key, a Model Card, and an environment in the Console. Set OPENMA_API_KEY, OPENMA_MODEL_ID (the Model Card’s model_id, not its database record ID), and OPENMA_ENVIRONMENT_ID. For self-hosting, set OPENMA_BASE_URL to your server origin without a trailing slash, such as http://localhost:8787.

The repository pins the official Anthropic SDK to 0.120.0:

npm install @anthropic-ai/[email protected]

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.OPENMA_API_KEY,
  baseURL: process.env.OPENMA_BASE_URL ?? "https://app.openma.ai",
});

const agent = await client.beta.agents.create({
  name: "researcher",
  model: process.env.OPENMA_MODEL_ID!,
  system: "Help me investigate a task and explain your findings.",
});

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: "Help me plan a code review." }],
  }],
});

console.log(session.id);

Open that session in the Console to follow the task. The official SDK E2E also demonstrates event streaming and continuation. For typed OpenMA extensions, use @openma/sdk, which composes the official Anthropic SDK.

OpenAI Agents API quickstart

Use the same OpenMA API key and a configured Model Card. This adapter’s tested SDK baseline is [email protected]:

npm install [email protected]

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENMA_API_KEY,
  baseURL: `${process.env.OPENMA_BASE_URL ?? "https://app.openma.ai"}/openai/v1`,
});

const events = await client.beta.agents.sessions.create({
  agent: {
    model: process.env.OPENMA_MODEL_ID!,
    instructions: "Help me investigate a task and explain your findings.",
  },
  environment: { type: "none" },
  input: "Help me plan a code review.",
  stream: true,
});

for await (const event of events) console.log(event);

This example requests no sandbox. Node and hosted Cloudflare support this session path. OpenAI dynamic subagent controls currently require Node and use single-level delegation. Advanced environment, plugin, and some model/tool settings have additional limits; these adapter limits do not describe the whole OpenMA platform. See the compatibility report.

Development and community

Use the versions in .node-version and package.json:

pnpm install --frozen-lockfile
pnpm typecheck
pnpm test

Contributing · Issues · Security reports · Discord · OMA CLI · Website

License

Apache-2.0. See individual package manifests and NOTICE for package and third-party license information.