Live survey304 models · 14 providers · 23,592 auditsAudited implement · SAFE →What changedHow we verifyllms.txt

Agent skill · Audited from source

managed-deep-agents

skill · langchain-ai/langchain-skillsMIT licenceAudited 14 Nov 2026 · source 03d2719a5e81

★ 1,340pushed today
✓SAFEGrade B · 89/100 · 14 Nov 2026 · 03d2719
1,340repo stars · whole langchain-ai/langchain-skills

Is it safe? Yes — SAFE, grade B (89/100). We read this skill's source at commit 03d2719a5e81 and found no filesystem, network or shell access and no hard-coded secrets. What it does: 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…

Ask an AI about this pageGChatGPTCClaudePPerplexityGeGeminiXGrok
More
Cite

Cite this page

ModelsAtlas. “managed-deep-agents (langchain-ai/langchain-skills)”. Retrieved 14 Nov 2026. https://modelsatlas.com/skills/langchain-ai/managed-deep-agents

Trust audit

Audit 0.4.1 · source read 14 Nov 2026

Trust score89/100✓SAFE B
0 critical0 high0 medium0 low0 info

SAFE means nothing in the source contradicts what the skill says it does. Grade B is shared by 17,406 of 18,389 audited skills.

What the source does

  • FilesystemNone observedNo reads or writes in the source
  • NetworkNone observedNo outbound calls in the source
  • ShellNone observedNo commands run in the source
  • DependenciesPinnedNothing floats
  • SecretsNone foundNo keys in source

Five audit layers

LayerWhat we checkResultFindings
L0 ProvenanceRepo owner, licence, archive status, activityPASS0
L1 Static sourceSecrets, path traversal, supply chain, hidden codeNA0
L2 InstructionsPrompt injection, authority framing, hidden directivesPASS0
L3 InventoryThe files and declarations match the sourcePASS0
L4 SandboxRun in isolation and watch behaviourSKIPPED why0

Gates applied: no behavioural pass.

Findings (0)

No findings at any severity. We re-audit when the source changes.

Audit 0.4.1 · source sha 03d2719a5e81 · 14 Nov 2026Report an issue or request a re-scan

Provenance

Who published it, and what the verdict is pinned to

  • Publisherlangchain-ai GitHub organizationOwner of the repository this skill is read from
  • Source folderlangchain-ai/langchain-skills/config/skills/managed-deep-agentsThe exact folder we audited
  • LicenceMITAs the repository states it
  • Commit pinned for this verdict03d2719a5e81A new audit runs when the source changes
  • Repository statusNot archivedPushed today
  • Sandboxed runNot runSkills are read, not executed; layer L4 is skipped

What it tells the agent

Full source on GitHub ↗

Its 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…

---
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 with the mda CLI. Routes to the official docs page for each capability: instructions, skills, tools, MCP, connections, middleware, sandboxes, browser use, memory, identity, subagents, schedules, channels, runtime, Context Hub, deploy, and evals."
---

# 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`. It runs the open-source Deep Agents harness (see [[deep-agents-core]]) on LangSmith Agent Server, and adds managed sandboxes, browsers, memory, connections, schedules, and channels as project-file declarations.

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** on LangSmith Cloud and BYOC data planes.

## The docs are the source of truth

This skill stays thin on purpose. It tells you *what to build and where it goes*; the docs tell you *exactly how*. **Before writing a capability's file, fetch its docs page** from the [feature map](#feature-map) and follow it.

- Fetch the language-specific Markdown page: `https://docs.langchain.com/langsmith/<lang>/managed-deep-agents-<page>.md`, where `<lang>` is `python` or `javascript`. These pages contain only that language's examples.
- Load pages progressively — only the ones the current step needs.
- The full index is at `https://docs.langchain.com/llms.txt`.
- If the docs, this skill, and the installed package disagree, trust `mda --help` and the installed package's types, then the docs, then this skill.
- If you cannot fetch pages (no network), say so, work from this skill and the installed package, and tell the user which pages to check.

## 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 a capability to an existing MDA project.

