Managed Deep Agents：如何把关键业务 Agent 部署到生产环境

简要描述Brief Description

托管式深度智能体 | 将关键任务智能体部署到生产环境Managed Deep Agents | Deploying mission critical agents to production

目录Table of Contents

• 什么是智能体运行框架？为什么上下文很重要？
  What is an agent harness, and why does context matter?
• 构成深度智能体的四个核心领域
  The four core areas that make up a deep agent
• Madrigal 几小时内即可启动研究代理，而非几周后才能启动。
  Madrigal spins up research agents in hours instead of weeks
• 本地代理投入生产后会发生哪些变化？
  What changes when a local agent goes to production?
• 托管式 Deep Agents 如何将运行框架与基础设施打包整合在一起
  How Managed Deep Agents bundles harness and infrastructure
• 一个以文件夹形式提供的代理，附带三个 mda 命令
  An agent as a folder, shipped with three mda commands
• LangChain 的 GTM 智能体如何映射到文件上
  How LangChain's GTM agent maps onto files
• 是谁在提出请求，代理应使用谁的账户？
  Who is asking, and whose account should the agent use?
• 智能体可以在私信或共享频道中使用哪些记忆？
  Which memories can the agent use in a DM or shared channel?
• Context Hub 中的版本化上下文，以及借助 Harbor 进行评测
  Versioned context in Context Hub and evals with Harbor
• Consensus 如何为其组织的不同部门构建智能体
  How Consensus builds agents for different parts of its org
• What's new in the Managed Deep Agents 0.8 release

什么是智能体框架？为什么上下文很重要？What is an agent harness, and why does context matter?

大家好，我是 Victor，是 LangChain 的产品经理。我主要负责我们的运行时产品。今天我们要聊的是如何将任务关键型智能体部署到生产环境中。首先，我们会稍微回顾一下什么是 Deep Agents，然后再聊聊托管式 Deep Agents，以及我们为何对它们如此期待。 我们通常喜欢从一个问题开始：什么是智能体？这是我们经常被问到的问题。智能体的核心概念是：模型通过使用工具来完成任务。这一概念基于一年多前开始流行的 ReAct 风格智能体，而 ReAct 指的是推理（Reason）与行动（Act）。智能体会使用工具，并围绕工具进行推理，从而帮你完成任务。接下来，我们经常会被问到：什么是运行框架？Hi everyone, I'm Victor. I'm a product manager here at LangChain. I primarily focus on our runtime products, and today we're going to talk about deploying mission-critical agents into production. We're going to start first with like a little refresher on what Deep Agents are, and then we'll talk about Managed Deep Agents and why we're so excited about them. So the first place we always love to start with this is: what is an agent? It's a question we get a lot, and the core idea of an agent is it's a model using tools in order to complete a task, and this is based on the ReAct-style agents that have become popular over a year ago, and that's based on like reason and action. So they're going to use tools, they're going to reason over it to accomplish a task for you. The next question we often get is: what is a harness?

因此，Harness 基本上就是我们为构建智能体而加入的其他所有内容。它可以是技能、工具、上下文、子智能体，实际上就是我们添加到智能体中的各种东西，帮助它完成任务。我们为什么要这么做？为什么要费这么大功夫去构建 Harness、构建智能体，还要投入所有这些开发工作？这是为了在合适的时机向模型提供合适的上下文。我们在构建智能体时，常常会意识到，模型的能力有多强，取决于我们提供给它的上下文有多丰富。因此，我们必须始终确保能在合适的时机向它提供合适的上下文。So a harness is basically everything else that we bake in to create the agent. So that can be skills, it can be tools, context, subagents, really all of these different things that we put into an agent in order for it to accomplish a task. Why do we do this? Like, why do we go through all the effort of building a harness, building an agent, and going through all this development? And that's to get the model the right context at the right time. So a lot of times when we're building an agent, we know that the model is only as powerful as the context that we give it. And we need to always be able to get it the right context at the right time.

