Anthropic’s self-hosted Claude Managed Agents gives organizations a way to operate the agent platform inside their own cloud or on-premises environment instead of relying on Anthropic to host the entire service. The November 12, 2026 announcement moves beyond the earlier option of running only an agent’s sandbox on customer infrastructure: the self-hosted release puts the agent harness, server, database, credentials, session history, and tool-execution workers under the organization’s operational control.

That distinction matters for teams building autonomous agents that can read source code, run commands, access internal systems, triage alerts, or work through engineering backlogs. Keeping the platform in a private environment can improve control over where operational data is stored and which systems an agent can reach. It also transfers meaningful infrastructure, security, and maintenance responsibilities to the organization.

This guide explains the architecture, how the development quickstart differs from a production deployment, what the Kubernetes path requires, how model inference and data flows work, and which security controls should be reviewed before an agent receives access to sensitive systems.

Availability and scope: Anthropic announced self-hosted Claude Managed Agents as a private beta on November 12, 2026. Access to the release archive currently requires contacting an Anthropic account team. This is an implementation guide based on Anthropic’s announcement and documentation available on November 13, 2026. It is not a report of an independent deployment test by Articles About AI.

Quick answer: what is self-hosted Claude Managed Agents?

Self-hosted Claude Managed Agents is a deployment option for Anthropic’s Managed Agents platform. Instead of having Anthropic operate the complete service, an organization runs the Managed Agents server, its database, and the workers and sandbox infrastructure that execute agent tools.

The agent definition and core API model remain familiar to developers already using hosted Managed Agents. What changes is where the service components run, who operates them, how credentials and session history are stored, and where model requests are routed.

The key points are:

  • Control plane: The organization operates the Managed Agents server and the agent harness.
  • State and history: Session history and platform data are stored in the organization’s database.
  • Tool execution: Workers run shell and file operations inside isolated sandboxes on infrastructure the organization controls.
  • Credentials: The deployment can use its own credential-management arrangements and secrets infrastructure.
  • Inference routing: Model requests can go to Anthropic, a supported cloud model provider, or an organization’s own model gateway, depending on configuration.
  • Operations: The organization owns deployment, upgrades, database availability, network boundaries, logging, monitoring, and incident response.

Self-hosting is therefore not simply a switch that makes Claude run locally. It changes the hosting and control boundary around the agent platform. If the Claude API remains the configured inference provider, model requests still go to Anthropic.

What changed on November 12, 2026?

Anthropic introduced Managed Agents as a hosted way to build and operate long-running agents without having to assemble every part of the agent loop, tool execution layer, state management, and runtime infrastructure yourself.

Before the November 12 announcement, developers could also use self-hosted sandboxes: the agent’s tool execution could take place on infrastructure controlled by the customer while the wider Managed Agents service remained hosted. That is useful when code, files, and commands must execute inside a company’s network, but it does not mean the whole platform is self-hosted.

The new self-hosted Managed Agents option takes the boundary further. Anthropic says the organization can run the harness, sandboxes, credentials, and session history in its own cloud or on-premises environment. Developers continue to use the same core APIs as the hosted service.

Deployment model What the organization operates Main distinction
Hosted Managed Agents Agent configuration and application integration Anthropic operates the platform infrastructure
Self-hosted sandbox The worker and sandbox where agent tools execute The wider Managed Agents service remains hosted
Self-hosted Managed Agents Server, database, workers, sandboxes, and supporting infrastructure The organization operates the complete agent service boundary

Do not treat these options as interchangeable. A team evaluating data residency, internal network access, or operational responsibility should identify exactly which components are hosted by the provider and which components run in its own environment.

Self-hosted Claude Managed Agents architecture

The architecture separates the agent’s control logic from the environment in which its tools execute. At a high level, a self-hosted deployment contains five cooperating parts.

1. Managed Agents server and control plane

The server provides the API surface used by applications, SDKs, and command-line tools. It manages agents, environments, sessions, and the events exchanged while an agent works.

The control plane coordinates the agent’s execution rather than placing every component inside the same sandbox. This separation allows a session to continue across tool executions without depending on one long-lived sandbox process.

2. PostgreSQL database and persistent state

The self-hosted stack uses PostgreSQL for its database. Session history is stored in the organization’s own database rather than being hosted as part of Anthropic’s managed service.

