CheinTian / notes
Clipping · 7 分钟

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#AI#agentic#agent-harness#agent-loop#managed-agents#LangChain#LangSmith#Deep-Agents#MCP#durable-execution#sandbox#production-ai#agent-orchestration#Anthropic#Vercel#AGENTS-md#Fleet#Eve#context-management

📝 摘要

Harrison Chase (@hwchase17) 发布 LangChain Managed Deep Agents，并论述了 Agent 构建的演进脉络：从早期 AI 框架（2022-2023 LangChain/ChatGPT/AutoGPT）到成熟框架（2024-2025 LangGraph/Google ADK/Vercel AI SDK），再到 Agent Harness（2025 Claude Code/Deep Agents），最终走向 Managed Agents——将 Agent harness 与基础设施打包的托管服务。文章指出，当 LLM 在循环中调用工具成为 Agent 的核心原语后，生产环境面临运行时、UX、沙箱、上下文管理、评估、记忆、认证七大挑战，而 Managed Agents 通过捆绑 harness + 基础设施解决了这些痛点。LangChain 的产品线从 Fleet（无代码）到 Managed Deep Agents（开发者友好），与 Anthropic Claude Managed Agents 和 Vercel Eve 形成竞争格局。

核心概念： Agent 构建正从"自建 harness + 自拼基础设施"走向"托管式 Agent 服务"，开发者只需提供业务逻辑（context、tools、instructions），基础设施由平台统一提供。

关键技术栈 / 关键要点：

  1. Agent 演进四阶段 — Early Frameworks → Mature Frameworks → Agent Harnesses → Managed Agents，每阶段建立在前一阶段的基础之上
  2. 核心原语 — LLM 在循环中调用工具（agent loop），是所有现代 Agent 的底层算法
  3. 两大关键学习 — 基础设施原语（durable execution、sandbox）和用户驱动标准（AGENTS.md、MCP、skills）共同催生了 Managed Agents
  4. 生产七大挑战 — Runtime、UX、Sandboxes、Context Management、Evaluation、Memory、Auth，是 Agent 从本地到生产的关键障碍
  5. Managed Deep Agents — LangChain 最新产品，基于 Deep Agents harness + LangSmith 基础设施，支持自定义 middleware 和代码工具
  6. "Agent as Files" — 将 Agent 定义表示为文件系统中的文件（AGENTS.md/skills/MCP），便于跨平台迁移和版本控制
  7. 竞品格局 — Claude Managed Agents（API-first，引入 dreaming）、Vercel Eve（文件驱动）、LangSmith Fleet（无代码），三者均采用相同标准但面向不同受众

关键结论 / 实践建议： 构建 Agent 时应聚焦业务逻辑，将基础设施（运行时、沙箱、认证等）交给托管服务；同时采用 AGENTS.md、MCP、skills 等开放标准，确保 Agent 可跨平台迁移，避免锁定。

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