构成深度代理的四个核心领域The four core areas that make up a deep agent

Deep Agents 是一个可定制的执行框架，我们可以针对任何特定领域的任务来构建它。因此，我们吸收了许多编码智能体以及业界各种执行框架的经验，并将这些经验融入这个高度可定制的基础框架中，你几乎可以将它用于任何场景。深度智能体主要由四个核心部分组成。首先是执行环境。这是 Deep Agents 理念的核心：我们会为智能体抽象出文件系统。作为开发者，我们可以通过虚拟文件系统，在模型与其交互的文件之间建立一道隔离层。这个文件系统实际上可以位于任何地方，比如 S3 文件；也可以是一个沙箱，让智能体能够编写并执行代码；或者是功能更轻量的代码解释器或 REPL。Deep Agents is a customizable harness that we can build for any domain-specific task. So we took a lot of the learnings of coding agents and different harnesses that are out there in the wild, and we've really put it into this very customizable base harness that you can use for virtually any use case. The anatomy of a deep agent is really comprised of four core areas. The first being the execution environment. And this is really core to the philosophy of Deep Agents, is we sort of abstract away the file system for the agent. So us as developers, we can define sort of this wall between your model and the files it interacts with through a virtual file system. That file system can actually live anywhere. It could be S3 files. It could even be a sandbox where your agent can write and execute code, or its lighter-weight cousin, a code interpreter or a REPL.

另一个很棒的地方是，它还能帮助管理上下文。比如，渐进式地展示技能，以及实现跨线程记忆。如果你想跨线程记住有关代理或用户的信息，就可以通过文件系统来实现。我们还可以进行摘要。随着上下文不断增长，我们可以对之前的对话进行摘要、压缩，并将其存储到文件系统中。此外，我们还可以将上下文移出模型的上下文窗口。比如说，我们检索到一条非常大的工具响应时，可以把它移到文件系统中，而不是直接加载到模型的上下文窗口里。第三个关键领域是委派。委派指的是模型能够制定计划、围绕计划进行推理，然后启动子代理来执行任务。What's really cool about this too is this helps with context management. So things like progressive disclosure of skills, doing things like cross-thread memory. So you want to remember things about agents or about users across threads, you can do that with the file system. We can do things like summarization. So as our context grows and grows, we're able to summarize that previous conversation, compact it down, and store it in the file system. And then we can also offload context. So let's say we retrieve like a very large tool response, we can actually offload that into the file system rather than directly loading that into our model's context window. The third kind of key area is delegation. So delegation is the ability for the model to plan, reason over that plan, and then kick off subagents to execute things.

最后一点是人在环路中。人在环路中是我们在 LangChain 所做一切的核心。这场会议实际上是以 LangGraph 的 interrupt 函数命名的。Deep Agents 构建在 LangGraph 运行时之上，因此你可以中断并暂停执行。And then lastly is human in the loop. Human in the loop is very core to everything that we do here at LangChain. This conference is actually named after the interrupt function, which is a function of LangGraph. Deep Agents is built on top of that LangGraph runtime. So you have that ability to interrupt and pause for execution.

Madrigal 只需数小时即可启动研究智能体，而非数周。Madrigal spins up research agents in hours instead of weeks

将深度代理投入生产的一个很好的例子，是我们的客户 Madrigal。Madrigal 有大量不同的应用场景，但主要专注于药物研究代理。这个代理让他们的药物研究人员能够加载一个特定领域的运行框架，使其可以针对该研究人员所在领域的特定知识库进行推理，综合所有结果，并生成一份内容连贯、附有引用来源的报告。他们借助 Deep Agents 构建了这一整套系统。过去，为一位研究人员启动一个新代理需要数周时间；如今，只需将所有内容放入 Deep Agents 运行框架并部署到 LangSmith 上，几个小时就能完成。So a good example of taking a deep agent into production is a customer of ours, which is Madrigal. Madrigal has a ton of different use cases, but primarily focuses on a pharmaceutical research agent. And this is for their pharmaceutical researchers to be able to load in a domain-specific harness that is able to reason over a certain knowledge base for that particular researcher's domain, synthesize all of those results, and respond back with a cohesive report with cited sources and all of that. They were able to build all of this with Deep Agents, and a task that used to take them weeks, to spin up a new agent for a researcher, now just takes a few hours by putting this all into the Deep Agents harness and deploying it onto LangSmith.