Database operations become part of the deployment’s reliability plan. Teams should define backup frequency, restore procedures, access controls, encryption, retention, capacity monitoring, and recovery objectives before production use. Protect the encryption material needed to recover stored credentials; a database backup without its required encryption key may not be sufficient for a complete restoration.

3. Workers and dispatcher

Workers claim work for an environment and run the agent’s shell and file tools. In a Kubernetes deployment, Anthropic’s documented charts include a dispatcher that polls the server for work and starts sandbox pods for sessions.

Worker design affects isolation and capacity. An always-on worker is a straightforward option for continuously polling a work queue. A webhook-triggered pattern can reduce idle polling but requires a reachable webhook endpoint. Teams should select a model that matches their availability, scaling, and network requirements.

4. Isolated sandbox for each session

The sandbox is where the agent’s commands and file operations run. In the documented Kubernetes pattern, a session can receive its own sandbox pod. This gives the operator a clearer boundary for filesystem state, resource limits, and network policy.

A fresh sandbox per session can improve isolation between workloads, but isolation is not automatic security. The container or pod still needs appropriate runtime restrictions, network egress controls, resource limits, and protection against access to cluster credentials or internal services.

5. Model inference provider

The server sends model requests to the configured inference provider. Anthropic documents the Claude API as the default provider and describes alternatives including Amazon Bedrock, Google’s Agent Platform, Microsoft Foundry, and a customer-operated model gateway.

This is an important architectural distinction: self-hosting the agent platform does not by itself mean self-hosting the model weights or running Claude inference offline. The inference provider determines where prompts, tool inputs, and tool results are sent for model processing.

Architecture flow: from an application request to an agent tool call

A simplified request lifecycle looks like this:

  1. An application authenticates to the self-hosted Managed Agents server and creates or resumes a session.
  2. The server records the session state and coordinates the agent’s next step.
  3. The configured inference provider receives the model request and returns the next action.
  4. When the agent needs to use a shell or file tool, the worker claims the work.
  5. The worker executes the operation inside the configured sandbox.
  6. The tool result returns to the agent runtime and becomes part of the session event history.
  7. The agent can continue, request another tool, or return a result to the application.
  8. Operational events can be monitored and exported to an observability system where configured.

The architecture separates three questions that are often confused: where the control plane runs, where tool execution runs, and where model inference runs. An enterprise architecture review should document each location independently.

Deployment options: Docker Compose or Kubernetes?

Anthropic provides a Docker Compose quickstart for starting the server, PostgreSQL, and workers on one machine. It is intended for development and initial evaluation, not as a production deployment blueprint.

Area Docker Compose quickstart Kubernetes deployment
Intended use Local development and initial evaluation Production-oriented deployment
Core components Server, PostgreSQL, workers, sandbox containers Server chart, sandbox chart, dispatcher, sandbox pods, external PostgreSQL
Isolation model Containers on one Docker host Kubernetes sandbox pods with cluster-level controls
Scaling and operations Limited single-host setup Cluster scheduling and operational controls
Installation Docker Compose Helm charts from the release archive
Security posture Development defaults; not production-ready Requires deliberate cluster, network, database, and TLS configuration

Docker Compose: a development quickstart

The official quickstart requires the self-hosted release archive, a Claude API key for the default inference setup, Docker Engine with the Compose plugin, and the ant CLI. Anthropic lists a host with at least two CPUs as a prerequisite.

The documented workflow is:

  1. Obtain the release archive through the Anthropic account team.
  2. Extract it and move into the supplied compose directory.
  3. Create the local .env file with separate values for the PostgreSQL password, upstream model credential, server API key, and credential-encryption key.
  4. Restrict access to the secrets file.
  5. Start the stack with docker compose up --build -d.
  6. Follow the server logs and check the readiness endpoint.
  7. Point the ant CLI at the local server and create a test agent and session.

The readiness endpoint in the quickstart is:

curl -s http://127.0.0.1:8400/cma-server/readyz

A ready response reports "status":"ready". The service may briefly report a degraded state while its initial checks complete.

Do not expose the Compose quickstart as a production service. Anthropic explicitly describes it as a development stack. It uses plain HTTP and binds port 8400 to the Docker host’s loopback address by default. The documentation also warns about local-network reachability under some Docker Engine versions earlier than 28.3.3. Agent tools run in containers on the same host, so use a disposable development machine that does not contain data or credentials you need to protect.

