LangChain opens Managed Deep Agents public beta with sandboxes and LangSmith deploys

• Managed Deep Agents is in public beta: LangChain's announcement says teams can author agents in Python or TypeScript, test locally, and deploy to a managed LangSmith runtime.
• The terminal path is scaffold, local Studio, deploy: LangChain's CLI post lists channels, sandboxes, memory, identity, and Harbor evals as first-class primitives.
• The product bundles the harness and the infra while leaving business logic with the developer, the split shown in the harness-and-infra diagram.
• LangChain is pairing the runtime with an eval-loop thesis: agents write code, traces become signals, and signals become evals, according to Vtrivedy10.
• Open-weight production is part of the backdrop: 1 in 3 active LangSmith teams ran an open-weight model in July, according to LangChain's Signal post.

The launch post includes an exact project tree, including identity, memory, channels, middleware, schedules, connectors, skills, sandbox, and evals. The quickstart adds the beta catch: LangSmith Cloud, US region only. The eval path compiles Harbor handoffs under .mda/evals/, while the tutorial shows a daily scheduled research agent backed by durable memory.

Managed Deep Agents is a hosted path for Deep Agents, LangChain's open-source harness. LangChain's stack explainer defines the layers as LangGraph for runtime, LangChain for framework, and Deep Agents for harness.

From LangChain's CLI post and the quickstart, the developer path is:

• Install managed-deepagents with uv tool install managed-deepagents or npm install -g managed-deepagents.
• Run mda init research-assistant.
• Run locally with mda dev in LangSmith Studio.
• Deploy with mda deploy to LangSmith-managed infrastructure.
• Keep control of model, instructions, tools, middleware, subagents, and business logic.
• Let LangSmith handle persistence, memory mounts, skill loading, sandbox lifecycle, and deployment.
• Public beta scope is LangSmith Cloud in the US region, CLI-first while the supported API is finalized.

The short mental model came from hwchase17's diagram: managed agents bundle the harness and infrastructure, while teams provide prompts, skills, tools, and subagents.

The launch post names eight production primitives:

• Durable execution: pause, retry, and resume long-running agents without losing work.
• Streaming: expose progress while the agent is working.
• Persistence: keep thread state across turns, restarts, and failures.
• Sandboxes: give agents isolated file, code, dependency, and CLI environments.
• Evals: test behavior, tool use, and state changes before and after deployment.
• Channels: connect agents to work surfaces like Slack.
• Memory: carry durable context and preferences across conversations.
• Identity: run with user context and access boundaries.

A Managed Deep Agent is a repo project, not a dashboard-only config. The launch post lists this shape:

mda deploy compiles the project, syncs deploy-owned context to LangSmith Context Hub, uploads the build, and creates the hosted deployment.

Managed Deep Agents gives LangSmith Sandboxes first-class support. The launch post says each durable thread gets its own sandbox by default, while scope="agent" shares one sandbox across threads.

Harbor evals are packaged through two commands:

• mda evals init creates checked-in Harbor tasks under evals/.
• mda evals compile builds the handoff under .mda/evals/, including the compiled agent artifact, adapter, and example Harbor job config.

Harbor still runs directly, either locally in Docker or in a configured Harbor environment. Managed Deep Agents supplies the bridge from a production-ready agent to a Harbor-ready artifact.

The managed runtime mounts channel endpoints, verifies provider signatures, stamps identity, and can reply in the originating conversation. The launch example uses a Slack channel file with app_mention, direct_message, and auto_reply=True.

Memory is backed by Context Hub and exposed at runtime under /memories/. The launch post says deploy syncs instructions and skills but preserves runtime-created memories, so redeploying the harness does not wipe what the agent learned.

Identity is basic in the beta. Defining an OIDC provider in identity.py or identity.ts scopes threads by end-user ID under the same deployment.

Vtrivedy10 framed the launch around self-improving agents driven by evals and environments. The loop they described is concrete:

• Treat every task as an agent writing code to define an agent for that task.
• Iterate on harness code, models, configurations, and evals.
• Trace agent runs out of the box.
• Run agents over traces to mine signals.
• Convert those signals into evals or environments.
• Harness-engineer or post-train toward cheaper and better agents.
• Keep harness config, model choice, data, and evals open to the team running the system.

That loop still keeps the base harness lightweight. In Vtrivedy10's RLM reply, Recursive Language Model style decomposition is available through middleware, but most current end users do not need it in their agents. A follow-up pointed to Sydney Runkle's RLM guide for benchmarks and examples Vtrivedy10's benchmark reply.

LangChain's adjacent Engine course uses the same production-loop framing: monitor production traces, identify issues, propose fixes, run experiments, deploy, then monitor for regressions LangSmith Engine course post.

LangChain tied the release to Harmonic's Scout rebuild. Austin Berke, Lead AI Product Engineer at Harmonic, said Scout was rebuilt on Deep Agents and quadrupled retention in the cited fireside chat Harmonic's retention post.

LangChain also pointed to Madrigal Pharma, where LangSmith traces helped reduce time to production for agentic use cases from 12 weeks to 2 Madrigal Pharma trace demo.

The model-agnostic pitch lands differently next to LangSmith's own observability data. LangChain said 1 in 3 active teams ran an open-weight model in July, up from 1 in 5 a year earlier, and teams running an open-weight model daily grew 9x year over year.

The same thread said closed-model daily usage grew 4.8x year over year, based on LangSmith Observability data across billions of agent runs LangSmith Signal thread.

The launch landed alongside a broader Deep Agents onboarding push. LangChain's course update lists new LangChain Academy material for Deep Agents v0.7:

• Dynamic and async subagents.
• A course tutor skill that turns a coding agent into a personal tutor.
• Capstone projects and practice exercises.
• TypeScript support.
• Updates aligned with Deep Agents v0.7.

Skills get their own framing too: Sydney Runkle called them "fancy prompts" that are easy to share and help agents narrow in on a task LangChain's skills clip.