本地代理进入生产环境后会发生什么变化？What changes when a local agent goes to production?

好。我们来聊聊，如何把一个在本地运行正常的智能体真正投入生产环境。构建智能体大致有三个核心领域。第一是业务逻辑，我们认为这是开发者和团队最重要的贡献所在：也就是他们的专业知识，以及智能体可能会用到的各种指令和技能。第二是执行框架本身，我们之前聊过，Deep Agents 让智能体能够使用文件、管理上下文，还能实现许多很棒的功能。第三个领域是基础设施。基础设施可能是比较枯燥的部分，但如果你想真正把智能体投入生产环境，让其他人也能使用它，这就是最重要的部分。Cool. So, let's talk about like what it takes to take an agent from something that works locally and actually put it into production. So, there's kind of like three core areas of building an agent. The first is the business logic, and this is what we think is the most important thing for developers and for teams to bring, is this core idea of like their expertise and the different instructions and skills that your agent might use. The second is the harness itself, which we talked about, as Deep Agents gives our agent the ability to use files and do context management and all these wonderful things. And the third area is going to be infrastructure. So infrastructure is probably the more boring area, but the most important area when you talk about actually taking an agent and putting into production in a way that others can use it.

很好。构建智能体时，我们首先要做的事情之一，就是在本地进行原型开发。我们会让它在自己的机器上本地运行起来，发现效果很棒，这让我们非常兴奋。然后，我们就想把它分享给其他所有人。这实际上是一个非常非常重要的阶段。在这个阶段，我们可以证明智能体确实有它的神奇之处，对吧？也就是说，它确实能完成我们设计它要做的事情。接下来，我们会尝试将它投入生产环境，这时就需要考虑很多不同的事情了，对吧？我们需要考虑人们会在哪里使用这个智能体、你可能希望智能体通过哪些不同的入口供人使用，以及如何协调这些不同入口接入实际运行时的方式。你还需要能够对运行任务进行排队，这样智能体才能合理地处理它们。Cool. So one of the first things that we do when we're building an agent, right, is we're prototyping it locally. We get it running locally on our machine and it works great, and we're really excited, and then we want to go and actually share this with everyone else. This is actually a very, very valuable stage. This is where we can kind of prove the magic of the agent, right? That the agent can actually do what we're designing it for. What happens then is we try to go into production, and now we need to think about a lot of different things, right? We need to think about where people are going to use this agent, the different surfaces you might want your agent to be used from, how you're going to reconcile where those different surfaces are entering into your actual runtime. You need to be able to queue up the runs so that your agent can kind of serve them reasonably.

你需要能够建立流式传输。要让这个智能体在生产环境中可靠运行，你需要完成这些不同的工作。与此同时，你的团队还需要从基础设施的角度考虑一些不同的问题。You need to be able to establish streaming. You need to do all these different things in order to have this agent run reliably in production. And it requires kind of different things that your team has to consider from an infrastructure standpoint.

托管式 Deep Agents 如何将运行框架与基础设施打包在一起How Managed Deep Agents bundles harness and infrastructure

