Managed Deep Agents is now in Public BetaManaged Deep Agents 现已进入公测阶段

Deep Agents is an open source agent harness you can ownDeep Agents：一款您可以自主掌控的开源代理框架

We built Deep Agents around a pattern we kept seeing in useful agents. Agents often need to:我们在构建 Deep Agents 时，参考了高效代理中常见的模式。代理通常需要完成以下任务：

• Call tools调用工具
• Have somewhere to keep working files拥有存储工作文件的空间
• Manage growing context over long runs在长时间运行中管理不断增长的上下文
• Needs to delegate work to subagents将工作委派给子代理
• Load domain-specific skills加载特定领域的技能
• Pause for human approval before taking sensitive actions.在执行敏感操作前暂停以等待人工审批

You can build all of that yourself on top of a lower-level framework, but the pattern is common enough that it should be available as a reusable harness that companies can own and control. Deep Agents is that harness. It's open source and model agnostic, allowing you to bring your model, your instructions, your tools, and your business logic.虽然您可以在底层框架之上自行构建所有这些功能，但这种模式非常通用，理应作为一种可复用的框架供企业直接使用和掌控。Deep Agents 正是为此而生。它是开源且模型无关的，允许您自由选择模型、指令、工具和业务逻辑。

Managed Deep Agents helps you take the harness to productionManaged Deep Agents 助您将框架顺利推向生产环境

Deep Agents makes it easier to build capable agents. Managed Deep Agents makes it easier to run those agents in production.Deep Agents 让构建功能强大的代理变得更简单，而 Managed Deep Agents 则让这些代理在生产环境中的运行变得更轻松。

It handles the production infrastructure that’s costly to build and maintain, while keeping the parts that make your agent unique in your control. That means you can spend your time on the agent's behavior, including prompts, tools, middleware, identity rules, evals, and domain logic instead of rebuilding the same infra that every agent requires:它负责处理那些构建和维护成本高昂的生产基础设施，同时让您保留对代理核心特性的控制权。这意味着您可以将精力集中在代理的行为上（如提示词、工具、中间件、身份规则、评估和领域逻辑），而无需重复构建每个代理都必需的基础设施：

• Durable execution so long-running agents can pause, retry, and resume without losing work持久化执行：确保长时间运行的代理可以在不丢失工作进度的情况下暂停、重试和恢复
• Streaming so users can see progress while the agent is working流式传输：让用户能够实时查看代理的工作进度
• Persistence so thread state survives across turns, restarts, and failures持久化存储：确保线程状态在多轮对话、重启和故障后依然存在
• Sandboxes so agents can work with files, run code, and use CLIs in isolated environments沙箱环境：使代理能够在隔离环境中处理文件、运行代码和使用 CLI
• Evals so teams can test behavior, tool use, and state changes before and after deployment评估机制：助力团队在部署前后测试行为、工具使用和状态变更
• Channels so agents can meet users in tools like Slack多渠道支持：让代理能够接入 Slack 等工具与用户互动
• Memory so agents can carry durable context and preferences across conversations记忆功能：让代理在不同对话间保持持久的上下文和偏好设置
• Identity so agents can act with the right user context and access boundaries身份验证：确保代理在正确的用户上下文和访问边界内执行操作

A Managed Deep Agent is a code-first project in your repo. It allows you to easily organize all your agent’s primitives into a simple directory:Managed Deep Agent 是您代码仓库中的一个以代码为优先的项目。它允许您轻松地将代理的所有原语组织到一个简单的目录中：

my-agent/
  agent.py | agent.ts | agent.tsx
  pyproject.toml | package.json    # project dependencies
  instructions.md                  # prompt synced to Context Hub
  identity.py | identity.ts        # auth, thread scoping, memory scoping
  memory.py | memory.ts            # define your agent's memory
  tools/                           # custom tools
  channels/                        # entry points like Slack and GitHub
  middleware/                      # custom middleware
  schedules/                       # managed cron schedules
  connectors/                      # managed cron schedules
  skills/                          # skills synced to Context Hub
  sandbox/                         # sandbox configuration
  evals/                           # agent evals