Kubernetes: the production deployment path

For production, Anthropic recommends the two Helm charts included in the release archive. Its Kubernetes guide walks through a deployment on Google Kubernetes Engine and explains the corresponding requirements for other clusters.

The two main chart responsibilities are:

  • cma-server: Runs the Managed Agents servers and applies the database schema.
  • cma-sandboxes: Runs the dispatcher and the sandbox pods that execute session tools.

The documented Kubernetes prerequisites include:

  • Kubernetes 1.30 or later.
  • The Agent Sandbox controller, or the corresponding supported component for the chosen platform.
  • Nodes configured for a sandboxed runtime such as gVisor, following the platform-specific instructions.
  • A network plugin that enforces Kubernetes NetworkPolicy.
  • PostgreSQL 16 or later that the cluster can reach.
  • A container registry for the images built from the release archive.
  • Helm, kubectl, Docker Buildx, OpenSSL, and the ant CLI.
  • The required cluster permissions to create namespaces and role bindings.

The high-level deployment sequence is:

  1. Prepare the Kubernetes cluster and verify the sandbox controller, runtime, and network-policy enforcement.
  2. Build and push the server, dispatcher, and sandbox images to a registry.
  3. Provision PostgreSQL and create the database credentials.
  4. Create separate namespaces and Kubernetes Secrets for the server and sandbox components.
  5. Install the cma-server Helm chart and configure the database connection.
  6. Install the sandbox chart and configure the dispatcher, platform, and egress behavior.
  7. Forward the server port for an initial test, point the CLI at the deployment, and create a test session.
  8. Verify that a tool call runs inside the expected sandbox pod.
  9. Put a TLS-terminating load balancer or ingress in front of the server before allowing external clients to connect.

The official guide’s GKE example uses separate cma-server and cma namespaces. The database remains outside those two namespaces. Other Kubernetes platforms require platform-specific configuration; do not copy GKE values unchanged into EKS, AKS, or a generic cluster.

TLS and ingress are not optional production details

The Kubernetes guide states that the server speaks plain HTTP on port 8400. Before applications outside the cluster connect, place a load balancer or ingress that terminates TLS in front of the server service.

The ingress must preserve request paths, support the documented request-body size, avoid buffering streamed responses, use appropriate read timeouts, route only to ready server instances, and avoid retrying a POST request that the server has already accepted. It must not cache API responses.

These details affect both security and correctness. A generic reverse-proxy configuration that buffers responses or retries accepted requests can break streaming behavior or create duplicate operations.

Security model: what changes when you self-host?

Self-hosting gives an organization more control over its environment, but it also makes that organization responsible for securing the components it operates. A private network or a Kubernetes cluster does not automatically make an autonomous agent safe.

Keep the agent harness separate from tool execution

The control plane and sandbox have different responsibilities. The harness coordinates the agent, while the sandbox runs the code and commands requested through tools.

Preserve that separation. Do not place long-lived application secrets, database administrator credentials, cluster-admin credentials, or unrelated production data inside a sandbox merely because the agent needs access to one repository or service.

Protect credentials and encryption keys

The deployment has several distinct credentials: application-to-server authentication, server-to-inference-provider authentication, database authentication, environment or worker credentials, and secrets used by connected tools.

Use a dedicated secret manager or Kubernetes Secrets with an appropriate external key-management strategy. Apply least privilege to every credential, rotate keys, restrict who can read them, and avoid printing secret values in logs or build output.

Keep the credential-encryption key in a protected backup location separate from the database backup. Test the restore process rather than assuming that a successful database snapshot guarantees recoverability.

Restrict network egress

A worker can generally reach whatever the sandbox’s network configuration permits. If an agent can read untrusted repository content or external documents, unrestricted outbound access can create a route to unintended destinations.

Use network policies, firewall rules, and an egress gateway where appropriate. Begin with a deny-by-default posture and allow only the Git hosts, package registries, internal APIs, and MCP endpoints that the workflow actually requires.

Anthropic’s Kubernetes guide distinguishes between closed egress, public internet access, and gateway-based access. Choose the narrowest mode that supports the task. Validate that sandbox pods cannot reach Kubernetes control-plane endpoints, cloud metadata services, or private network ranges that should remain inaccessible.