借助 Managed Deep Agents，我们希望让这个过程变得非常、非常简单。因此，我们把运行框架和基础设施整合在一起，让团队能够非常轻松地专注于业务逻辑，并通过评测、跟踪记录和 Engine 来改进智能体，不必把精力放在基础设施和运行框架层面的工作上，而是可以不断迭代实际的智能体逻辑。这大致就是它的样子。之前那张由许多不同方框组成、需要你自行管理的架构图，现在借助 Managed Deep Agents 就变得非常简单。它运行在我们久经验证的 LangSmith Deployment 上，支持流式传输、检查点、认证处理器等功能；需要智能体运行并执行代码时，它还能直接集成 LangSmith Sandboxes，实现沙箱控制。With Managed Deep Agents, we wanted to make this process very, very easy. So what we've done is we've sort of bundled together the harness and the infrastructure to make it really, really easy for your teams to work on primarily the business logic and actually improving your agents with evals, with traces, with Engine, and iterating on your actual agent logic rather than focusing on the infrastructure and the harness-level stuff. So this is kind of what it looks like. That previous graph of all these different boxes that you had to manage yourself now becomes very easy with Managed Deep Agents. It runs on our proven LangSmith Deployment for things like streaming, checkpointing, auth handlers, things of that nature. It integrates directly with LangSmith Sandboxes for all of that sandbox control when you need agents to run and execute code.

它还使用 Context Hub，我们稍后会稍微介绍一下。借助它，我们可以与业务用户协同制定指令和技能，并不断迭代完善。当然，它也接入了我们的 LLM Gateway 和追踪系统。还有一点特别好：左侧可以看到这个智能体界面。我们在支持用户通过不同界面使用智能体，并协调统一这些界面方面做得非常出色。It also uses Context Hub, which we'll talk about a little bit later, but allows us to kind of coordinate on instructions and skills with business users and iterate on things. And then of course, it plugs into our LLM Gateway and traces as well. And what's really nice is, on the left side you'll see this agent interface, is we do a really good job of allowing you to use your agent from different interfaces and reconcile those.

一个作为文件夹提供的智能体，附带三个 mda 命令An agent as a folder, shipped with three mda commands

既然我们负责处理所有这些基础设施，现在就能让你作为开发者轻松定义智能体。你不必再在自己的逻辑中定义智能体，我们可以直接提供这样的文件夹结构来定义各项内容。你的智能体会放在 agent.ts 或 agent.py 这样的文件中，因此 Python 和 TypeScript 都适用。你需要添加到智能体中的指令、技能、工具、身份等各种基本要素，会分别放在目录中的不同文件夹或文件里。开始使用非常简单：只需运行 mda init 并为智能体命名，就能为我们搭建好项目目录。添加完所有逻辑后，就可以运行 mda dev。这会为我们启动一个本地 Agent Server，也就是为 LangSmith Deployment 提供支持的同一套服务器。So since we're handling all of this infrastructure, we now can make it really easy for you as a developer to define the agent. So rather than kind of defining it in your own logic, we can go ahead and give you this folder structure in order to define things. So your agent will live in like the agent.ts or agent.py. So this works for Python or TypeScript. Your instructions, skills, tools, identity, all of these different primitives that you need to add to the agent itself will live in different folders or different files in your directory. Getting started is really easy. So, all we're going to do is run mda init and give our agent a name. That'll scaffold this project directory for us. After we add in all of that logic, we can then go ahead and run mda dev. And that's going to start up a local Agent Server for us, which is the same server that powers LangSmith Deployment.

这样，你就可以在本地测试所有功能，确保它们按预期运行。等到准备好正式投入生产时，只需运行 mda deploy，就能将其部署到 LangSmith 托管的基础设施上。这样一来，从构想到原型、在本地运行，再到投入生产，整个过程就变得非常简单。So you're able to test everything out locally and make sure that it's working as intended. And then once you're ready to actually go into production, all you need to do is run mda deploy. And that's going to go ahead and deploy it onto LangSmith's managed infrastructure. This makes it really, really easy to go from an idea to a prototype, something that works locally, and then into production.

LangChain 的 GTM 代理如何映射到文件上How LangChain's GTM agent maps onto files