Once you author your project and run mda deploy , Managed Deep Agents compiles the project, syncs deploy-owned context to LangSmith Context Hub, uploads the build, and creates a hosted LangSmith deployment.完成项目编写并运行 mda deploy 后，Managed Deep Agents 会编译项目，将部署所需的上下文同步到 LangSmith Context Hub，上传构建版本，并创建一个托管的 LangSmith 部署。

Here's what MDA looks like:MDA 的结构如下所示：

Built on top of LangSmith Deployment基于 LangSmith Deployment 构建

Most production infrastructure assumes short-lived, stateless requests. Agents often break both assumptions. Agents often run for minutes, hours, and even days. It may need to pause for approval, resume after a user replies, stream progress while it works, and recover from infrastructure restarts without losing state. It may need durable threads, persistent memory, cancellation, retry behavior, and traceability across model calls, tool calls, files, errors, and runtime state.大多数生产基础设施都假设请求是短生命周期且无状态的。但代理往往会打破这两个假设。代理的运行时间可能长达几分钟、几小时甚至几天。它可能需要暂停以等待审批，在用户回复后恢复工作，在运行过程中流式传输进度，并在基础设施重启后从故障中恢复而不丢失状态。它可能需要持久化线程、长期记忆、取消机制、重试行为，以及跨模型调用、工具调用、文件操作、错误处理和运行时状态的全面可追溯性。

Building this infrastructure from scratch can take months or even quarters, and it has to be maintained. Durable execution, streaming, human approval, auth, scheduling, and conversation state all introduce edge cases around persistence, retries, timeouts, and reliability that directly impact user experience and agent usefulness.从零开始构建这些基础设施可能需要数月甚至数个季度，而且还需要持续维护。持久化执行、流式传输、人工审批、身份验证、调度和对话状态等功能，在持久化、重试、超时和可靠性方面都会引入各种边缘情况，直接影响用户体验和代理的实用性。

Managed Deep Agents is built on the same LangSmith Deployment Agent Server that teams already use to run agents in production. It packages the operational patterns required for product agents into a more opinionated runtime for Deep Agents.Managed Deep Agents 基于团队现已用于生产环境的 LangSmith Deployment Agent Server 构建。它将生产级代理所需的运维模式封装成更具规范性的 Deep Agents 运行时。

That gives you production primitives out of the box:这为您提供了开箱即用的生产原语：

Sandboxes for code execution and filesystem work用于代码执行和文件系统操作的沙箱

Many useful agents need an isolated working environment to inspect files, write outputs, run tests, install dependencies, call CLIs, or execute code securely.许多实用的代理需要一个隔离的工作环境来检查文件、编写输出、运行测试、安装依赖、调用 CLI 或安全地执行代码。

Deep Agents supports sandbox backends for this kind of work. We have built first class support for LangSmith Sandboxes for Managed Deep Agents.Deep Agents 为此类工作提供了沙箱后端支持。我们已为 Managed Deep Agents 构建了对 LangSmith 沙箱的一流支持。

You configure a sandbox in just a few lines of code:您只需几行代码即可配置沙箱：

from managed_deepagents import define_sandbox
 
sandbox = define_sandbox(
    provider="langsmith",
    scope="thread",
)

By default, each durable thread gets its own sandbox. That works well for agents that need an isolated workspace per user conversation or task, such as a coding agent. You can also set the scope to agent when the agent process should share one sandbox across threads.默认情况下，每个持久化线程都会获得自己的沙箱。这对于需要为每个用户对话或任务提供隔离工作区的代理（如编程代理）非常有效。当代理进程需要在多个线程间共享同一个沙箱时，您也可以将范围设置为 agent。

