lolspider / notes
Clipping · 6 分钟

Why managed agents are the next big thing in agent building

Today we’re launching Managed Deep Agents - the easiest way to build, run and deploy production agents. We have a full release blog and docs...

x.com @hwchase17
#clippings#agentic#managed-agents#agent-harness#Deep-Agents#MCP#AGENTS-md#LangChain#LangSmith#durable-execution#sandbox#production-ai#context-management#agent-infrastructure

📝 摘要

Harrison Chase（LangChain 联合创始人）宣布推出 Managed Deep Agents，并系统梳理了 Agent 构建的四个演进阶段：早期 AI 框架/App（2022-2023）→ 成熟 AI 框架（2024-2025）→ Agent Harness（2025）→ 托管智能体（Managed Agents，2026）。文章核心论点是：当 LLM 在循环中调用工具的能力成熟后，Agent 构建的主要瓶颈从"框架能力"转向"生产基础设施"，托管智能体将 harness 与基础设施打包，开发者只需提供业务逻辑，即可大幅降低部署门槛。

核心概念： Managed Agents = Agent Harness + 生产基础设施的打包服务，开发者只需提供业务逻辑（上下文、工具、指令），即可构建和部署生产级智能体。

关键技术栈 / 关键要点：

  1. Agent 构建四阶段演进 — 从早期框架到成熟框架到 Agent Harness 再到托管智能体，每一步都在解决上一层的瓶颈
  2. 生产级 Agent 的七大基础设施需求 — Runtime（持久化执行）、UX（事件流）、Sandboxes（沙箱）、Context Management（上下文管理）、Evaluation（评估）、Memory（记忆）、Auth（认证）
  3. Agent Harness 的核心设计 — "分离大脑与双手"（Separating brain and hands），LLM 在循环中调用工具，harness 提供工具与环境
  4. 标准化驱动 — AGENTS.md（基础指令）、MCP（系统集成）、Skills（渐进式上下文披露）三大标准使托管智能体成为可能
  5. 三大托管智能体产品对比 — LangSmith Fleet（无代码/非开发者）、Claude Managed Agents（API 优先/开发者）、Vercel Eve（文件驱动/开发者），Managed Deep Agents 是 LangChain 面向开发者的版本
  6. Agent 定义即文件 — Fleet 将 Agent 定义为文件系统中的文件，所有标准（AGENTS.md/skills/MCP）都映射为文件，便于在代码和 UI 之间切换

关键结论 / 实践建议： 托管智能体将释放新一轮生产级 Agent 构建浪潮，开发者应关注 AGENTS.md + MCP + Skills 三大标准，优先选择 harness + 基础设施打包的方案，而非自行组装。

Today we’re launching Managed Deep Agents - the easiest way to build, run and deploy production agents. We have a full release blog and docs if you want to read more. In this article I want to talk about the journey to get here and why I’m so excited about what I think is the next step of agent building.

I think there are a few distinct periods of agent building.

Briefly covering two of the earlier ones:

Sometime in early to mid 2025 the models started to get good enough to power what we think of agents today: LLMs running in a loop calling tools. This is the core primitive, the core algorithm, that underpins agents today. Really early agent apps like Manus, Deep Research, and Claude Code followed this same pattern.

When the models became good enough to just run in a loop and call tools, this became a more solid foundation we could build upon. The concept of Agent Harnesses like Claude Code, Pi, and Deep Agents emerged as we figured out the rights tools and environments to add into this loop. We launched Deep Agents nearly a year ago - one of the first attempts to take some of the patterns we saw in the application layer and bring them to a general use harness.

Over the past year, there have been two set of learnings that have shaped the next direction.

First, we started to learn some of the common primitives for running these agent harnesses at scale. Things like durable execution to back the running of the agent loop, and sandboxes for running untrusted code. “Separating the brain and hands” became a common design choice. The infrastructure required for running these agents started to become more known.

Second, standards for how users should drive these agent harnesses emerged. Things like AGENTS.md for base set of instructions, MCP for plugging into other systems, skills for progressive disclosure of context. These became standards to control and drive parts of harnesses.

Both of these contributed to the rise of “managed agent” experiences. Where the agent harness is run on managed infrastructure, and builders use these standards to drive agent behavior.

I think these managed agent experiences will unlock a new wave of building production agents. When building agents, there are three parts:

  1. The business logic (context, tools, and instructions) you provide
  2. The harness
  3. The infrastructure to run the harness in production

You always need to bring your own business logic. Off-the-shelf harnesses like Deep Agents have made it easier to get started. But there’s lot of challenges you face when trying to run an agent in production!

  • Runtime: How do I run it in a reliable way? How do I resume a run if it fails halfway through?
  • UX: How do I stream events back to a UI? How do I bring my agent to where users already are?
  • Sandboxes: Where does untrusted code execute?
  • Context Management: Where do instructions, skills, and other context live? Can I have business users (or subject matter experts) edit them directly?
  • Evaluation: How do I evaluate changes to prompts, tools, or models?
  • Memory: What does the agent remember?
  • Auth: Who is allowed to call it, and what are they allowed to do? When the agent calls external systems, who does it act as?

These are a lot of different considerations! Managed agent services make a lot of this easier, by bundling the harness with the infrastructure. This makes it much easier for builders - rather than Having to pick a harness and then assemble all these pieces individually, they just pick a bundle of the harness and infrastructure. Much easier!

One early version of this that we worked on was Fleet - our no-code agent building platform. This pushed the “managed” aspect to the extreme - Fleet is built for non-developers and is purely UI based. We used standards like AGENTS.md, skills, and MCP to make it easy to port agents back to code if needed.

One thing we purposefully did here - we represented and defined Fleet agents just as files in a filesystem. All the standards above - those just became files that our harness would load. We even had a toggle to show Fleet agents in a file explorer.

This targeted a bit of a different audience for us - non developers. Because it was so “managed”, and because our target audience is largely developers, we kept on getting more and more technical feature requests: custom middleware, custom tools as code, programmatic creation of agents from the API.

Claude Managed Agents was launched a little after this. It also had a UI based experience, but more so was API first, which targeted developers much more. It made it super easy to create agents via an API, and used a lot of the same standards. It relied less on treating the agent definition as just files in a filesystem. It introduced some cool concepts like “dreaming”.

Vercel launched Eve a month or so as another entry here. It very much leans into representing agents as files, uses a lot of the same standards, and bundles up infrastructure to make it easy to deploy.

Today we’re launching our version of managed agents meant for developers: Managed Deep Agents. It builds upon the Deep Agents harness, represents agents as files, but allows for a lot more configurability than Fleet: you can bring custom middleware and custom tools as code. It bundles in infrastructure to make it easy to run agents in production:

This is one of the launches I’m most excited about in a while. I think it will make it so much easier for developers to build and deploy agents in production, not just run them locally.

If you want to get started, I filmed a "Managed Deep Agents explained in 20 minutes" video that I think is the best place to get started.

I also think it is still early when it comes to building agents. More infrastructure requirements will emerge. More standards will be needed. We want to learn those and build those with you, so please reach out with feedback.

返回 Clippings