很好。接下来我们来看一个实际的智能体示例——你可能会想要构建这样一个智能体，供组织中的成员使用。这是我们 LangChain 内部经常使用的一个示例，也就是我们的市场拓展智能体。组织中的任何人都可以与它互动，处理所有与市场拓展相关的事务。比如，我们会让它帮我为某场会议做准备，并起草一封邮件供我审阅，这些请求都会发送给这个市场拓展智能体。 这个智能体的运作方式以及设计方法都相当简单。现在，这些内容分别对应不同的文件。再说一遍，我们一开始的智能体定义，也就是指导它如何完成不同任务的操作手册，可以放在 instructions 和 skills 中；它与 Salesforce、Gong 等不同业务系统及其他平台的连接，则放在 tools 中；至于如何对用户进行身份验证，以及如何记住有关用户的信息，则可以在另外两个文件中定义。Cool. So let's take a look at an actual example of an agent that you might want to build, something that people in your organization might use. This is sort of an example that we use a lot internally here at LangChain, which is our go-to-market agent, and it's something that anyone in our organization can interact with in order to do anything related to go-to-market. So, we're going to ask it to prep me for a certain meeting and draft an email for me to review, and that kind of gets sent into this GTM agent. The way that this looks and the way that we can design this agent is really quite easy. This now all maps to different files. So again, our agent definitions at the beginning, the sort of playbook for how we wanted to do different things, can live in both the instructions and the skills, and then all of the connections to different business systems like Salesforce, Gong, all these other sort of platforms, lives in tools, and then we can define how users authenticate and how we remember things about users in the other two files.

是谁在提出请求，代理应该使用谁的账户？Who is asking, and whose account should the agent use?

因此，在我们与客户讨论构建智能体时，有几件核心问题总会被提出来，而当你把智能体投入生产环境时，通常会有四个令人担忧的问题：我们如何识别是谁在要求这个智能体做什么——准备邮件还是准备会议？它会使用谁的数据？它可以引用或编辑哪些记忆？最后，如果启动运行时它实际上没有所需的访问权限，会发生什么？先来看第一个问题。这是我们在设计 Managed Deep Agents 时深入考虑过的：如何协调不同界面中的调用者。Managed Deep Agents 原生支持不同渠道。你可以非常轻松地创建一个 Slack 应用并使用这个智能体，但你也可能希望在自己的网页 UI、Web 应用或平台中提供这个智能体。So, one of the core things that, when we talk about building agents with customers, there's kind of four scary things that then get brought up when you bring it into production, is how do we identify who's asking this agent to do what, prep for the email or prep for the meeting? Whose data is it going to use? Which memory is it going to be able to reference or edit? And then lastly, what happens if it is actually missing access when that run gets initiated? So jumping into the first one, this is something that we thought about a lot with Managed Deep Agents, is being able to reconcile the callers between different surface areas. So we have first-class support for different channels in Managed Deep Agents. You can really easily just create a Slack application, go ahead and use this agent, but you also might want to expose this agent in your web UI or your web application or your own platform.

而且你肯定不希望用户总是得重新进行身份验证，一遍又一遍地重新走权限配置流程。因此，我们构建了一个非常出色的身份验证处理程序，帮助你关联这些用户，并让他们在不同的交互界面之间保持关联；所有这些信息都可以轻松传递给托管式深度智能体的运行时。第二个问题是：应该使用谁的账户？作为开发者，我们可能想定义智能体可以使用的特定连接和工具，并以特定方式将它们连接起来。比如，我们可能会说，好，在使用我们的 CRM 工具时，我们始终希望它使用用户的凭据。也就是说，我们希望它代表调用者执行操作。所以，如果我在和这个智能体的私信中说“帮我准备一下这场会议”，它就能够使用我的 Salesforce 凭据并访问相关信息。And you don't want to have to have a user always like re-authenticate and re-go through the permissioning over and over again. So what we did is built a very nice auth handler that will help you reconcile those users, and you can have them reconcile across these different surface areas, and that all gets passed into the runtime for the managed deep agent quite easily. The second is: whose account should it use? So as a developer, we might want to define certain connections, certain tools that your agent can use, and connect them in a certain way. So we might want to say, okay, when it uses our CRM tool, for example, we always want it to use the user's credentials. So we want to have it operate on behalf of the caller. So, if I'm in a DM with this agent and I say, "Prep me for this meeting," it's then going to be able to use my Salesforce credentials and go and access that.

