SkillAgentSearch skills...

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-agents

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

93/100

Category

Operations

Supported Platforms

Universal

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.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
13/20
Freshness
15/15

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 found

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.

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.

SkillScoreStarsUpdatedFormat
managed-deep-agents (this skill)by langchain-ai931.2k54d agoSKILL.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md
CowAgentby zhayujie10048.0ktodayCLAUDE.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.

name: 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 .env yourself, and do not copy a key from another project directory.
  • Do not echo key values to the terminal or into your reply.
  • Confirm .gitignore covers .env and .env.* — mda init does 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 uv for Python projects; Node.js and npm for TypeScript.
  • Credentials required by the selected model, either in the project .env or 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

View on GitHub
GitHub Stars1.2k
CategoryOperations
Updated1mo ago
Forks98

Languages

TypeScript

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions