本番ディープエージェントを支えるランタイム設計——LangSmith Deployment完全解説

The runtime behind production deep agents To build a good agent, you need a good harness. To deploy that agent, you need a good runtime. The harness is the system you build around the model to help your agent be successful in its domain. That includes prompts, tools, skills, and anything else supporting the model and tool calling loop that defines an agent. The runtime is everything underneath: durable execution, memory, multi-tenancy, observability, the machinery that keeps an agent running in production without your team reinventing it. This guide walks through the production requirements that surface once you deploy agents, the runtime capabilities that meet them, and how deepagents deploy packages those capabilities into something you can ship. ## Runtime capabilities for production agents Throughout this section, "the runtime" refers to LangSmith Deployment (LSD) and its Agent Server: LSD runs agents in production, and Agent Server is the interface for assistants, threads, runs, memory, and scheduled jobs. ## Durable execution Agents work by running a loop: Given a prompt, the model reasons, calls tools, observes the results, and repeats until it decides the task is complete. Unlike a typical web request that returns in milliseconds, this loop can span minutes or hours. A single run might make dozens of model calls, spawn subagents, or wait indefinitely for a human to approve a draft. In practice, you feel it in two places: - Long runs need to survive infrastructure failures. - Agents need to be able to stop and wait. Agents run on a managed task queue with automatic checkpointing, so any run can be retried, replayed, or resumed from the exact point of interruption. Each super-step of graph execution writes a checkpoint to the persistence layer (PostgreSQL by default), keyed by a thread_id that acts as a persistent cursor into the run. ## Memory Agents need two different kinds of memory: Short-term memory is what the agent accumulates within a single conversation. The messages exchanged, the tool calls made, the intermediate state built up across a run. This lives in the checkpoint for the thread, scoped to a thread_id. Long-term memory is what the agent carries across conversations. This can include user preferences learned across conversations, project conventions and best practices, or a knowledge base enhanced with each new query. It's a key-value interface where memories are organized by namespace tuples (for example, (user_id, "memories")) and persisted across threads. ## Multi-tenancy The moment your agent serves more than one user, a set of problems appears. These break down into three distinct concerns: 1. Isolating one user's data from another. Custom authentication runs as middleware on every request. 2. Letting the agent act on behalf of a user. Agent Auth handles the OAuth dance and token storage. 3. Controlling who can operate the system itself. RBAC handles this operator-level access control. ## Human-in-the-loop (HITL) Agents work by running a loop. Most of the time you want that loop to run uninterrupted. But sometimes you need a human in the middle at key decision points. There are two common situations: - Reviewing a proposed tool call. Before the agent executes a consequential action. - An agent asking a clarifying question. The Agent Server handles this with two primitives: interrupt() pauses execution and surfaces a payload to the caller; Command(resume=...) continues it with the human's response. ## Real-time interaction ### Streaming An agent that takes thirty seconds to produce a response leaves the user staring at a spinner. Streaming solves this: partial output flows to the client as the agent produces it. The Streaming API supports several modes: full state snapshots after each graph step, state updates only, token-by-token LLM output, or custom application events. Thread streaming supports resumption via the Last-Event-ID header: the client reconnects with the ID of the last event it received, and the server replays from there with no gaps. ### Double-texting A user sends a new message while the agent is still working on the previous one. There are four strategies: - enqueue (the default): The new input waits for the current run to finish. - reject: Refuse any new input until the current run finishes. - interrupt: Halt the current run, preserve progress, and process the new input from that state. - rollback: Halt the current run, revert all progress, and process the new message as a fresh run. ## Guardrails Not every production concern can be expressed as 'run the loop durably.' Some have to shape the loop itself: intercepting model inputs, filtering tool outputs, enforcing limits on expensive operations. Both are handled by middleware, which wraps the agent loop at defined hooks—before_model, wrap_model_call, wrap_tool_call, after_model. LangChain ships built-in middleware covering the common cases: PIIRedactionMiddleware, ModelRetryMiddleware, ModelFallbackMiddleware, ToolCallLimitMiddleware, SummarizationMiddleware, HumanInTheLoopMiddleware, OpenAIModerationMiddleware. ## Observability You don't know what an agent will do in production until you run it. When something goes wrong, you need to see what actually happened. Every LangSmith Deployment is automatically wired to a tracing project. You get the full execution tree out of the box—model calls, tool calls, subagent runs, middleware hooks. Traces aren't just a debugging tool; they're the foundation of the improvement loop: - Polly, the LangSmith AI assistant, analyzes traces and surfaces insights—common failure modes, slow tool calls, repeated patterns. - Online Evals run LLM-as-judge or custom scorers against production traces automatically. ## Time travel Observability tells you what happened. Time travel lets you ask what would have happened if something had gone differently. Because every super-step writes a checkpoint, every point in a run's history is already a snapshot you can return to. Time travel makes this explicit: pick a checkpoint from a thread's history, optionally modify its state, and resume from there. ## Code execution An agent that can only call the tools you pre-wired is limited to what you anticipated. An agent that can run arbitrary code is general-purpose. Arbitrary code execution requires isolation. In Deep Agents, isolation happens through sandbox backends. Supported providers include Daytona, Modal, Runloop, and LangSmith Sandboxes. LangSmith Sandboxes (currently in private preview) feature: warm pools that pre-provision sandboxes with automatic replenishment eliminating cold start latency, and the auth proxy that intercepts outbound requests and injects credentials from workspace secrets automatically. ## Integrations The Agent Server provisions three integration surfaces automatically: MCP: Every LangSmith Deployment automatically exposes an MCP endpoint, making your agent discoverable by any MCP-compliant client—Claude Desktop, IDEs, other agents. A2A: Every deployment exposes an A2A (Agent-to-Agent) endpoint automatically. This makes multi-agent architectures across deployments tractable. Webhooks: Pass a webhook URL when creating a run, and the server POSTs the run payload to that URL on completion. ## Cron The Agent Server has cron jobs built in, so scheduled runs get the same durability, tracing, and auth guarantees as any other run. Two flavors: - Stateful cron (client.crons.create_for_thread): ties the schedule to a specific thread_id. - Stateless cron (client.crons.create): spins up a fresh thread for each execution. ## deepagents deploy deepagents deploy is the packaging step that deploys your agent on the runtime described above. You define your agent in deepagents.toml, and the CLI bundles your configuration and deploys it as a LangSmith Deployment. ## Open Harness deepagents deploy is built to avoid vendor lock-in. The harness is MIT licensed and fully open source, agent instructions use AGENTS.md (an open standard), and agents are exposed via open protocols—MCP, A2A, Agent Protocol. The capabilities this guide outlines—durable execution, memory, multi-tenancy, guardrails, human-in-the-loop, observability, sandboxed code execution, scheduled runs—are the infrastructure requirements production agents can't function without. deepagents deploy packages all of it so teams don't have to assemble it from scratch.