在其他一些场景中，你可能希望代理拥有自己的代理专属凭据，或者能够使用服务账户凭据。借助 connections 这一基础功能，我们让你可以在 Managed Deep Agents 中轻松实现这一点。你只需要定义这些连接并上传令牌。如果令牌是基于用户的，我们会代你处理。我们可以在任务执行过程中轻松完成这一流程。由于 Deep Agents 和 LangGraph 运行时内置了 human in the loop 功能，因此当你发出请求，而代理没有某个用户对应的特定令牌，且需要使用 on-behalf-of 令牌时，它就可以轻松暂停并请求用户进行身份验证。用户点击链接后，流程便会照常继续。由于我们会为中断创建检查点，这一过程可以无限期地进行。There's other scenarios where you might want your agent to have its own agent-scoped credentials or be able to have service account credentials. We make this really easy in Managed Deep Agents with this connections primitive. So, all you need to do is define these connections, upload tokens. If they're user-based, we'll actually handle that for you. And how we handle that is really easily mid-task. So since we have built-in human in the loop in Deep Agents and in the LangGraph runtime, what happens is when you make a request and the agent doesn't have a particular token for a particular user and it's an on-behalf-of token, it's actually able to really easily pause, ask the user to go ahead and authenticate. They'll click the link, everything proceeds as normal, and this will happen indefinitely, since we have the interrupts checkpointed.

代理可以在私信或共享频道中使用哪些记忆？Which memories can the agent use in a DM or shared channel?

第二个，或者说第三个开始变得有意思的核心领域是记忆。记忆有很多不同的实现方式，我们希望为此提供非常出色的默认设置。第一种约定是智能体级记忆，也称为程序性记忆。在 Managed Deep Agents 中，我们提供了一种很棒的方式，让你的智能体能够获取并记住有关用户的某些程序性信息。第二种是用户级记忆，也就是我告诉智能体的个人偏好。让智能体能够处理这些不同类型的记忆非常重要，而这正是访问控制开始发挥作用的地方。比如，我们在 Managed Deep Agents 中加入了一项功能，让你可以根据智能体所使用的渠道来定义访问控制。例如，如果我在 Slack 私信中与它交流，它就可以使用我的个人记忆。The second, or the third kind of core area that becomes interesting is memory. There's a lot of different approaches to memory, and we wanted to have really good defaults for this. So the first kind of convention is agent-level memory, or procedural memory. We have a really great way for your agent to be able to take and remember certain procedural things about users in Managed Deep Agents. The second is user-level memory. So personal preferences that I tell the agent about myself. And it's really important that your agent is able to kind of take these different types of memory. And this is where control starts to come into place. So, one thing that we've built into Managed Deep Agents is allowing you to define the access control based on the channel that it's calling from. So, if I'm in a Slack DM, for example, it can use my personal memories.

它可以使用我的个人凭据，也可以获取关于我的个人记忆，这完全没问题。但如果我是在和其他同事共用的频道里发言，我可能不希望它透露某些关于我的信息。因此，作为开发者，如果有需要，我可以定义这类基本规则。It can use my personal credentials. It can take personal memories about me, and that's totally fine. But if I'm talking in a shared channel with my other co-workers, I probably don't want it to be able to unveil certain information about me. So, as a developer, I can define those sort of primitives if I need to.