Managed Deep Agents gives agents a controlled place to work without making you manage sandbox provisioning, lifecycle, and cleanup yourself. Sandbox activity is traced to LangSmith , so you can inspect what happened when a run succeeds or fails.Managed Deep Agents 为代理提供了受控的工作空间，无需您亲自管理沙箱的配置、生命周期和清理。沙箱活动会被追踪到 LangSmith，因此您可以在运行成功或失败时检查具体发生了什么。

Harbor evals without the setup work无需繁琐设置即可使用 Harbor 进行评估

Verifying agent behavior requires more than evaluating just a prompt and expected answer. You need to check what actions the agent took along the way to get to the final answer. That's where evals come in. For example:验证代理行为不仅仅是评估提示词和预期答案，您还需要检查代理在得出最终答案过程中所采取的操作。这就是评估（evals）发挥作用的地方。例如：

Did it call the right tools? Did it edit the right files? Did it create the expected artifact? Did the final workspace state match the task? For code and file-based agents, those state-based checks are often more useful than only scoring the final message.它是否调用了正确的工具？是否编辑了正确的文件？是否创建了预期的工件？最终的工作区状态是否符合任务要求？对于代码和基于文件的代理，这些基于状态的检查往往比仅对最终消息评分更有价值。

Managed Deep Agents uses Harbor for this workflow. Harbor tasks give the agent an instruction, run it in an isolated environment, and grade the resulting files or state with a verifier.Managed Deep Agents 在此工作流中使用 Harbor。Harbor 任务为代理提供指令，在隔离环境中运行，并使用验证器对生成的最终文件或状态进行评分。

The hard part is usually packaging your agent so Harbor can run it. Managed Deep Agents handles this packaging for you, in just a few short terminal commands:通常最困难的部分是将代理打包以便 Harbor 运行。Managed Deep Agents 通过几条简单的终端命令为您处理了这种打包工作：

mda evals init
mda evals compile

mda evals init creates checked-in Harbor tasks under evals/. mda evals compile builds a Harbor handoff under .mda/evals/, including the compiled agent artifact, the adapter Harbor uses to run the agent, and an example Harbor job config.mda evals init 可在 evals/ 下创建已签入的 Harbor 任务。mda evals compile 则会在 .mda/evals/ 下构建 Harbor 交付包，包括已编译的代理工件、Harbor 运行代理所需的适配器以及示例 Harbor 作业配置。

You still run Harbor directly, either locally in Docker or in another Harbor environment you configure. That keeps your evals portable. Managed Deep Agents gives you the bridge from your production-ready agent to a Harbor-ready artifact.您仍然可以直接运行 Harbor，无论是在本地 Docker 中，还是在您配置的其他 Harbor 环境中。这确保了评估的可移植性。Managed Deep Agents 为您搭建了从生产就绪型代理到 Harbor 就绪型工件的桥梁。

Once the agent is deployed, you can manage your evals and monitor production behavior in LangSmith. Every run is traced in LangSmith, so production failures become future test cases, closing the feedback loop.代理部署后，您可以在 LangSmith 中管理评估并监控生产行为。每次运行都会在 LangSmith 中被追踪，因此生产故障将转化为未来的测试用例，从而形成闭环反馈。

Channels bring agents into the tools where work happens多渠道（Channels）将代理引入工作工具中

Channels are how you expose your agent to users. Managed Deep Agents has first class support for channels, making it straightforward to define how your agent connects to different channels, such as Slack. Add a file under channels/, and the runtime mounts the provider event endpoint, verifies provider signatures, invokes your agent with identity stamps, and can reply in the originating conversation.渠道是您向用户展示代理的方式。Managed Deep Agents 对渠道提供了一流支持，使得定义代理如何连接到 Slack 等不同渠道变得非常简单。只需在 channels/ 下添加一个文件，运行时就会挂载提供商事件端点、验证提供商签名、携带身份标识调用您的代理，并在原始对话中进行回复。

