Original Title: Launching Claude Managed Agents
Original Author: Lance Martin
Translated by: Peggy, BlockBeats

Editor's Note: This article introduces the Managed Agents launched by Claude. It offers a software form closer to the future: agents are no longer one-time response interfaces, but execution systems that can be configured, deployed, scheduled, and run for a long time.

By completely decoupling "intelligence" (models and runtime frameworks), "execution" (tools and sandboxes), and "process" (sessions and logs), Claude Managed Agents transform agents from "logic in code" into independent infrastructure units. This design not only enhances the stability and security of the system in long-duration tasks, but also enables agents to continuously scale as model capabilities evolve, free from the constraints of existing frameworks.

Under this framework, common usage patterns also change: from event-triggered and scheduled runs to "trigger and deliver" automatic execution, and to complex tasks spanning days or even weeks, agents begin to truly possess the ability to "work continuously." This means that the value of AI is no longer solely reflected in the quality of single answers but in its ability to accumulate and compound over time.

If past APIs allowed developers to "call intelligence," then Managed Agents are trying to answer another question: how to make intelligence a system that can be hosted, scheduled, and run continuously. In this sense, agents are no longer just tools, but are closer to a new computational primitive.

The original text is as follows:

TL;DR

Claude Managed Agents are a set of pre-built, configurable agent runtimes (agent harness) operating on hosted infrastructure. You only need to define an agent as a template—including tools, skills, file/code repositories, etc.—while the rest of the runtime framework and infrastructure are provided by the system. This system is designed to keep up with the rapid growth of Claude's intelligence levels and to support long-duration tasks.

Claude Managed Agents

Why Claude Managed Agents Are Needed

Claude's messages API essentially serves as an entry point for direct interaction with the model: input messages return content blocks. Agents built on the messages API require a "runtime framework" (harness) to manage tool invocation routing, context management, and other tasks. However, this brings several issues:

1. The runtime framework needs to continually keep pace with Claude's capability evolution
I recently wrote a blog detailing how to build agents based on the underlying capabilities of the Claude API for handling tool orchestration and context management. The issue is that the agent's runtime framework often implicitly assumes certain "limitations" of Claude. As Claude's capabilities improve, these assumptions quickly become outdated and even turn into performance bottlenecks. Therefore, the runtime framework must be continuously updated to keep up with Claude's evolution.

2. Claude's task cycles are becoming longer
The time span of tasks that Claude can handle is growing exponentially; in the METR benchmark tests, it has exceeded a human workload of over 10 hours. This poses higher demands on the underlying infrastructure of agents: it must possess security, stability during long-running operations (to cope with various infrastructure failures), and scalability (such as supporting multiple agent teams running concurrently).

Why These Issues Matter

Addressing the above challenges is crucial, as we anticipate that future Claude will be able to continuously operate and tackle the most complex human problems on time scales of days, weeks, or even months.

The Claude Agent SDK is the first step in this direction, providing a universal, user-friendly agent runtime framework. Claude Managed Agents represent a further evolution: built on this foundation, they offer a complete runtime framework + hosted infrastructure, specifically designed to support the safe and reliable execution of tasks over extended time periods.

How to Get Started

A simple way to get started is by using our open-source claude-api skill, which works out of the box in Claude Code. You just need to install the latest version of Claude Code and then run the following sub-command to complete the initialization configuration of Claude Managed Agents.

I am personally optimistic about the way "skills" introduce new functionalities and I have extensively used this skill in practice.

Additionally, you can refer to our documentation to quickly get started via the SDK or CLI, and prototype agents in the Claude Console.

Usage Scenarios

You can see many interesting cases on the official Claude blog. Combining these cases with my own practice, I have observed some common usage patterns:

1. Event-triggered
Managed Agent executes tasks triggered by a service.
For example, when the system detects a bug, it automatically invokes a hosted agent to write a fix patch and submit a PR. No human intervention is needed between "issue flagged" and "execute fix."