Context Hub 中的版本化上下文与使用 Harbor 进行评测Versioned context in Context Hub and evals with Harbor

Managed Deep Agents 的另一个很棒之处在于，我们可以通过 Context Hub 对智能体上下文进行版本控制。这样，我们就能把所有指令、技能和记忆都存储在 Context Hub 仓库中。这让我们可以在 LangSmith 界面中协作，这非常棒，尤其是在迭代指令等内容、对其进行版本控制、将其部署到生产环境等方面。不过，将内容部署到生产环境可能会让人担心。因此，我们在 Managed Deep Agents 中加入了一项功能，并在这上面花了很多时间：将其与 Harbor 集成，把 Harbor 用作评估框架。我知道今天我们已经聊过 Harbor，但我们确实认为它是运行评估的绝佳方式。不过，我们从客户那里了解到，开始使用它可能有些困难。Another really nice part of Managed Deep Agents is we get version control for our agent context with Context Hub. So we're able to store all of our instructions, skills, and memory inside of a Context Hub repo. And that will allow us to collaborate in the surface within LangSmith, which is really great for kind of iterating on different things like instructions, having version control over it, promoting it to production, things of that nature. Promoting it to production, though, can be scary. So, one thing that we built into Managed Deep Agents that we've really spent a lot of time on was its integration with Harbor as an eval framework. So, I know we've talked about Harbor today, but we really think it's a great way for running evals. But what we found from customers is that it can be a bit difficult to get started with.

所以，我们希望让 Managed Deep Agents 用起来尽可能简单。运行 `mda eval init`，它就会为你初始化一个 Harbor 环境，帮助你设置任务和检查项。所有这些都会被追踪到 LangSmith，并显示在 LangSmith 的实验标签页中，这样你就能逐步改进自己的智能体。你可以重新运行相同的任务，直接在自己的机器上不断迭代优化智能体。今天我们宣布的一项内容，是与 Parallel 的集成。我们非常高兴能宣布这项集成。在公开测试期间，这项集成将免费提供，欢迎大家使用。它的工作方式很简单：只需将这个工具添加到你的 managed deep agent 中即可。你不需要添加任何 Parallel API 密钥之类的东西。So, we wanted to make it really easy for Managed Deep Agents. If you run this mda eval init, it'll go ahead and initialize a Harbor environment for you. Help you set up the tasks, help you set up the checks. All of that will get traced into LangSmith and show up in your LangSmith experiments tab, and you're able to kind of improve your agent over time. You can rerun the same tasks and you can actually hill-climb your agent right in your own machine. One of the things that we're announcing today is our integration with Parallel. So, we're really excited to announce this integration. It's going to be free during our public beta. So, please feel free to go ahead and use it. But the way that it works is essentially you can just go ahead and add this tool to your managed deep agent. You don't have to add any Parallel API keys, anything like that.

这一切基本上开箱即用。所以，我们非常期待与 Parallel 合作推进 Managed Deep Agents。It'll all kind of work just out of the box. So, we're really excited about partnering with Parallel on this for Managed Deep Agents.

Consensus 如何为其组织的不同部门构建智能体How Consensus builds agents for different parts of its org

我们真正非常享受的一件事，是不仅在内部围绕自己的智能体应用场景开展工作，比如我们的市场拓展智能体 Open SWE（类似软件工厂类型的智能体），并不断迭代它，以用于 Managed Deep Agents；还与许多客户合作。我们特别想重点介绍两位客户。 Kyth 的 Zahid 在帮助我们起步方面发挥了重要作用，让我们得以探索如何与无代码用户、业务用户协作的一些基本构件，也帮助我们规划连接和记忆的运作方式。能与 Zahid 合作真的非常棒，我们也珍视他这位合作伙伴。 此外，Consensus 的 Derek 也非常出色。他实际使用 Managed Deep Agents 的方式，正是我们设想中的用法。他和他的开发团队会在 Consensus 组织内部各处开展工作，为组织的不同部门构建各种深度智能体应用场景。So something that we've really, really enjoyed was working not only internally with our own agent use cases, like our go-to-market agent, Open SWE, which is like a software factory type agent, and iterating on that for Managed Deep Agents, but also working with a lot of our customers. And we wanted to highlight two customers in particular. Zahid from Kyth was instrumental in really helping us getting started with some of the primitives of collaborating with no-code users, with business users. Also setting up how connections and memory will work. So, it's been really great working with Zahid, and we value him as a partner. Additionally, Derek from Consensus has been really, really great to see how he's actually used Managed Deep Agents in a way that we really intended it to be used. So, him and his team of developers kind of go around the org there at Consensus, and they build out different deep agent use cases for different parts of the org.

