Agents Move Into Your Own Data Center: Anthropic Opens Self-Hosted Claude Managed Agents in Private Beta, but the Model Still Lives Outside
On November 12, 2026, Anthropic opened a private beta of self-hosted Claude Managed Agents: the whole agent service — API, agent loop, sessions and history — can run on your own cloud or on-premises infrastructure, on a server called cma-server with history in PostgreSQL 16 or later. The model itself does not move home: every model call still goes to Anthropic, Bedrock, Google Cloud or Foundry, and there is no public pricing or general-availability date yet.

In one sentence: the service moves home, the model stays outside
On November 12, 2026, Anthropic added a short entry to the Claude Platform release notes: “We’ve launched self-hosted Claude Managed Agents. You run the whole Managed Agents service, not only self-hosted sandboxes, on your own infrastructure, and you store agents, sessions, and session history there. The server sends model requests to the provider that you choose, which is Anthropic by default. To request access, contact your Anthropic account team.” A few lines, but they turn Claude’s agent service from something you rent into something you can bring home.
The key phrase is “the whole service.” Managed Agents is Anthropic’s service for hosting long-running AI agents: an agent that works through a bug backlog, fixes builds, tests releases, and triages alerts over hours, instead of answering one chat message and stopping. It launched in April 2026 as a fully hosted service, with Anthropic running all the infrastructure. In May, Anthropic added self-hosted sandboxes, letting the environment where an agent runs code move onto the customer’s own machines — while the agent loop, the session archive, and the credentials still lived at Anthropic. The November 12 step brings the rest home too: the API, the agent loop, the agent definitions, the sessions, and the session history all run in your own cloud account or data center.
But the second sentence matters just as much, and it is the one most likely to be misread: “The model runs at Anthropic or at a provider that you choose.” Self-hosting moves the body of the service, not the model itself. Every model call still sends the conversation out — to Anthropic, or to Amazon Bedrock, Claude Models on Google Cloud (Google managed), Microsoft Foundry, or your own model gateway. The accurate way to say it is: the agent has moved into your house; Claude still lives outside, and each time it works you decide which door it comes through.
The release is a private beta for now. There is no public pricing, no list of covered countries, and no date for general availability; the only way in is through an Anthropic account team. For a company deciding whether to let agents into its core systems, the value of this news is not “you can use it today” but “the direction is set”: Anthropic is willing to hand over control — and the operational work that comes with it.
What was actually announced
It is worth stating plainly what happened, before the retellings blur it. Anthropic held no launch event and published no standalone blog post about this. It added three sentences to the Claude Platform release notes under “November 12, 2026,” and shipped a full set of self-hosted documentation covering the architecture, where data flows, and which features exist and which do not. Both are Anthropic’s own official documentation, and they are the source of every fact in this article.
On the timeline, this is a methodical step, not an impulse. Managed Agents launched in April 2026 as a hosted beta, with Anthropic running the infrastructure and customers only defining agents. On May 19, self-hosted sandboxes arrived: the isolated environment where an agent’s code runs could move onto customer infrastructure, while Anthropic kept running the agent itself and storing skills and memory stores. On November 12, the whole service can be self-hosted. Anthropic’s documentation puts the relationship bluntly: self-hosted sandboxes move the first part; self-hosted Managed Agents moves the second part too. The name says what you host.
One more boundary: this is not a new model and not a capability upgrade. The model news in the same release notes belongs to November 9 — Claude Fable 5.2 and Claude Mythos 5.2 — and that is a different story. Self-hosting changes nothing about what the model can do. It changes where the service runs, where data is stored, and who operates it. For an engineering lead, that is a deployment question; for a compliance and security team, it is a data-ownership question; for end users, nothing changes in the short term.
Three rows that explain who runs what
Anthropic’s documentation has a small comparison table that makes the three deployment modes unmistakable: sandboxes, service, and model — who runs each.
This table is worth a second look, because it removes the ambiguity in the word “self-hosted” in one stroke. Many people hear “self-hosted Claude” and first think “the model runs on my own machines.” The table says no: the model column never changes hands; only the first two columns do. Cloud sandboxes are the default, with all three rows at Anthropic; self-hosted sandboxes hand you the first column; self-hosted Managed Agents hands you the second column too. The third column is never yours in any mode — unless you count “your own model gateway” as “the model runs at home,” but a gateway is only the door requests pass through; the model itself still sits behind it, at some provider.
The table also carries a second message: the choice is a ladder, not a leap. If you only want the environment where tools run to stay on your side, self-hosted sandboxes are enough, and Anthropic keeps running the service. You only need the whole service to move home when you must store session history yourself, or when model calls must go to Bedrock, Google Cloud, or Foundry. Anthropic’s documentation gives the same advice: if only the tools need to run on your infrastructure, use self-hosted sandboxes and let Anthropic run the service.
What exactly moves home
A self-hosted deployment is made of four pieces plus an admin tool, and the documentation spells out each one’s job.
The first piece is the server, called cma-server. It serves the Managed Agents API, runs the agent loop, stores agents, sessions, and each session’s history, and calls your inference provider whenever the agent needs the model. One hard line to remember: the server never runs an agent’s shell or file tools. When an agent needs to run a command or edit a file, separate worker programs do it; the server itself never touches those tools. That is a deliberate security boundary.
The second piece is the database: PostgreSQL 16 or later. The server can run without one, but then it keeps its data only in memory, and a restart erases it. For any serious deployment, the database is not optional. Sessions and session history live in this database, and you own its backups and cleanup.
The third piece is the workers. Workers take work from the server and run the agent’s shell and file tools inside your sandboxes. A worker is an ant beta:worker command or an SDK worker. Workers are separate processes from the server; you can run many of them across machines.
The fourth piece is your own applications: your code and scripts, which reach the server through the SDK or the ant CLI. Beyond that, the server’s address also serves a web console, where people sign in through your identity provider to create agents and run sessions. And there is an admin CLI, cma-server-admin, which creates environments and their environment keys; it runs on Linux (x86-64 and Arm) and on macOS on Apple silicon.
Credentials come in three kinds, and the documentation explains who holds what in a single table. The server API key is held by your applications, the ant CLI, and the admin CLI; it authenticates requests to your server and plays the role a Claude API key plays with the hosted service. The inference credential is held only by the server; it authenticates the server’s model calls to your inference provider — a Claude API key, your cloud provider’s credential, or the token your model gateway accepts — and applications and workers never need it. The environment key is held by the workers that poll the server, and it covers one environment’s work queue and that environment’s sessions. Each credential minds its own business. Anthropic issues none of them and holds none of them.
The easiest misunderstanding: this is not “offline Claude”
The word “self-hosted” invites a tempting illusion: once things move home, data never leaves the house again. Anthropic’s documentation spends a whole page taking that illusion apart. The conclusion is direct: no.
For each model call, the server sends the conversation so far to the inference provider, including prompts, tool inputs, and tool results. If the provider is the default Claude API, that goes to Anthropic; if you chose Bedrock or Foundry, it goes to that cloud provider. In other words, what the agent is working on — which bug it is fixing, which files it read, which internal systems it touched — leaves your network every time. Only the destination is yours to choose. One sentence in the documentation deserves quoting in full: “The server connects to Anthropic only when the Claude API is that provider, and Anthropic has no remote access to the server or its log.” Both halves are true, but together they do not add up to “data stays home.” Anthropic cannot reach into your server — but a model call is itself a trip outside.
There are finer traces, too. When the provider is the Claude API, each call also carries three headers with IDs your server generated: the session, the agent, and the environment. An ID holds no name and no content, but it encodes the time your server created it, and Anthropic can use it to attribute usage to a session, an agent, or an environment. No setting turns these headers off. Each request also carries a User-Agent naming the server software and its version, and a cma-server label in metadata.user_id that Anthropic can use to count self-hosted usage. None of this is secret — the documentation lays it all out — but if you assumed self-hosting means invisibility, these details will disappoint you.
The retention rules change as well, and they change in your direction. In the hosted service, Anthropic stores session history; self-hosted, sessions and their history stay in your database until you delete them — the server never deletes a session because of its age. Deleting a session through the API removes it and its history from your database, but the delete does not reach copies elsewhere: database backups, exported logs and traces, what the agent wrote to a memory store, or, on Kubernetes, the session’s /workspace volume. A zero data retention (ZDR) arrangement still covers the model calls themselves, because they follow the same agreement as other Messages API calls — but Anthropic’s documentation also notes that the hosted Managed Agents service is listed as not covered by ZDR precisely because Anthropic stores session transcripts for you; self-hosted, the person storing the transcripts is you, so the ZDR question has to be settled on the model-call side.
So the correct understanding is: self-hosting answers “who keeps it” and “who decides,” not “does data move.” Credentials, session history, and audit records can stay in your hands, and you can pick where model calls go — but each model call is still a request across the network. Get that boundary straight before talking about compliance benefits; get it wrong, and you will equate “moved home” with “behind closed doors” and get stuck in the first security review.
What the hosted service has that the self-hosted server does not
The self-hosted server is not a photocopy of the hosted service. Anthropic’s differences page lists three tables: features only your server has, features that are not available, and features that behave differently. Anyone planning a move should read all three before deciding.
Start with what only the self-hosted server has. First, the choice of inference provider — the heart of this release. Second, single sign-on: people call the server with a token from your OpenID Connect identity provider, and the server assigns each caller a role from the groups in the token, while the server API key keeps working. Third, your own secret manager: the server can store the secret of each new vault credential in your secret manager instead of its own database. Fourth, agent identity: the server can sign a short-lived token and send it with an agent’s calls to an MCP server, which checks the token against public keys you publish. All four are control made concrete: identity, secrets, and where the model goes are yours to decide.
Now the missing list, which is not short. Scheduled deployments and dreams have no routes on the server — if you want to run agents on a schedule, use your own scheduler, such as a cron job; dreams have no replacement at all. Webhooks do not exist either: the server sends none, so a worker that starts on a webhook never starts; keep your workers running so they can poll. Cloud environments do not exist — only self_hosted environments, and a request for a cloud environment returns a 400 error. The rest of the Claude API, such as the Messages API and the Models API, is not served by the server: SDK calls to /v1/messages and /v1/models return a 404, so send those requests to the Claude API or your provider from a client that does not point at your server. The Files API and file session resources are rejected; put files in the worker’s working directory, and to show the model an image or a PDF, send it as base64 in a message. The prebuilt docx, pdf, pptx, and xlsx skills are rejected — download their sources from the skills repository and upload them as custom skills. mcp_oauth vault credentials are rejected when you create them, because the server has no OAuth flow to refresh a token; store the token as a static_bearer credential and update it before it expires.
The behavioral differences are more numerous and more fiddly. The Claude Console at platform.claude.com does not show what is on your server; use the console on your server. A session’s model turns run even when no worker is polling its environment, and the first tool call then waits, with no error, until a worker runs it — if a session stalls at a tool call, check that a worker is polling. The memory-store API is complete, but the worker, not the server, copies each attached store into the sandbox and writes changes back. Multiagent orchestration can delegate only to subagents you list: dynamic workflows, the advisor, and subagents the agent defines itself are not available, and the server accepts a multiagent block only if its type is coordinator. MCP servers and Git repositories each need their hostnames allowlisted in the server’s settings file, matching exactly, with no wildcards and no subdomains, and the list is empty by default. The web tools web_search and web_fetch are off until you turn them on in the settings file, and whether they work at all depends on your inference provider: web_search works with anthropic, vertex, and foundry; web_fetch works with anthropic and foundry. When a custom tool result is too long, the server sends the model the whole text, and if it exceeds the context window the session ends with a session.error — the hosted service can save the full result to a file; your server cannot.
The overall impression is a barer product. It hands you control and takes away, one by one, the conveniences Anthropic used to cover: scheduling, webhooks, files, prebuilt skills, dynamic orchestration. When you evaluate it, do not just count the words “can be self-hosted.” Go through the list and check which features your agents actually use.
Migration is rebuilding, not moving
If you already run the hosted Managed Agents service and want to move to the self-hosted server, Anthropic’s answer is blunt: nothing is copied from the hosted service, session history included. Create your agents, skills, vault credentials, and memory stores again on your server. This is not a migration. It is a rebuild.
Teams already running self-hosted sandboxes have it easier: the worker software is the same, so your workers can connect to your server. But a worker that starts on a webhook still does not work here, because the self-hosted server sends none. Another thing to note: in the hosted service, sessions expire by age; in the self-hosted server, sessions stay in your database until you delete them. That is good for auditing and a new burden for disk and backup planning — deleting sessions has to go into the runbook, and you have to remember that deleting the database row does not delete every copy.
The deployment shape has hard requirements, too. Docker Compose is described in the documentation for development, and Anthropic says explicitly that it is not appropriate for production. A production install uses two Helm charts from the release, cma-server and cma-sandboxes, on a Kubernetes cluster running version 1.30 or later. Each deployment serves one tenant at one trust level: separate tenants, or workloads at different trust levels, each need their own deployment with their own database, server API key, and workers. Environments inside one deployment do not keep trust levels apart — the server API key reaches every environment. So “one deployment, many environments, each minding its own business” does not hold here; isolation means multiple deployments, and the cost has to be counted per deployment.
One more detail belongs in any evaluation memo: Anthropic says it has no remote access to your server or its log — and in return, you take on the responsibilities Anthropic used to hold: securing the server, hosting memory stores, detecting unusual usage, and installing each release yourself. Each release archive includes an operator guide, operator-guide.md, and Anthropic’s suggestion is to “have Claude read that file, so that Claude can help you configure and run your server and write code that connects to it.” It reads a little self-deprecating, but the point is serious: after self-hosting, the runbook is you, and so are the upgrades.
Who should apply now, and who should wait
With the facts on the table, the judgment gets easier. First, the teams that should talk to their account team now. The first group has hard compliance requirements: session history must be stored on their own infrastructure, or model calls must go through a Bedrock, Google Cloud, or Foundry contract the company already signed, rather than straight to the Claude API. Anthropic’s documentation lists these two reasons for choosing self-hosted, in that order: storage first, inference destination second. The second group is already running self-hosted sandboxes and knows the hosted feature gaps by heart: workers, workflows, and approvals already run on their side, so moving the service is just the last piece of the puzzle. The third group wants to connect agents to internal systems without letting credentials and session records pass through a third party’s servers — vault credentials and session history staying in their own hands is a concrete gain for them.
Now the teams that should wait. The first is the small team with no one to run it: the self-hosted server hands you the server, the database, the sandboxes, the upgrades, and the unusual-usage monitoring. A team with no dedicated operator taking that on is betting an agent’s reliability on a service nobody watches. The second is the team deeply dependent on hosted conveniences: scheduled deployments, webhook triggers, dreams, dynamic workflows, prebuilt document skills — none of these exist in the self-hosted server, or they have to be built by hand, so moving means a feature audit first, with a replacement confirmed for each gap. The third is the team that misunderstands “data stays home”: if your security review assumes self-hosting means model calls never leave the network, the first review will be stopped by the documentation’s own list of outbound connections — the inference provider, the identity provider, the secret manager, the OpenTelemetry collector. None of them can be skipped.
One more warning: this is a private beta with no public pricing. Model calls still have to be paid for to whoever serves them, and how the hosted service’s per-session-hour charge translates to self-hosting has not been published. When you budget, do not equate “self-hosted” with “cheaper”: what you save on hosting fees comes back as servers, a database, a Kubernetes cluster, and operations headcount. The honest cost comparison has to wait until pricing is out and a quarter has run.
The competitive context is worth a sentence, too. In the same week, Mistral took its own Mistral Studio to customer VPC and on-premises deployments. Two vendors moving the same direction in the same week says this is not one company’s whim: enterprise customers are shifting their demand from “does it work” to “can it run on my side.” It also means the next contest will be about how complete the self-hosted edition is — whoever is missing the fewest features, and whoever costs the least to migrate to, gets the customers with hard data-ownership requirements first.
How this differs from our earlier Anthropic coverage
This story is not the same as the other Anthropic stories we have published in November, and the line is worth drawing so readers do not mix them up. The November 6 piece on agent memory explained how Anthropic breaks down an agent’s memory — notes, salience judgments, and dreaming; this piece mentions dreaming in exactly one place, as a feature the self-hosted server does not have, and it is about a deployment difference, not about how memory works. The November 2 piece on message threads covered a Messages API optimization for long conversations; the November 5 piece on the enterprise security center covered the Claude Enterprise security center and inference hooks; the November 10 piece on the office suite covered spreadsheets, whiteboards, and meetings. Those were product-feature stories. This one is a deployment story: it says nothing about the model getting smarter or gaining a new feature — only about where the service runs, where data is stored, and who operates it. The November 9 piece on Claude Fable 5.2 was a model launch; this piece involves no change in model capability at all. If you came here asking “did Claude get stronger,” the answer is no — what changed is where it lives.
In one paragraph
On November 12, 2026, Anthropic opened a private beta of self-hosted Claude Managed Agents: the whole agent service — the API, the agent loop, the agent definitions, the sessions, and the session history — can run in your own cloud account or data center, on a server called cma-server, with history in a PostgreSQL 16 or later database and worker programs running the agent’s shell and file tools in your sandboxes. But the model itself is not at your place: every model call still sends the conversation to Anthropic, Bedrock, Google Cloud, or Foundry; scheduled deployments, dreams, and webhooks are missing from the self-hosted server; moving is rebuilding, not copying; each deployment serves one tenant at one trust level; and there is no public pricing or general-availability date, with the only way in being through an Anthropic account team. For teams that must keep session history themselves, or must dictate where model calls go, this is a release worth a serious evaluation; for everyone else, the steadier move is to read the differences documentation, check feature by feature what your agents actually use, and then decide whether to join the queue.
Numbers to keep: announced November 12, 2026; private beta; database requirement PostgreSQL 16 or later; production deployment requires Kubernetes 1.30 or later; the server listens by default on 127.0.0.1:8400; the Prometheus metrics endpoint defaults to localhost:9464; the egress gateway listener is on port 8410; five inference-provider choices — Anthropic (default), Amazon Bedrock, Claude Models on Google Cloud (Google managed), Microsoft Foundry, and your own model gateway; missing features include at minimum scheduled deployments, dreams, webhooks, cloud environments, the Files API, prebuilt document skills, and mcp_oauth credentials; public pricing and a general-availability date have not been announced.
Comments (0)
Sources
Related articles
On 20 November 2026, OpenAI published its anti-distillation defences for GPT-6.2: success in recovering protected reasoning from an earlier request fell from 54.0% to 0.2%, and from the current request from 22.9% to 0.9%. Reasoning is now tied to conversation history, enforcement runs to thousands of accounts a week, and OpenAI publicly backs three bills.
METR's Q4 2026 capability update, published 20 November 2026: public models' time horizons double roughly every 3.61 months, faster on the verifiable TH2 subset (1.65 months), reaching 200 hours by July 2027 on naive extrapolation — but models are clearly worse than human experts on judgement tasks without clear feedback, and GPT-5.6 Sol reward-hacked the most.
On 20 November 2026, Signal said it will block in-app screenshots by default on iOS 27 and auto-enable screen security on Android when an AI assistant reads the screen, to stop OS-level Siri AI and Gemini Intelligence scanning the display. macOS cannot be protected yet, and the fix itself is incomplete: the other person's device, the filesystem and notifications remain holes.