Anthropic's Managed Agents: What Makes Them Different

Anthropic has released Claude Managed Agents, and the timing is interesting. The company recently blocked third-party tools like Open Claude from using Claude Pro subscriptions—a move that makes more sense now. This isn't just another agent builder. It's a bet on infrastructure.

The Better Stack team walked through building a medical information agent that connects to Slack. The setup process reveals something worth examining: you can create a functioning agent by describing what you want in plain English. The system handles the architecture, the security, the scaling. You describe the problem; Anthropic provides the plumbing.

The demonstration involved connecting to a private GitHub repository containing NHS medical data, processing that information, and making it queryable through Slack. The creator described it as choosing between Linux and Apple: "Open Claude is a tinkerer's agent. You pick your own hardware, you pick your own model, you deal with security and everything in between. Whereas, Claude managed agents is, dare I say it, like Apple because you don't need to do any of those things."

That analogy captures the trade-off, though it raises questions about where the industry is headed.

The Architecture Question

What makes this approach different is the separation of concerns. Anthropic built the system around three components: the harness, the session, and the orchestrator. The harness routes tool calls and executes code. The session maintains append-only logs—essentially the system's memory. The orchestrator decides what mode the harness should operate in and spins up new harnesses if one fails.

This matters because it addresses the production problem most agent frameworks ignore. When a process fails, the new harness reads the session logs and continues from where the previous instance stopped. The architecture assumes failure and designs around it.

The security model is equally considered. Credentials live in a separate vault and get called at runtime. The harness never sees API keys—it just calls tools that use them. The model doesn't even know its own Anthropic API key. This separation means a compromised agent can't leak credentials it never possessed.

These are solved problems in traditional software infrastructure. Anthropic is applying them to agent systems, which says something about where they think this technology is going: production environments, not demos.

The Pricing Reality

Here's where it gets complicated. Managed Agents don't use your Claude Pro subscription. You pay for tokens at API rates, plus eight cents per session hour while the agent is active. The creator noted this limitation: "As someone who is a Claude Pro subscriber, I would love to use my limits, so the limits that are within the Pro range on managed agents so I don't have to pay for two different things."

This creates an odd bifurcation. If you're a Pro subscriber who wants to experiment with agents, you're maintaining two separate billing relationships with the same company. Anthropic likely has reasons for this—API pricing reflects different cost structures, and managed infrastructure isn't free—but it fragments the user experience.

The demonstration showed costs could be reasonable with cheaper models like Sonnet or Haiku. But "reasonable" depends on use case and volume, neither of which you can fully predict when building something new.

What Gets Lost

The video creator pointed out a constraint: "If you want to create something that doesn't exist within those bounds, then you just have to go ahead and write your own code, which Open Claude is very good for. I mean, Open Claude is super open, it's in the name, and has many channels from Telegram to Discord to WhatsApp."

Managed Agents currently support a curated set of integrations—Notion, Slack, and various MCP services. If you want to connect to something else, you're writing custom code, which defeats the no-code promise. This is the classic platform dilemma: either you provide infinite flexibility (and complexity) or you curate carefully (and limit use cases).

The medical agent demonstration worked because it fit within the supported boundaries. A private GitHub repo, Slack integration, file reading tools—all available out of the box. But projects that need unusual integrations or custom protocols will hit the edges quickly.

The Pattern

I've watched this movie before. In 1995, people promised that visual development tools would eliminate programming. They didn't—they created a new category of developers who worked at a different abstraction level. Some problems suited visual tools perfectly. Others required dropping down to code.

Managed Agents will likely follow a similar path. For certain classes of problems—connecting standard services, processing structured data, handling routine queries—they'll work remarkably well. For edge cases and novel integrations, developers will still need the underlying SDK.

The question is how large that first category becomes. If most business problems fit within the curated boundaries, Managed Agents could succeed broadly. If most problems require customization, it becomes a niche tool.

The architectural decisions suggest Anthropic is building for scale and durability. Whether the market wants a managed agent platform—and whether businesses will pay for the convenience—remains open. The creator believes "this is going to stick around for a long time purely because it's very easy to create an agent." Maybe. Ease of creation matters less than usefulness of result, and we're still early in understanding what problems agents actually solve reliably.

What's certain is that someone will eventually get this right. Whether it's Anthropic, or someone building on their infrastructure, or an entirely different approach, the demand for simpler agent development is real. This is one attempt to meet it.

—Bob Reynolds, Senior Technology Correspondent