deep-agents-core
Skill1 starsChanged 50 days agoMITView on GitHub
INVOKE THIS SKILL when building ANY Deep Agents application. Covers create_deep_agent(), harness architecture, SKILL.md format, and configuration options.
8 other projects use a version of this, 3 of them edited.
Adopted by
Most recently taken up by
- langchain-ai/design-agentword for word, first seen Oct 25, 2026
- langchain-ai/langchain-skillsword for word, first seen Oct 13, 2026
- willlee1995/skillsedited, first seen Oct 13, 2026
- gerald-donkor/poli-intelword for word, first seen Oct 11, 2026
- zoujindouGithub/agent-skillsedited, first seen Sep 2, 2026
- buduan/soul-graphword for word, first seen Jun 7, 2026
Used with
Projects with it also use managed-deep-agents, deepagents-python-quickstart and 2 more.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
LangChainSkillmanaged-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 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.
Also in 5 projects that use this
LangChainSkilldeepagents-python-quickstart
Scaffold a minimal local Deep Agent in Python by following the official quickstart, using provider-native web search instead of Tavily. Use when the user wants to quickly build or try a Deep Agent locally.
Also in 3 projects that use this
- +2 more from langchain-ai
Other versions8 projects use a version of this.
Word for word · 5
- langchain-ai/langchain-skills★ 1.3k100% same
- langchain-ai/design-agent★ 619100% same
- buduan/soul-graph★ 2100% same
- gerald-donkor/poli-intel★ 1100% same
- danielvogler/ai-skills-library★ 0100% same
Edited · 3
- langchain-ai/skills-benchmarks★ 116100% same
- willlee1995/skills★ 1100% same
- zoujindouGithub/agent-skills★ 144% same
Wrote their own version · 0
None found.
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository10 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- claude-apiSkill
- deep-agents-memorySkill
- deep-agents-orchestrationSkill
- deepagents-typescript-quickstartSkill
- langchain-dependenciesSkill
- langchain-typescript-quickstartSkill
- langgraph-typescript-quickstartSkill
- swarmSkill
The file
We split this skill into the rules it gives an agent
4 rules. About 0 are common, 4 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈4
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 45
Create a basic deep agent with a custom tool and invoke it with a user message.
- Distinctive: line 143
Every deep agent has access to:
- Distinctive: line 344
Use consistent thread_id to maintain conversation context across invocations.
- Distinctive: line 408
Use specific descriptions to help agents decide when to use a skill.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
<overview>
Deep Agents are an opinionated agent framework built on LangChain/LangGraph with built-in middleware:- Task Planning: TodoListMiddleware for breaking down complex tasks
- Context Management: Filesystem tools with pluggable backends
- Task Delegation: SubAgent middleware for spawning specialized agents
- Long-term Memory: Persistent storage across threads via Store
- Human-in-the-loop: Approval workflows for sensitive operations
- Skills: On-demand loading of specialized capabilities
The agent harness provides these capabilities automatically - you configure, not implement.
</overview>
<when-to-use>| Use Deep Agents When | Use LangChain's create_agent When |
| Multi-step tasks requiring planning | Simple, single-purpose tasks |
| Large context requiring file management | Context fits in a single prompt |
| Need for specialized subagents | Single agent is sufficient |
| Persistent memory across sessions | Ephemeral, single-session work |
</when-to-use><middleware-selection>| If you need to... | Middleware | Notes |
| Track complex tasks | TodoListMiddleware | Default enabled |
| Manage file context | FilesystemMiddleware | Configure backend |
| Delegate work | SubAgentMiddleware | Add custom subagents |
| Add human approval | HumanInTheLoopMiddleware | Requires checkpointer |
| Load skills | SkillsMiddleware | Provide skill directories |
| Access memory | MemoryMiddleware | Requires Store instance |
</middleware-selection><ex-basic-agent>
<python>
Create a basic deep agent with a custom tool and invoke it with a user message.from deepagents import create_deep_agent
from langchain.tools import tool
@tool
def get_weather(city: str) -> str:
"""Get the weather for a given city."""
return f"It is always sunny in {city}"
agent = create_deep_agent(
model="claude-sonnet-4-5-20250929",
tools=[get_weather],
system_prompt="You are a helpful assistant"
)
config = {"configurable": {"thread_id": "user-123"}}
result = agent.invoke({
"messages": [{"role": "user", "content": "What's the weather in Tokyo?"}]
}, config=config)</python>
<typescript>
Create a basic deep agent with a custom tool and invoke it with a user message.import { createDeepAgent } from "deepagents";
import { tool } from "@langchain/core/tools";
import { z } from "zod";
const getWeather = tool(
async ({ city }) => `It is always sunny in ${city}`,
{ name: "get_weather", description: "Get weather for a city", schema: z.object({ city: z.string() }) }
);
const agent = await createDeepAgent({
model: "claude-sonnet-4-5-20250929",
tools: [getWeather],
systemPrompt: "You are a helpful assistant"
});
const config = { configurable: { thread_id: "user-123" } };
const result = await agent.invoke({
messages: [{ role: "user", content: "What's the weather in Tokyo?" }]
}, config);</typescript>
</ex-basic-agent><ex-full-configuration>
<python>
Configure a deep agent with all available options including subagents, skills, and persistence.from deepagents import create_deep_agent
from deepagents.backends import FilesystemBackend
from langgraph.checkpoint.memory import MemorySaver
from langgraph.store.memory import InMemoryStore
agent = create_deep_agent(
name="my-assistant",
model="claude-sonnet-4-5-20250929",
tools=[custom_tool1, custom_tool2],
system_prompt="Custom instructions",
subagents=[research_agent, code_agent],
backend=FilesystemBackend(root_dir=".", virtual_mode=True),
interrupt_on={"write_file": True},
skills=["./skills/"],
checkpointer=MemorySaver(),
store=InMemoryStore()
)</python>
<typescript>
Configure a deep agent with all available options including subagents, skills, and persistence.import { createDeepAgent, FilesystemBackend } from "deepagents";
import { MemorySaver, InMemoryStore } from "@langchain/langgraph";
const agent = await createDeepAgent({
name: "my-assistant",
model: "claude-sonnet-4-5-20250929",
tools: [customTool1, customTool2],
systemPrompt: "Custom instructions",
subagents: [researchAgent, codeAgent],
backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
interruptOn: { write_file: true },
skills: ["./skills/"],
checkpointer: new MemorySaver(),
store: new InMemoryStore()
});</typescript>
</ex-full-configuration><built-in-tools>
Every deep agent has access to:- Planning:
write_todos- Track multi-step tasks - Filesystem:
ls,read_file,write_file,edit_file,glob,grep - Delegation:
task- Spawn specialized subagents</built-in-tools>
SKILL.md Format
<skill-md-format>
Skills use **progressive disclosure** - agents only load content when relevant.Directory Structure
skills/
└── my-skill/
├── SKILL.md # Required: main skill file
├── examples.py # Optional: supporting files
└── templates/ # Optional: templatesSKILL.md Format
---
name: my-skill
description: Clear, specific description of what this skill does
---
# Skill Name
## Overview
Brief explanation of the skill's purpose.
## When to Use
Conditions when this skill applies.
## Instructions
Step-by-step guidance for the agent.</skill-md-format><skills-vs-memory>| Skills | Memory (AGENTS.md) |
| On-demand loading | Always loaded at startup |
| Task-specific instructions | General preferences |
| Large documentation | Compact context |
| SKILL.md in directories | Single AGENTS.md file |
</skills-vs-memory><ex-skills-with-filesystem-backend>
<python>
Set up an agent with skills directory and filesystem backend for on-demand skill loading.from deepagents import create_deep_agent
from deepagents.backends import FilesystemBackend
from langgraph.checkpoint.memory import MemorySaver
agent = create_deep_agent(
backend=FilesystemBackend(root_dir=".", virtual_mode=True),
skills=["./skills/"],
checkpointer=MemorySaver()
)
result = agent.invoke({
"messages": [{"role": "user", "content": "Use the python-testing skill"}]
}, config={"configurable": {"thread_id": "session-1"}})</python>
<typescript>
Set up an agent with skills directory and filesystem backend for on-demand skill loading.import { createDeepAgent, FilesystemBackend } from "deepagents";
import { MemorySaver } from "@langchain/langgraph";
const agent = await createDeepAgent({
backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
skills: ["./skills/"],
checkpointer: new MemorySaver()
});
const result = await agent.invoke({
messages: [{ role: "user", content: "Use the python-testing skill" }]
}, { configurable: { thread_id: "session-1" } });</typescript>
</ex-skills-with-filesystem-backend><ex-skills-with-store-backend>
<python>
Load skill content into a Store backend for environments without filesystem access.from deepagents import create_deep_agent
from deepagents.backends import StoreBackend
from deepagents.backends.utils import create_file_data
from langgraph.store.memory import InMemoryStore
store = InMemoryStore()
# Load skill content into store
skill_content = """---
name: python-testing
description: Best practices for Python testing with pytest
---
# Python Testing Skill
..."""
store.put(
namespace=("filesystem",),
key="/skills/python-testing/SKILL.md",
value=create_file_data(skill_content)
)
agent = create_deep_agent(
backend=lambda rt: StoreBackend(rt),
store=store,
skills=["/skills/"]
)</python>
</ex-skills-with-store-backend><boundaries>What Agents CAN Configure
- Model selection and parameters
- Additional custom tools
- System prompt customization
- Backend storage strategy
- Which tools require approval
- Custom subagents with specialized tools
What Agents CANNOT Configure
- Core middleware removal (TodoList, Filesystem, SubAgent always present)
- The write_todos, task, or filesystem tool names
- The SKILL.md frontmatter format
</boundaries>
<fix-checkpointer-for-interrupts>
<python>
Interrupts require a checkpointer.# WRONG
agent = create_deep_agent(interrupt_on={"write_file": True})
# CORRECT
agent = create_deep_agent(interrupt_on={"write_file": True}, checkpointer=MemorySaver())</python>
<typescript>
Interrupts require a checkpointer.// WRONG
const agent = await createDeepAgent({ interruptOn: { write_file: true } });
// CORRECT
const agent = await createDeepAgent({ interruptOn: { write_file: true }, checkpointer: new MemorySaver() });</typescript>
</fix-checkpointer-for-interrupts><fix-store-for-memory>
<python>
StoreBackend requires a Store instance for persistent memory across threads.# WRONG
agent = create_deep_agent(backend=lambda rt: StoreBackend(rt))
# CORRECT
agent = create_deep_agent(backend=lambda rt: StoreBackend(rt), store=InMemoryStore())</python>
<typescript>
StoreBackend requires a Store instance for persistent memory across threads.// WRONG
const agent = await createDeepAgent({ backend: (config) => new StoreBackend(config) });
// CORRECT
const agent = await createDeepAgent({ backend: (config) => new StoreBackend(config), store: new InMemoryStore() });</typescript>
</fix-store-for-memory><fix-thread-id-for-conversations>
<python>
Use consistent thread_id to maintain conversation context across invocations.# WRONG: Each invocation is isolated
agent.invoke({"messages": [{"role": "user", "content": "Hi"}]})
agent.invoke({"messages": [{"role": "user", "content": "What did I say?"}]})
# CORRECT
config = {"configurable": {"thread_id": "user-123"}}
agent.invoke({"messages": [...]}, config=config)
agent.invoke({"messages": [...]}, config=config)</python>
<typescript>
Use consistent thread_id to maintain conversation context across invocations.// WRONG: Each invocation is isolated
await agent.invoke({ messages: [{ role: "user", content: "Hi" }] });
await agent.invoke({ messages: [{ role: "user", content: "What did I say?" }] });
// CORRECT
const config = { configurable: { thread_id: "user-123" } };
await agent.invoke({ messages: [...] }, config);
await agent.invoke({ messages: [...] }, config);</typescript>
</fix-thread-id-for-conversations><fix-frontmatter-required># WRONG: Missing frontmatter in SKILL.md
# My Skill
This is my skill...
# CORRECT: Include YAML frontmatter
---
name: my-skill
description: Python testing best practices with pytest fixtures and mocking
---
# My Skill
This is my skill...</fix-frontmatter-required><fix-backend-for-skills>
<python>
Skills require a proper backend to load from the filesystem.# WRONG: Skills won't load without proper backend
agent = create_deep_agent(skills=["./skills/"])
# CORRECT: Use FilesystemBackend for local skills
agent = create_deep_agent(
backend=FilesystemBackend(root_dir=".", virtual_mode=True),
skills=["./skills/"]
)</python>
</fix-backend-for-skills><fix-specific-skill-descriptions>
Use specific descriptions to help agents decide when to use a skill.# WRONG: Vague description
---
name: helper
description: Helpful skill
---
# CORRECT: Specific description
---
name: python-testing
description: Python testing best practices with pytest fixtures, mocking, and async patterns
---</fix-specific-skill-descriptions><fix-subagent-skills>
<python>
Skills are not inherited by subagents - provide them explicitly.# WRONG: Custom subagents don't inherit skills
agent = create_deep_agent(
skills=["/main-skills/"],
subagents=[{"name": "helper", ...}] # No skills
)
# CORRECT: Provide skills explicitly
agent = create_deep_agent(
skills=["/main-skills/"],
subagents=[{"name": "helper", "skills": ["/helper-skills/"], ...}]
)</python>
</fix-subagent-skills>Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