Apply least privilege to tools and actions

Do not enable every tool by default. Give each agent only the tools needed for its job, and separate read-only work from operations that modify repositories, tickets, cloud resources, or production records.

Require human approval for actions that are difficult to reverse or have a meaningful external impact. Treat untrusted issue descriptions, repository files, web pages, and user-provided documents as data—not as trusted instructions that can expand the agent’s permissions.

Use session and deployment budgets, timeouts, and a clear stop mechanism. A runaway agent should not be able to continue indefinitely or consume an unlimited amount of compute and inference spend.

Record, monitor, and review agent activity

An agent’s final response is not a complete audit trail. Production monitoring should capture session lifecycle events, tool calls, tool results, errors, retries, resource consumption, and relevant security decisions.

Anthropic describes exporting session records through OpenTelemetry. Teams can route this telemetry to their existing monitoring platform and correlate agent activity with application logs and infrastructure metrics.

Set alerts for sessions that become idle unexpectedly, reach a budget, terminate with errors, or generate unusual tool activity. Define retention rules for transcripts and logs because they may contain source code, internal identifiers, customer data, or other sensitive content.

Data residency: what stays inside your environment?

Self-hosting changes the location of the Managed Agents server, database, credentials, session history, and tool-execution environment. It does not mean that every piece of information automatically stays on-premises.

The configured inference provider receives the conversation context needed for model calls. When the Claude API is the provider, that includes the conversation so far, tool inputs, and tool results. If another provider is configured, requests are routed there instead.

Other outbound connections depend on the services the organization enables: approved MCP servers, Git hosts, identity providers, secret managers, key-management services, model-listing endpoints, and an OpenTelemetry collector.

Before approving a deployment, create a data-flow inventory that answers:

  • Which components run in the organization’s cloud or data center?
  • Which inference provider receives prompts and tool results?
  • Which repositories and internal services can workers access?
  • Which MCP servers are enabled, and who approves them?
  • Where are session events, traces, and application logs stored?
  • How long are transcripts and sandbox files retained?
  • Who can access the server, database, secrets, and backups?
  • What happens to data when a session is archived or deleted?

Anthropic’s self-hosted data-and-access documentation is the authoritative place to verify the current outbound connection list and the information sent to the selected inference provider. Do not infer data residency solely from the phrase “self-hosted.”

Hosted vs self-hosted: which option should a team choose?

Self-hosting introduces additional infrastructure and operational work. It is not automatically the best option for every team.

Requirement Hosted Managed Agents Self-hosted Managed Agents
Minimize infrastructure operations Better fit Requires an operations team
Keep server and session database in your environment Not the primary hosted model Core reason to consider it
Run tool execution in infrastructure you control Consider self-hosted sandboxes Included in the broader self-hosted model
Choose a separate inference provider or model gateway Depends on hosted service support Explicitly part of the self-hosted architecture
Manage Kubernetes, database, backups, and upgrades yourself Less operational responsibility Organization owns these responsibilities
Evaluate the platform quickly Usually simpler Requires beta access and deployment setup

Choose hosted Managed Agents when the priority is reducing infrastructure work and the hosted data-handling model meets your requirements.

Consider self-hosted Managed Agents when the organization needs the full agent service, session history, and tool execution to operate within infrastructure it controls, and has the engineering capacity to secure and maintain that stack.

If only command execution or repository access needs to stay inside the company’s network, compare the earlier self-hosted sandbox option before taking on the operational cost of hosting the complete platform.

Limitations and questions to resolve before deployment

The November 2026 announcement is a private beta, not a general-availability release. Access to the release archive requires contacting Anthropic. Teams should confirm eligibility, supported cloud platforms, release compatibility, and support arrangements with Anthropic before planning a production rollout.

Other points deserve explicit review:

  • Operational ownership: The organization must operate and secure the server, database, workers, sandbox runtime, network controls, and upgrades.
  • Inference remains separate: The platform’s hosting location does not determine where model inference occurs.
  • Beta changes: APIs, release archives, Helm chart values, and supported deployment details can change during the beta.
  • Data handling: Review current retention, logging, and provider-specific behavior. The self-hosted deployment should not be assumed to have zero data retention or a particular compliance status.
  • Compatibility: Confirm the chosen Kubernetes platform and sandbox runtime against the current official guide rather than assuming every cluster behaves identically.
  • Recovery: Test database restoration, encryption-key recovery, and session-data retention before relying on the platform for critical workflows.

