managed-deep-agents
INVOKE THIS SKILL when building, testing, or deploying Managed Deep Agents in LangSmith. Walks a user through their first agent end to end — interviewing them about what they want to build, mapping it onto what MDA can actually do, then scaffolding and deploying it.
Install / Use
npx skills add langchain-ai/langchain-skills --skill managed-deep-agentsInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
OperationsSupported Platforms
Our assessment of managed-deep-agents
managed-deep-agents scores 93/100 on our quality scale, 181st of 745 Operations skills we index (top 25%).
Its SKILL.md is 34 KB long, well organised into 41 sections with 27 code examples: a thorough specification that gives an agent plenty to work with.
With 1,246 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so managed-deep-agents is actively maintained.
- Our last check on 2026-10-26 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
managed-deep-agents compared with similar skills
All 4 of these similar skills score higher than managed-deep-agents; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| managed-deep-agents (this skill)by langchain-ai | 93 | 1.2k | 54d ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
| CowAgentby zhayujie | 100 | 48.0k | today | CLAUDE.md |
Frequently asked questions
- How do I install managed-deep-agents?
- Run
npx skills add langchain-ai/langchain-skills --skill managed-deep-agents. The install tabs above show the steps for each supported agent. - Which AI agents does managed-deep-agents work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is managed-deep-agents safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is managed-deep-agents still maintained?
- The repository was last updated about 2 months ago, so managed-deep-agents is actively maintained.
Skill content
View source on GitHubname: managed-deep-agents description: "INVOKE THIS SKILL when building, testing, or deploying Managed Deep Agents in LangSmith. Walks a user through their first agent end to end — interviewing them about what they want to build, mapping it onto what MDA can actually do, then scaffolding and deploying it. Covers the file-based project layout; define_deep_agent / defineDeepAgent; instructions, skills, memory, identity, tools, MCP servers, connections, middleware, sandboxes, schedules, channels, and evals; the mda CLI; GitHub deployments; and Context Hub."
Managed Deep Agents
Overview
Managed Deep Agents (MDA) is a hosted runtime for code-first Deep Agents in LangSmith. You author an agent in Python or TypeScript, test it locally with mda dev, and deploy it with mda deploy or from a connected GitHub repository in LangSmith. It pairs the open-source Deep Agents harness (see [[deep-agents-core]]) with managed infrastructure: durable runs, sandboxes, Context Hub-backed instructions and skills, memory, traces, and hosted LangGraph deployment.
The core idea is that an agent is a directory. A file's location determines its role, and the CLI compiles that directory into a managed LangGraph app.
MDA is in public beta and runs on US LangSmith Cloud only.
When to use
Use this skill when the user wants to build a Deep Agent in code and run it on LangSmith without operating their own server, or to add tools, MCP servers, connections, middleware, memory, identity, schedules, channels, skills, sandboxes, or evals to one.
Use a standard LangSmith Deployment instead (see [[langgraph-cli]], langgraph deploy) when the user needs custom server routes or runtime wiring inside the agent deployment, stronger isolation, maximum scalability, or a region other than US. MDA can still sit behind a separately operated backend that authenticates callers and proxies trusted identity headers.
Guide the user through their first agent
When a user is new to MDA, or says anything like "help me build an agent", do not scaffold immediately. Run this flow. It costs two questions and prevents building something the platform cannot host.
ask what they want to build -> check it against the limits -> confirm the shape
-> scaffold -> wire the smallest thing that runs -> mda dev -> deploy
1. Ask what they want to build
Ask in plain language, not in MDA vocabulary. The user does not yet know what a "channel" or a "sandbox" is.
Ask these two things first:
- What should the agent do? ("Answer questions about our docs", "triage incoming bugs", "post a summary every morning".)
- Who or what talks to it, and from where? (Them in a browser, their app's users, a Slack workspace, nobody — it runs on a timer.)
Then ask only the follow-ups that the answers actually raise:
- Does it need to remember anything between separate conversations?
- Does it need to reach a private API, database, or internal service?
- Should anything require a human to approve before it happens?
- Does it need to write files or run code?
Stop asking once you can name the capabilities. Two or three questions is usually enough.
2. Check the answer against the limits
Before you promise anything, check the request against What MDA cannot do below. If part of the request is out of scope, say so in one sentence, offer the nearest supported thing, and keep going with the rest. Do not quietly build a smaller agent and present it as what they asked for.
The common redirect: if they need custom HTTP routes, their own auth, or non-US hosting, tell them MDA is the wrong layer and point at langgraph deploy ([[langgraph-cli]]).
3. Map the answer onto capabilities
| What the user describes | What to reach for | Where it lives |
| --- | --- | --- |
| How it should behave, its tone, its rules | Instructions | instructions.md |
| Calls our API / database / internal service | Authored tools | tools/ |
| Uses a remote MCP server | MCP declaration | tools/mcp.py or tools/mcp.ts |
| Uses a workspace secret or OAuth grant | Connection | connections.get(...) + mda connections |
| A procedure it should follow for certain tasks | Skills | skills/<name>/SKILL.md |
| Remembers things across conversations | Durable memory (read the warning) | memory.py |
| Runs on a timer, no user message | Schedules | schedules/<name>.py |
| Lives in Slack | Channels | channels/slack.py |
| Writes files, runs code or shell commands | Sandbox | sandbox/__init__.py |
| Ask me before it does X | Human-in-the-loop | interrupt_on= |
| Users must not see each other's chats | Supabase identity | identity.py |
| Must return structured data, not prose | Structured output | response_format= |
| Hand off specialized work | Subagents | subagents= |
| PII redaction, call limits, retries, logging | Middleware | middleware/ |
| Prove it still works as we change it | Harbor evals | evals/<task>/ |
4. Confirm the shape before writing files
State the plan back in one short block and get agreement. Name the model, and list only the capabilities you are actually going to create:
research-assistant, Python, on anthropic:claude-sonnet-4-6
instructions.md how it researches and cites
tools/search.py web search
schedules/ weekday 8am digest
no memory, no sandbox, no channel
5. Scaffold and wire the smallest thing that runs
Scaffold with the flags that match the plan, so the project starts correct instead of being edited into shape:
mda init research-assistant --model anthropic:claude-sonnet-4-6
cd research-assistant
uv sync
Then add one capability at a time and confirm each one works before adding the next. A first agent that answers with good instructions and one real tool is a better starting point than a scaffold with every directory filled in.
Do not create directories the plan did not call for. Empty or unused skills/, channels/, or schedules/ directories are noise, and a sandbox/ directory the user does not need turns on a sandbox they will pay attention to for no reason (mda init --no-sandbox skips it).
6. Handle keys without touching their secrets
mda init writes a .env with empty placeholders. Fill in the names the project needs and let the user paste the values:
- Do not write live credential values into
.envyourself, and do not copy a key from another project directory. - Do not echo key values to the terminal or into your reply.
- Confirm
.gitignorecovers.envand.env.*—mda initdoes this already.
The project needs LangSmith authentication to deploy and whatever credentials its selected model requires. For a normal provider model, uncomment its key (ANTHROPIC_API_KEY, OPENAI_API_KEY, …) and let the user supply it through .env or LangSmith workspace secrets. An explicitly configured Gateway-backed client uses its Gateway/LangSmith credential instead of a provider key.
7. Run it locally, then deploy
mda dev . # compiles, opens LangSmith Studio, hot reloads
mda deploy . # syncs Context Hub, uploads, waits for DEPLOYED
Have the user actually send a message in Studio and confirm the agent calls the tool before deploying. mda deploy prints the deployment dashboard URL; open it to inspect builds, revisions, and traces.
What MDA cannot do
Check requests against this list before agreeing to build them. Being straight about a limit early is cheaper than discovering it at deploy time.
| Limit | Consequence |
| --- | --- |
| US LangSmith Cloud only | No self-hosted, no hybrid, no EU region. Needs langgraph deploy. |
| No public management API | Use mda or LangSmith's GitHub deployment UI to create and update agents. Do not invent a public create/update REST flow. |
| Slack is the only channel | No Discord, Teams, email, or SMS channel. Remote MCP servers for those products are tools, not channels. |
| Memory is deployment-shared | One /memories/agent/ tree for all callers. There is no per-user memory. |
| One agent entry per project | No multiple graphs in one project. Use subagents= for delegation. |
| Schedules must be static literals | No env vars, function calls, or computed values in a schedule declaration. |
| Build archive capped at 200 MB | Large fixtures or model weights in the project will fail the deploy. |
| Managed fields are not yours to set | backend, store, checkpointer, memory, skills, and the system prompt are injected by the runtime. |
| Sandbox scope is managed | Sandboxes are one per thread. Agent-shared sandbox scope is no longer supported. |
Prerequisites
- A workspace with Managed Deep Agents public beta access, and a LangSmith API key for it.
- Python and
uvfor Python projects; Node.js and npm for TypeScript. - Credentials required by the selected model, either in the project
.envor as LangSmith workspace secrets.
Install the CLI. Both packages ship the same mda binary:
uv tool install --prerelease allow managed-deepagents # Python
npm install -g managed-deepagents@dev # TypeScript
mda init generates a project with its own manifest — run uv sync (or npm install) inside that project before mda dev.
Project layout
The path passed to mda is the project root. A file's location determines its role:
my-agent/
agent.py | agent.ts # Required: exports the named `agent`
instructions.md # System prompt -> Context Hub
skills/<name>/SKILL.md # Task-specific procedures -> Context Hub
tools/ # Authored tools the agent imports
mcp.py | mcp.ts # Optional remote MCP server declaration
middleware/ # Authored middleware the agent imports
identity.py | identity.ts # Who may call the deployment
memory.py | memory.ts # Opt-in durable memory
channels/<name>.py # External messaging (Slack)
schedules/<name>.py # Managed cron schedules
sandbox/__init__.py | index.ts # Managed sandbox
pyproject.toml | package.json # Dependencies
.env # Auth + runtime secrets, never archived
evals/<task>/ # Harbor evals, not deployed
Only the agent entry is required. tools/ and middleware/ are plain conventions — MDA copies project files verbatim, so any local module the agent imports works. The other paths take on managed meaning when present. The TypeScript agent entry may be agent.ts or agent.tsx; managed auxiliary declarations also accept .mts and .cts where discovered.
Define the agent
The agent entry returns a pre-runtime spec, not a compiled graph.
# agent.py
from managed_deepagents import define_deep_agent
from tools.search import web_search
agent = define_deep_agent(
name="research-assistant",
model="anthropic:claude-sonnet-4-6",
tools=[web_search],
)
// agent.ts
import { defineDeepAgent } from "managed-deepagents";
import { webSearch } from "./tools/search";
export const agent = defineDeepAgent({
name: "research-assistant",
model: "anthropic:claude-sonnet-4-6",
tools: [webSearch],
});
name is required. Pass a static string starting with a letter, containing only letters, numbers, underscores, or hyphens. It becomes the LangGraph assistant ID and the default deployment name; override the latter with mda deploy --name.
Author-set fields: name, model, tools, middleware, subagents, permissions, interrupt_on / interruptOn, response_format / responseFormat, context_schema / contextSchema, cache, debug, metadata.
Managed fields — do not set: backend, store, checkpointer, memory, skills, system_prompt / systemPrompt.
Model IDs use {provider}:{model_id} and r
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
CowAgent
48.0kOpen-source personal AI assistant & Agent Harness. Plans tasks, runs tools and skills, self-evolves with memory and knowledge. Multi-agent, multi-model, multi-channel. Lightweight, extensible, one-line install.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