For Slack, that can be as simple as defining a channel file:对于 Slack，定义一个渠道文件即可轻松实现：

from managed_deepagents import channels
 
channel = channels.slack(
    on=["app_mention", "direct_message"],
    auto_reply=True,
)

Channels let your agent receive events from systems like Slack and respond without a separate integration service. This is especially useful for agents that collaborate with users, such as a code review agent that can comment on GitHub or a support or operations agent that responds in Slack. Users can tag an agent where the team is already discussing the work.渠道让您的代理能够接收来自 Slack 等系统的事件并做出响应，而无需额外的集成服务。这对于与用户协作的代理特别有用，例如可以在 GitHub 上发表评论的代码审查代理，或在 Slack 中响应的支持/运维代理。用户可以在团队讨论工作的地点直接 @ 代理。

Memory that persists across threads跨线程持久化的记忆功能

Thread state helps an agent manage a single conversation, but agents often need context that lasts longer than one thread. Memory gives them durable preferences and context they can carry across conversations.线程状态有助于代理管理单次对话，但代理通常需要比单次线程更长久的上下文。记忆功能为它们提供了可以在不同对话间携带的持久偏好和上下文。

Managed Deep Agents gives every deployment agent-scoped memory to start. You define memory behavior in memory.py or memory.ts, and the runtime backs memory with Context Hub. At runtime, the agent reads and writes memory files under /memories/.Managed Deep Agents 为每个部署提供了代理级记忆功能。您可以在 memory.py 或 memory.ts 中定义记忆行为，运行时会通过 Context Hub 为记忆提供支持。在运行时，代理会读写 /memories/ 下的记忆文件。

Deploy syncs instructions and skills from your project, but it preserves runtime-created memories. That means you can redeploy your agent to update its harness behavior without wiping what the agent learned.部署操作会同步项目中的指令和技能，但会保留运行时创建的记忆。这意味着您可以重新部署代理以更新其框架行为，而不会擦除代理已学习的内容。

Identity and auth for multi-user agents面向多用户代理的身份和认证

Managed Deep Agents includes a basic identity model today, and we will keep adding more advanced auth and credential flows going forward.Managed Deep Agents 目前包含一个基础的身份模型，未来我们将继续添加更高级的认证和凭证流程。

Today, your agent can run with a fixed set of credentials. If you define an OIDC provider in identity.py or identity.ts, Managed Deep Agents scopes threads per end user id from your OIDC provider. That keeps each user's threads isolated under the same deployment.目前，您的代理可以使用一组固定的凭证运行。如果您在 identity.py 或 identity.ts 中定义了 OIDC 提供商，Managed Deep Agents 会根据 OIDC 提供商提供的最终用户 ID 对线程进行划分。这使得每个用户的线程在同一个部署下保持隔离。

The identity system is also the basis for scoped memory and future credential patterns. That gives your agent a trusted way to know who triggered the run without relying on prompt text or spoofable request fields.身份系统也是作用域记忆和未来凭证模式的基础。这为您的代理提供了一种可信的方式来识别是谁触发了运行，而无需依赖提示词文本或易被伪造的请求字段。

How teams are using Managed Deep Agents today团队如何使用 Managed Deep Agents

Teams are already using Managed Deep Agents to ship faster by focusing on agent behavior instead of infrastructure, scaling, and runtime logic.团队已经在使用 Managed Deep Agents，通过专注于代理行为而非基础设施、扩展性和运行时逻辑，从而更快地交付产品。

Managed Deep Agents was amazing to work with. Highly recommend for teams exploring agent infrastructure who want a more cohesive offering, while avoiding model or lab lock-in.

- Chip Lay, Director of Product, FullstoryManaged Deep Agents 的使用体验非常棒。强烈推荐给那些正在探索代理基础设施、希望获得更具凝聚力的解决方案，同时又想避免被特定模型或实验室绑定的团队。—— Chip Lay，Fullstory 产品总监

