Deploying mission-critical agents is about more than getting a demo to work. You need dependable runs, the right context at the right time, and safe ways for the agent to use tools and code while humans stay in control when it really matters.
This article explains what a Deep Agents harness includes, why it exists, and how Managed Deep Agents connects that harness to production-grade infrastructure. You’ll also see how teams move from local prototyping to production deployment using LangChain and LangSmith.
Managed Deep Agents maximise the value of a domain-specific harness
A Deep Agents approach starts by building a base harness you can shape for your own domain. That harness sits around the model itself, including skills, memory, and the system prompt, so the model gets the right context when it needs it.
The key idea is simple: models only perform as well as the context they’re given. When the harness supplies the right information at the right moment, the agent can reason and act in a way that fits your task, not just generic prompts.
Managed Deep Agents then pairs this harness with production infrastructure. That means fewer moving parts for your team to manage, while you can still focus on the business logic and domain expertise.
The four key areas of a Deep Agents harness
A Deep Agents harness is built around four core areas. Together, they support execution, context, task splitting, and human oversight.
Execution environment supports file use and safe code runs
The harness includes an execution environment so the agent can work with a file system. It can also write code and then execute it in a safe environment.
That “safe environment” matters when an agent has to run code generated during a real workflow, not just in a controlled test.
Context management keeps skills and memory in the right place
Context management supports progressive disclosure of skills. It also helps the agent manage memory, including ways to summarise conversations and compact or offload context when needed.
If a tool returns a large output, the harness can store it in the file system and let the model reference it only when it’s useful.
Delegation breaks work into sub-tasks for specialised handling
Delegation lets the agent split a task and hand parts of it to subagents. These subagents can be specialised or general-purpose, depending on what the job calls for.
This helps when one task needs different kinds of reasoning, formatting, or tool use.
Steering with a human in the loop keeps control inside the workflow
Human oversight isn’t an afterthought. The harness supports steering through human-in-the-loop, so the agent can wait for approval before it continues an action.
This is especially important for real operations, where permissions and the “right moment” for a step need to be checked.
How production workflows are realised with Managed Deep Agents
Most teams start by prototyping locally. Getting an agent working on your domain task can feel impressive, because you can quickly prove it can do the job.
As you move towards production, things get more involved. You need multi-tenancy, persistence, durable execution, and streaming. If you build it all from scratch, your team ends up owning task queues, prioritisation, runtime reliability, and more.
Managed Deep Agents reduces that burden by tightly coupling the execution environment, the harness, and the infrastructure. That way, developers can focus on improving the business logic that makes the agent useful in your specific domain.
It also supports durable execution and reliable task handling. Instead of stitching together separate systems, the setup is built to run as one coherent production unit.
The production ecosystem and features that support reliability
Managed Deep Agents runs on LangSmith Deployment, which acts as a proven production runtime. That foundation helps with the reliability side that often slows teams down when they scale.
For orchestration across many agents, MCP and A2A support coordination patterns. When you need a clear way for business users to interact with instructions and skills, Context Hub provides a shared surface for collaboration.
For safe tool use, LangSmith Sandboxes support code execution in a controlled environment. Governance and quality are supported through LLM Gateway, plus tracing and evals.
Evals are designed to fit into the workflow. With an integration with Harbor, setting up checks and iterating on eval datasets becomes a managed process.
- Context Hub for collaborating on context, instructions, and skills
- LangSmith Sandboxes for safe code execution when the agent writes and runs code
- LLM Gateway, tracing, and evals for governance and review
Where search data matters, a partnership with Parallel is available with zero data retention. Access to search APIs can be added via MCP, so the agent can use the information through LangChain and LangSmith.
How to scaffold, develop, and deploy a Deep Agent
Building a working agent project is easier when the structure stays consistent. Managed Deep Agents scaffolds a coherent project, so developers can quickly see how different agents are built and where to make changes.
You start by using mda init to scaffold a project. It takes a name, such as a GTM agent, and generates the project structure that supports the harness and production setup.
Next, run it locally with mda dev. This supports testing the agent loop logic and the core behaviour, including instructions, playbooks, and tool connections.
When you’re ready to ship, deploy with mda deploy. That moves the agent into production runtime on LangSmith Deployment.
In practice, an agent definition can include an agent loop in agent.ts or agent.py, alongside instructions that define how the agent should behave. Playbooks tie actions to skills, while tools can connect to systems such as MCP servers.
Authentication and identity also fit into the workflow, along with how the agent remembers. A central auth handler service establishes the principal for a call, then passes that into the runtime context so tools and other connections can apply the right user context.
Credentials can be controlled by scope. Depending on the tool and channel, you can define whether the agent uses user-scoped credentials or agent-scoped/service credentials, such as for shared channels where private data shouldn’t leak.
Because the underlying runtime supports durable execution, the agent can pause and wait indefinitely for access to certain systems. That means it can ask the user to authorise in a channel like Slack, then continue later from where it left off once the user returns.
Memory is handled in Managed Deep Agents as well. You can define agent-level memory to improve procedural memory, or user memory for preferences, such as how someone likes to write emails and reach out to customers. Channel-based controls help ensure memory and credentials are appropriate for where the agent is called.
Conclusion
Managed Deep Agents bring together Deep Agents harness design and production-ready infrastructure, so your domain expertise can run reliably. You get clearer control over context, memory, delegation, and human-in-the-loop, while the runtime responsibilities that often derail teams are handled in a managed way.
If you’re ready to move beyond local demos, the workflow from mda init to mda dev, and then mda deploy, is a practical place to start.
Frequently Asked Questions
What is Managed Deep Agents?
Managed Deep Agents is the integrated approach that combines Deep Agents with production infrastructure, so domain-specific agents can run reliably in production using LangSmith Deployment and related components.
How do you start a new agent project with this system?
Use mda init to scaffold the project structure for a named agent. Build and test locally with mda dev, then deploy with mda deploy when it’s ready for production.
What role does Context Hub play?
Context Hub provides a surface for business users to interact with context, instructions, and skills. It also supports collaboration, sharing, and version control in a shared space.
How is durable execution handled?
Durable execution is supported through the LangGraph runtime. The agent can pause and wait for access to systems, then continue the run later, such as after a user completes an authorisation step.
What tooling supports evaluation and governance?
Evals integrate with Harbor for setting up checks and iterating on eval datasets and experiments. Governance features include LLM Gateway, tracing, and evals support in the Managed Deep Agents workflow.