2. Scheduled
Set scheduled tasks for Managed Agents.
For example, many people, including myself, use this method to generate daily summaries (such as summary updates from platform X or GitHub, or progress reports from a team of agents). Below is an example of a daily summary of X events that I use regularly.

3. Fire-and-forget
Managed Agent is triggered by humans to execute tasks, but continuous participation is not required. For instance, assigning tasks to hosted agents through Slack or Teams, they will automatically complete the task and return results (such as tables, slides, or even applications).

4. Long-horizon tasks
Long-running tasks are one of the scenarios where I believe Managed Agents are particularly valuable.
I have conducted some experiments based on Andrej Karpathy's auto-research repo to explore different application methods. For example, I recently used _chenglou's pretext library as input and let a Managed Agent study how to apply it to our engineering blog content.

Core Concepts

During the getting started process, there are three core concepts to understand:

1. Agent
A version-controlled configuration that defines the agent's "identity": including the model, system prompt, tools, skills, MCP server, etc. Once created, it can be repeatedly called using its ID.

2. Environment
A template that describes the sandbox environment provided for the agent's tool operations (such as runtime types, network policies, dependency package configurations, etc.).

3. Session
A stateful execution instance launched based on the pre-created agent configuration and environment. It will generate a completely new sandbox from the environment template, mount the necessary resources for this execution (such as files, GitHub repositories), and securely store authentication information in the vault (such as MCP credentials).

It can be understood as follows:

·Agent = configuration itself

·Environment = sandbox template required for agent operation

·Session = a specific execution process

One Agent can correspond to multiple Sessions.

Usage Methods

For specific details, refer to the documentation. Overall, usage is divided into two categories:

1. SDK (code-oriented)
Integrate the SDK into the application to drive sessions at runtime. Currently, six languages support Managed Agents: Python, TypeScript, Java, Go, Ruby, PHP.

2. CLI (terminal-oriented)
Operate all API resources via the command line, including agents, environments, sessions, vaults, skills, files, etc. Each resource type has corresponding subcommands.

Common practice modes:
Typically, use CLI to complete configuration and initialization, and SDK to handle runtime logic.
Agent templates are persistent—you can create a template (for example, define model, system prompt, tools, MCP server, skills using YAML), store it in Git, and apply it in the deployment process via CLI.

How It Works

I and @mc_anthropic, @gcemaj, @jkeatn wrote an Engineering blog for Anthropic detailing the construction process of Claude Managed Agents. An important conclusion in the article is that enabling agents to scale with Claude's intelligence levels is essentially an "infrastructure problem," rather than just a runtime framework (harness) design issue.

This means that the real challenge is not about "how to write a smarter agent," but about how to build a system that can operate stably and sustainably for a long time, is scalable and evolvable, allowing agents to handle increasingly complex and long-term tasks.

Based on this idea, we did not design a fixed agent runtime framework (harness), as we expect it to continuously evolve. Instead, we decoupled several key parts of the system:

"Brain" (Claude and its runtime framework)

"Hands" (sandbox and tools for performing specific operations)

"Session" (event logs recording the execution process)

These three are designed as independent interfaces with minimal assumptions about each other. Each part can fail or be replaced independently without affecting the overall system.

We also share how this architecture brings higher reliability, security, and flexibility—while reserving space for future integration of new runtime frameworks, sandboxes, or infrastructure to host sessions.

Conclusion

I am very excited about projects exploring multi-agent orchestration or long-duration tasks. One of the issues that has always troubled me in the past was that the runtime framework for agents struggled to keep up with the evolution of model capabilities.

Claude Managed Agents matter because they handle the issues of runtime frameworks and infrastructure layers for you, allowing you to focus your efforts on a higher level—treating the "agent" itself as a new foundational primitive in the Claude API, enabling more exploration and construction on top of that.

[Original link]

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。

Transform AI into a personal execution system, Claude's latest Managed Agents Practice Manual.