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 · 中文

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.

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.

Install Docker with Compose, then:

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

Edit .env before starting:

• Generate BETTER_AUTH_SECRET with openssl rand -hex 32 and PLATFORM_ROOT_SECRET with openssl rand -base64 32. Store both securely; back up the encryption root with your data.
• Select an isolated SANDBOX_PROVIDER and supply its configuration. The deployment does not fall back to running agent commands in an unisolated host subprocess.
• Configure the provider's network, storage, and credential-proxy requirements. Remote sandboxes need reachable services; a private Docker hostname alone is not enough.