由于 Managed Deep Agents 负责处理所有基础设施，他们可以非常轻松地部署这些智能体。他们也得以迅速增加 Consensus 内部使用的智能体数量，这确实令人兴奋。And because Managed Deep Agents handles all of the infrastructure, they're able to really easily kind of go and deploy these agents. And they've been able to really rapidly increase the amount of agents that are being used across Consensus, which is really exciting.

What's new in the Managed Deep Agents 0.8 release

那么，截至今天，托管式 Deep Agents 有哪些新功能？第一项是 HTTP 通道。这项基础能力让你能够定义自己的自定义通道。比如，我们已经提供了与 Slack 等平台的优质预构建集成，但我们知道，你可能希望在各种不同的平台上以不同方式使用你的智能体。因此，我们现在让你可以非常轻松地定义智能体如何响应特定事件，并由它替你处理这些事件。借助全新的 HTTP 通道，这一切现在都变得非常简单。我们还改进了用于访问沙箱文件系统的 API。智能体不仅可以访问文件系统，你现在也可以在不同位置通过自己的前端访问它。第三项是用户范围的记忆。正如我提到的，我们深入思考了如何可靠、安全地实现用户范围的记忆；现在，这项功能已在托管式 Deep Agents 中推出。So what's new as of today in Managed Deep Agents? The first is HTTP channels. And the primitive here allows you to basically define your own custom channels. So we have great pre-built integrations for Slack, for example, but we know that you might want to use your agents in a variety of different ways across a variety of different surfaces. So we make it very easy for you now to define how your agent responds to certain events, where it then responds to those events for you. So it's very, very easy now with the new HTTP channels. We also added much better APIs for accessing your sandbox's file system. So not only can the agent access the file system, but you as a user can now access it from your front ends in different places. The third is user-scoped memories. So as I mentioned, we thought a lot about user-scoped memories and how to do it reliably and safely, and that's now available in Managed Deep Agents.

然后当然还有 connections，这就是我们作为开发者实际进行身份验证和定义的方式，现在也已推出。倒数第二项是 Slack 中的文件传输。我们经常需要协作处理文件。你可能想让智能体为你创建一份 PowerPoint 或 PDF，也希望能直接在 Slack 中反复修改。现在，这些功能已成为 Managed Deep Agents 的一等功能。最后是我刚才提到的与 Parallel 集成的内置搜索。太棒了。感谢大家今天的参与。我们非常激动地宣布，Managed Deep Agents 已包含在 0.8 版本中，也迫不及待地想看看你们会用它构建什么，以及会如何构建特定领域的智能体。谢谢。And then of course connections, which is how we're going to actually authenticate and define that as developers, is now available. The second to last is file transfers in Slack. So very commonly you're going to want to collaborate on files. You maybe want an agent to create a PowerPoint for you, create a PDF. You want to be able to iterate on it right within Slack, and that is now first-class in Managed Deep Agents. And lastly, the built-in search with Parallel that I just mentioned. Awesome. Thank you all for joining today. We're really excited to announce Managed Deep Agents in our 0.8 release, and we can't wait to see what you build with it and build your domain-specific agents. Thank you.