A practical pre-production checklist

Before giving an autonomous agent access to internal repositories or business systems, verify each of the following:

  • The organization has confirmed private beta access and obtained the matching release archive.
  • The deployment architecture identifies the control plane, database, workers, sandboxes, and inference provider.
  • Docker Compose is used only for development, or the production Kubernetes deployment follows the official Helm guidance.
  • PostgreSQL backups and restore procedures have been tested.
  • Database credentials, server API keys, upstream model credentials, and encryption keys are stored securely.
  • TLS terminates in front of any server endpoint reachable by external clients.
  • Worker and sandbox network egress is restricted to approved destinations.
  • Sandboxes cannot access cluster administration endpoints or unrelated internal services.
  • Agents have only the tools and permissions required for their tasks.
  • High-impact write operations require review or approval.
  • Session budgets, timeouts, alerts, and a stop procedure are configured.
  • Session events and relevant traces are exported to an approved monitoring system.
  • Transcript retention, deletion, and backup policies are documented.
  • The organization has tested an incident response and recovery scenario.

Frequently asked questions

Is self-hosted Claude Managed Agents the same as Claude running locally?

No. Self-hosting refers to operating the Managed Agents platform and agent execution infrastructure in your environment. If the Claude API is the configured inference provider, model requests still go to Anthropic. The platform also documents alternative inference providers and model gateways.

Can I deploy it on my own Kubernetes cluster?

Anthropic documents a Kubernetes deployment using two Helm charts. The guide covers GKE and describes the configuration differences and prerequisites for EKS, AKS, and generic Kubernetes clusters. Check the current platform requirements before selecting a cluster.

Can I use Docker Compose in production?

Anthropic’s quickstart explicitly says the Compose stack is for development, not production. For production, Anthropic recommends the two Helm charts supplied with the release archive.

Does self-hosting keep all data inside my network?

Not automatically. The server, database, credentials, session history, and tool-execution infrastructure can run in your environment, but model requests and enabled integrations may communicate with external providers. Review the data-flow documentation and configure the inference provider and outbound destinations deliberately.

Is self-hosted Claude Managed Agents generally available?

Anthropic announced it as a private beta on November 12, 2026. The official quickstart says to contact an Anthropic account team to request access to the release archive.

What database does the Kubernetes guide require?

The documented Kubernetes deployment requires PostgreSQL 16 or later that the cluster can reach. The Docker Compose quickstart includes PostgreSQL as part of its development stack.

What is the difference between a self-hosted sandbox and self-hosted Managed Agents?

A self-hosted sandbox moves agent tool execution to infrastructure controlled by the customer while the broader Managed Agents service remains hosted. Self-hosted Managed Agents moves the server, database, credentials, session history, workers, and sandboxes into the organization’s environment.

Final verdict

Self-hosted Claude Managed Agents is a significant infrastructure option for organizations that need more control over where agent orchestration, session history, credentials, and tool execution run. Its value is not simply that an agent can access private code; it is that the organization can operate the broader agent platform within its own security and operational boundary while retaining the same core developer API model.

The trade-off is substantial responsibility. Teams must run and secure the database, server, workers, sandbox runtime, network boundaries, secrets, observability, and upgrade process. The Docker Compose quickstart is useful for evaluation, while Anthropic points production deployments toward Kubernetes and its Helm charts.

For engineering and security teams, the right next step is to compare the hosted, self-hosted sandbox, and fully self-hosted models against an explicit data-flow diagram and threat model—then validate the chosen architecture with a limited, non-production workload before granting agents access to critical systems.

Official sources and further reading

  1. Anthropic: Operate Claude Managed Agents inside your security perimeter (November 12, 2026)
  2. Anthropic documentation: Self-hosted Managed Agents quickstart
  3. Anthropic documentation: Deploy self-hosted Managed Agents on Kubernetes
  4. Anthropic documentation: Data and access in self-hosted Claude Managed Agents
  5. Anthropic documentation: Secure your Managed Agents deployment
  6. Anthropic documentation: Choosing an agent environment