Managed Deep Agents lets us scale our agentic workforce: an agent goes from idea to production in hours, not weeks. Our teacher agent wakes up every morning to review the runs of our entire fleet and drives improvements based on observability and live evals. We focus on the business logic; Managed Deep Agents handles the operational complexity, from persistent memory and the runtime to Slack and GitHub integration.

- Mathieu Mailhos, Staff Engineer, AI Runtime & Infrastructure, stealth-mode startupManaged Deep Agents 让我们能够扩展代理劳动力：代理从构思到生产仅需数小时，而非数周。我们的教师代理每天早上都会回顾整个代理集群的运行情况，并根据可观测性和实时评估推动改进。我们专注于业务逻辑；Managed Deep Agents 则处理运维复杂性，从持久化记忆和运行时，到 Slack 和 GitHub 集成。—— Mathieu Mailhos，AI 运行时与基础设施资深工程师，某隐形模式初创公司

When to use Managed Deep Agents何时使用 Managed Deep Agents

Managed Deep Agents is useful when you want a code-first Deep Agent with LangSmith owning persistence, execution, deployment, and the common production scaffolding around the harness.当您需要一个以代码为优先的 Deep Agent，并希望由 LangSmith 负责持久化、执行、部署以及框架周围的通用生产脚手架时，Managed Deep Agents 是理想选择。

Use it when you want to:在以下场景中使用它：

• Build on the open source Deep Agents harness基于开源 Deep Agents 框架进行构建
• Keep control over your model, prompts, tools, middleware, and business logic保持对模型、提示词、工具、中间件和业务逻辑的控制
• Deploy without rebuilding agent infrastructure from scratch无需从零开始构建代理基础设施即可部署
• Give the agent durable threads, memory, sandboxes, channels, schedules, evals, and traces为代理提供持久化线程、记忆、沙箱、渠道、调度、评估和追踪功能
• Move quickly from local development to a hosted LangSmith deployment快速从本地开发迁移到托管的 LangSmith 部署

If you need custom routes, application code alongside the graph, custom auth logic, or direct control over the persistence layer, use LangSmith Deployment directly. If you want to operate the harness yourself, Deep Agents is open source, so you can run it on the infrastructure you choose.如果您需要自定义路由、图表之外的应用程序代码、自定义认证逻辑，或需要直接控制持久化层，请直接使用 LangSmith Deployment。如果您想自行运维该框架，Deep Agents 是开源的，您可以将其运行在您选择的基础设施上。

The public beta scope today:当前公测范围：

• LangSmith Cloud in the US region美国地区的 LangSmith Cloud
• CLI-first while we finalize the supported API在确定受支持的 API 之前，以 CLI 为主
• Additional regions and deployment methods will be available at a later date更多地区和部署方式将在稍后提供

These are beta primitives, and we are excited to hear evolve it as we hear feedback from teams running workloads on Managed Deep Agents这些是测试版原语，我们非常期待在收到使用 Managed Deep Agents 的团队反馈后对其进行演进。

Get started开始使用

Follow the quickstart to deploy your first Managed Deep Agent. The tutorial adds identity, memory, tools, and evals step by step.按照快速入门指南部署您的第一个 Managed Deep Agent。该教程将逐步添加身份、记忆、工具和评估功能。

If you want the open source harness first, start with the Deep Agents overview. When you are ready to productionize that harness, use Managed Deep Agents to deploy it to LangSmith.如果您想先使用开源框架，请从 Deep Agents 概览开始。当您准备好将该框架投入生产时，请使用 Managed Deep Agents 将其部署到 LangSmith。

We would love to hear what you build, where the defaults work, and where you need more control.我们非常期待了解您的构建成果，以及哪些默认设置对您有效，哪些地方您需要更多的控制权。