Use a standard LangSmith Deployment instead (see [[langgraph-cli]], `langgraph deploy`) when the user needs custom server routes, a custom LangGraph auth handler, application code around the agent, their own backend/store/checkpointer, or a Python `state_schema`. To convert an existing `create_deep_agent` project, follow the `migrate` page.

# 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.

```text
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, a webhook from another system, nobody — it runs on a timer.)

Then ask only the follow-ups that the answers raise:

- Does it need to remember anything between conversations — shared knowledge, or per-person preferences?
- Does it need to reach a private API, or a third-party account on the user's behalf?
- Should anything require a human to approve before it happens?
- Does it need to write files, run code, or use websites that have no API?

Stop asking once you can name the capabilities. Two or three questions is usually enough.

## 2. Check the answer against the limits

Check the request against **[What MDA cannot do](#what-mda-cannot-do)**. If part of it 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.

## 3. Map the answer onto capabilities

Use the [feature map](#feature-map) to turn each need into a file, then read that file's docs page.

## 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:

```text
research-assistant, Python, on openai:gpt-5.5
  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

Follow the `quickstart` page. Scaffold with flags that match the plan:

```bash
uvx --from managed-deepagents mda init research-assistant --model openai:gpt-5.5 --no-sandbox
cd research-assistant && uv sync
```

TypeScript: `npx managed-deepagents init research-assistant --model openai:gpt-5.5 --no-sandbox`, then `npm install`. Run `mda` from inside the project (`uv run mda ...` / `npx mda ...`).

Add **one** capability at a time and confirm each works before the next. Do not create files the plan did not call for: a `sandbox/` directory turns on a sandbox (`mda init` scaffolds one unless `--no-sandbox`), and a root `browser.py` turns on a browser.

## 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`, copy keys from other projects, or echo key values.
- Confirm `.gitignore` covers `.env` and `.env.*` — `mda init` does this already.

The project needs `LANGSMITH_API_KEY` and its mode

Excerpt, first 6,000 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.

Install

Pinned to the audited commit 03d2719

Download folder ↗
uvx --from managed-deepagents mda init research-assistant --model openai:gpt-5.5 --no-sandbox
uv run mda dev       # compiles, opens LangSmith Studio
uv run mda deploy    # syncs Context Hub, uploads, waits for DEPLOYED

Commands as the repository documents them: shown, never run by us. Our verdict covers commit 03d2719a5e81 only.

Works in which agents?

What its own text says, not a test

AgentStatusMore
Claude CodeMentioned in its text, not testedSkills for Claude Code · About Claude Code
“Mentioned” means the skill’s text names the agent. We have not run it there.

Audit history

Every audit, every source change

  1. ✓SAFE B 89 / 100

    first audit · source 03d2719a5e81

README badge

For maintainers · shows the latest audit

ModelsAtlas: SAFE BMODELSATLASSAFE · B
[![ModelsAtlas: SAFE B](https://modelsatlas.com/skills/langchain-ai/managed-deep-agents/badge.svg)](https://modelsatlas.com/skills/langchain-ai/managed-deep-agents/)

The badge shows our verdict and grade for this skill, and links back to this page. It changes when the audit does.

Similar skills

Add this badge to your README

[![ModelsAtlas: SAFE B](https://modelsatlas.com/skills/langchain-ai/managed-deep-agents/badge.svg)](https://modelsatlas.com/skills/langchain-ai/managed-deep-agents/)

Questions about managed-deep-agents

Is managed-deep-agents safe to install?
The audit found nothing in the source that contradicts what it says it does, and graded it B (89/100). Grade A is held back for packages that have also passed a sandboxed behavioural run, which is why a clean skill reads B.
What can managed-deep-agents access on my machine?
The audit observed no filesystem, network or shell use at all in its source.
Which assistants does managed-deep-agents work with?
Its documentation mentions claude-code. That is what the text claims, not a compatibility test we ran.
How current is this page?
The grade is for one exact copy of the source (03d2719a5e81), read on 2026-11-14. The repository is watched, and a new audit runs when it changes — this is the first audit.

Sources

Spotted something wrong? Report a correction · Methodology

Keep going in your AI

Opens with this page as the source. We add nothing else to the prompt.