Source: LangChain — 2026-08-18

Summary

LangChain has moved Managed Deep Agents out of private preview into public beta, turning its Deep Agents harness — the AGENTS.md, skills/, subagents/, and tools.json convention for structuring an agent's context and capabilities — into a hosted runtime. Developers author agents in Python or TypeScript, test them locally, and deploy with a single command to a /v1/deepagents endpoint on LangSmith, which now handles persistence, memory mounts, skill loading, and sandbox lifecycle. The release adds a new "Context Hub" feature letting agents persist and update working context across runs, and ships with an open-source reference repo, langchain-ai/managed-deepagents.

Key Takeaways

• Deep Agents' file-based harness convention (AGENTS.md for instructions, skills/ for reusable capabilities, subagents/ for delegation, tools.json for tool definitions) is unchanged — what's new is a managed runtime that hosts it instead of requiring self-managed infrastructure.
• Deploy path is local dev to production in one command: author and test an agent locally in Python or TypeScript, then push it to a /v1/deepagents endpoint on LangSmith.
• LangSmith now owns the operational layer previously left to the developer — persistence, memory mounts, skill loading, and sandbox lifecycle management — rather than requiring a custom deployment stack.
• Context Hub is the headline new capability: it lets a deployed agent persist and update its working context between separate runs, instead of starting from a blank slate on every invocation.
• The reference implementation is open source at langchain-ai/managed-deepagents, so teams can inspect or fork the harness structure rather than treat the managed runtime as a black box.
• This is a public beta, not GA — LangChain is opening the managed runtime to broader testing after running it privately, following the same beta-to-GA path it used for LangSmith BYOC.

Reel Script

Hook: Right now, if you build a serious AI agent, you're the one running the servers — the sandbox, the memory store, the deployment pipeline. LangChain just made that job disappear for anyone using their Deep Agents framework, and the entire deploy step is one command.

Core Concept: Deep Agents is LangChain's convention for structuring an agent's brain as files: an AGENTS.md that holds top-level instructions, a skills/ folder of reusable capabilities the agent can load on demand, a subagents/ folder for tasks it delegates to sub-agents, and a tools.json that declares what it can call. Think of it like a project folder for an AI worker instead of a human developer. Until now, that folder ran wherever you hosted it — your own servers, your own sandboxing, your own memory persistence. The managed beta changes only the hosting side: you still write the agent in Python or TypeScript and test it locally exactly as before, but shipping it to production is now one deploy command that pushes it to a LangSmith-hosted endpoint. LangSmith becomes the thing that keeps the agent's sandbox alive between calls, mounts its memory, and loads its skills — the undifferentiated infrastructure work that used to eat engineering time before you ever got to agent logic.

Hands-On: The part worth actually sketching is the deploy flow, because it's a clean before-and-after. Before: you write your Deep Agent locally, then you're on your own for a production environment — provisioning a sandbox to run it safely, wiring up a persistence layer so it remembers state between calls, and building your own mechanism for loading skills at runtime. After: same local agent, but the deploy step targets a /v1/deepagents endpoint, and everything on the other side of that command — sandbox lifecycle, memory mounts, skill loading — is LangSmith's job. The new piece layered on top is Context Hub, which solves a specific gap: a deployed agent normally starts cold on every new run, with no memory of what it decided last time. Context Hub gives it a place to persist and update working context across runs, so a long-running agent task can pick up where it left off instead of re-deriving state every invocation. And because the reference harness (langchain-ai/managed-deepagents) is open source, you can trace exactly what the managed runtime is doing with your AGENTS.md and skills/ files rather than trusting it blind.

Takeaway: This is LangChain betting that agent frameworks win by owning the boring infrastructure, not just the framework code — and for teams already using Deep Agents, skipping self-hosted sandbox and memory plumbing is a real time save, not a marketing line. If you're building on Deep Agents, pull the open-source repo and try the one-command deploy before committing to your own hosting stack.

Discussion