Anthropic’s November 12 release notes introduce self-hosted Claude Managed Agents: teams can run the full agent service and store agents, sessions and history on their own infrastructure. Model requests still go to an inference provider, with Anthropic as the default. Access is requested through the Anthropic account team. The launch changes where the service runs; it is not an announcement of local Claude model weights.
This is a useful option when the location of session storage or the route used for model calls is a real requirement. It also creates an operating commitment. Before choosing it, separate the part you need to control from the parts you are willing to maintain. A team that only needs tools inside its own network may have a narrower option than running the entire service.
- 01The service moves tooFull self-hosting includes the agent service and stored session state, beyond the earlier self-hosted sandbox option.
- 02Inference remains a separate boundaryThe chosen model provider still receives model requests; local storage does not mean all processing stays local.
- 03Feature parity needs checkingThe self-hosted service has documented differences, including migration and integration limitations.
- 04Operations become part of the productBackups, upgrades, access, isolation and incident response need owners before a production rollout.
01 — Hosting choicesDistinguish the service from its workspaces
Anthropic’s self-hosted overview separates the service from sandboxes. The service runs the agent loop and stores session state; a sandbox is where tools execute commands and work on files. Self-hosted sandboxes leave the service with Anthropic. Full self-hosting moves both to your infrastructure while retaining a separate inference provider.
That distinction should drive the first architecture conversation. Suppose an agent must run a build tool inside a company network. The requirement concerns tool execution and network access. It does not automatically establish that the company also needs to operate session storage and the agent API. If the company must control that stored history, the larger hosting option becomes relevant.
The existing self-hosted sandbox guide covers the narrower execution choice. Begin with a written requirement such as where a workspace must run or where session history must be stored. “We want control” is too vague to select an architecture, because each form of control transfers a different maintenance responsibility.
| Option | Service and session storage | Tool workspaces |
|---|---|---|
| Hosted default | Anthropic | Anthropic |
| Self-hosted sandboxes | Anthropic | Your infrastructure |
| Self-hosted Managed Agents | Your infrastructure | Your infrastructure |
02 — Data boundariesFollow the request beyond the database
Anthropic’s data and access documentation says a model call sends the conversation, including tool inputs and results, to the inference provider. The default provider is the Claude API. A different configured provider changes that destination; it does not eliminate the need to understand what the request contains.
Consider a hypothetical agent reviewing an internal report. The report may be stored in your database or workspace, but a tool can return an excerpt into the conversation. That excerpt can then become part of the next model request. Saying that the original file stayed on a company disk would not fully describe the processing. Map the content that crosses each boundary, not just the location of the first copy.
This is a practical design question rather than a reason to reject the product. A business may approve a particular provider and limit the information sent to it. It may also choose a workflow that extracts only the relevant fields before the model call. The architecture should make that decision visible and testable, with a clear owner for the provider configuration and the data included in tool responses.
For one representative task, list the source file, tool output, conversation context, model request and retained result. That sequence reveals more than a diagram that labels the database “local.”
03 — Operating scopeBudget for a service that someone must run
The overview identifies a server, database and workers as parts of the deployment. It specifies PostgreSQL 16 or later; without a database, state is held in memory and lost on restart. Those details matter because a quick demonstration can appear successful before persistence, recovery and maintenance have been designed.
A production decision should name who operates the database, who deploys updates and who investigates a stalled session. The cost is not just the compute line on an invoice. Include monitoring, backup storage, recovery exercises, release testing and the time needed to keep the environment compatible with the application. This article does not claim a published self-hosting price or a measured savings figure.
Use an ordinary business scenario to test the ownership model: the agent is halfway through a permitted document task when a server restarts. Can the team determine the state of the work, avoid repeating an external action and give the user a truthful status? If the answer depends on one developer remembering a command, the deployment needs more operational work before it becomes a dependable service.
Keep useful state
Decide what must survive a restart and verify a restore into a safe environment. A backup that has never been restored leaves an important question unanswered.
Keep work moving
Monitor whether permitted tasks can actually run and finish. A responsive API does not prove that its execution workers are healthy.
Keep changes reviewable
Test the application against a candidate release and preserve a recovery route. Treat an upgrade as an operating change with evidence.
04 — Feature gapsCheck the workflow before planning a migration
Anthropic’s differences page says hosted resources and session history are not copied automatically. It also lists unavailable hosted features, including webhooks, the Files API and prebuilt document skills. The API similarity is useful, but it should not be read as a promise that an existing application can move unchanged.
Inventory the features your workflow actually uses. If it starts workers from a webhook, missing webhooks affect execution rather than merely a reporting preference. If it depends on a file-upload path, the file movement needs a supported replacement. A migration estimate should include these changes before somebody commits to a cutover date.
The earlier Managed Agents update describes capabilities of the hosted product. Read it as background, then check the self-hosted differences for the version being evaluated. A feature available in the hosted service is not automatically available in the service you operate. Test the full business journey instead of confirming only that an agent can be created.
| Dependency to inspect | Migration question | Evidence to require |
|---|---|---|
| Existing session history | What must be retained or recreated? | A documented preservation decision |
| Webhook-driven work | How will workers receive and track tasks? | A successful end-to-end test |
| File handling | How will authorised content reach the workspace? | Correct access and a usable result |
| Document skills | Which supported skills must be supplied? | A verified representative document |
05 — IsolationGive workers only the access their work requires
The overview warns that the agent’s shell uses the worker process’s permissions and network access. Isolation comes from the environment around the worker. A familiar command-line interface should not obscure that boundary: a process with access to valuable files or credentials can use that access, even if the intended task is modest.
For a hypothetical code-review pilot, use a disposable workspace with a copy of the required repository and narrowly scoped credentials. Separate the permission to inspect code from the permission to publish a release or modify a live system. Test the behavior with a harmless out-of-scope request so the team knows whether the surrounding controls enforce the intended boundary.
The data and access documentation also treats a deployment as one trust level; environments are not a substitute for tenant isolation. A company serving unrelated customers should therefore resolve the separation design before placing them in one installation. A convenient environment label is not evidence that one customer cannot affect or access another customer’s work.
Ask what the worker could reach if a task or retrieved document supplied a misleading instruction. Reduce that reachable surface to what the approved workflow actually needs.
06 — RetentionInclude logs and backups in the data decision
Keeping the primary database under your control makes retention a responsibility you can act on, but it does not make every copy disappear when one record is deleted. Anthropic’s data documentation distinguishes session deletion from copies that may remain in logs, backups or workspace storage. An operational retention plan has to include those locations.
For a document-processing workflow, write down what is retained after completion and why. A short-lived workspace may not need to preserve the original document once the approved result has been handed back. Diagnostic logs may need enough information to investigate a failure without duplicating the whole document. The appropriate choices depend on the business requirement; the important point is to make them explicit.
Test the deletion path with synthetic information before making a customer-facing promise. Confirm who can access the backups and whether restoring one reintroduces data that was intentionally removed. These are proposed acceptance checks, not legal conclusions or a claim that the platform supplies a complete retention policy automatically.
A useful retention map includes the database, workspace, application logs, telemetry and backups. Assign a policy and an owner to each rather than relying on a single delete button.
07 — Pilot designProve recovery as well as a successful answer
A self-hosted pilot should exercise the conditions that make the hosting choice valuable. If the requirement is control over session storage, verify where the records are written and who can access them. If the requirement is a particular inference route, inspect the configured destination and approved request content. A polished answer proves neither of those architectural properties.
Include an interrupted task, unavailable worker, rejected credential and provider failure in the acceptance plan. Keep the tests safe and isolated. The desired result may be a clear error with preserved state, rather than automatic recovery at any cost. For a workflow that can make external changes, verify how repeated attempts avoid duplicating the action.
The agent evaluation guide helps frame the difference between evaluating an answer and evaluating a complete run. Record both. A model can reason correctly while the application loses its result, and a healthy service can faithfully deliver an incorrect conclusion. The production decision needs evidence about the workflow as a whole.
Demonstrate one useful task, one expected failure and one recovery path. Keep the evidence small enough that the operational owner can explain what happened and why.
08 — Architecture decisionChoose the smallest hosting commitment that fits
Full self-hosting is most persuasive when the service boundary itself solves a requirement: control over stored agent history, an approved inference route or a deployment arrangement the organisation can operate. If the only need is to run tools in a private workspace, compare the narrower sandbox option before accepting the broader maintenance commitment.
Write a short decision record with the requirement, the chosen boundary, known feature differences, operating owners and the evidence still needed before launch. Include a fallback if the pilot shows that a missing capability is essential. This makes a later review possible without reconstructing the reasoning from a collection of product announcements.
AI transformation work should connect this architecture to a useful business process and the people responsible for it. The right outcome may be full self-hosting, self-hosted execution only or the hosted service. The decisive question is which option satisfies the requirement with a level of operational responsibility the team can reliably carry.
Name the requirement that the larger hosting boundary solves. If it cannot be stated clearly, settle that question before building an installation that someone will have to maintain.
Draw the boundary and assign its owner
Self-hosted Claude Managed Agents gives teams control over more of the service, while keeping inference as a separate provider relationship. Choose it when that control answers a concrete requirement. Before production, verify the data path, required feature support and recovery behavior, and make the operating responsibilities as explicit as the architecture.