deepagents-cli-deepagents-skill

A LangGraph Deep Agents Skill for the LangChain Deep Agents CLI

Scaffold a production-grade Deep Agents Skill that gives LangGraph Deep Agents comprehensive, structured knowledge of the Deep Agents CLI — commands, providers, memory, sandboxes, streaming, and SDK customization.

Installation · What Gets Installed · Skill Resources · Official Documentation

Overview

The Deep Agents CLI is LangChain's terminal coding agent — a LangGraph-powered assistant with persistent memory, 20+ LLM provider integrations, sandboxed code execution, and a composable skills system. Its surface area spans interactive and non-interactive modes, a rich slash-command REPL, programmatic SDK customization, streaming output, and the Agent Client Protocol for editor integration.

This package scaffolds a Deep Agents Skill that encodes that entire surface area as structured, on-demand knowledge. When the skill is active, the agent can accurately assist with any Deep Agents CLI task — from launching a first session to building production subagent pipelines — without requiring repeated context or pasted documentation.

The skill follows the Agent Skills open standard and loads automatically via progressive disclosure when relevant.

Why This Skill?

This isn't just a documentation reference. When your coding agent has this skill loaded, it can actively help you work with deepagents -- not just answer questions about it.

• Learn by building. Ask your agent to walk you through deepagents concepts, then have it set up a session, configure providers, or scaffold a skill -- all from within your current editor.
• Author custom agents. The skill includes the full SDK reference for create_deep_agent(), middleware, subagents, and backends. Your agent can help you design and implement specialized deepagents workflows tailored to your stack.
• Extend deepagents itself. Clone the deepagents repo, install this skill, and let your coding agent help you customize the framework -- adding tools, modifying behavior, or building production pipelines.

The skill covers everything from first launch to programmatic customization, so your agent grows with you.

Installation

Workspace (recommended)

Installs the skill into the current project's .deepagents/skills/ directory. Check it into version control to share it with your team.

npx deepagents-cli-deepagents-skill init

Personal

Installs the skill to ~/.deepagents/<agent>/skills/ so it is available across all projects for a specific agent.

npx deepagents-cli-deepagents-skill init --personal

By default, the skill installs to the default agent. To install for a named agent:

npx deepagents-cli-deepagents-skill init --personal --agent my-agent

Alternative: Native CLI

You can also create a skill scaffold with the Deep Agents CLI and copy the files manually:

# Create the skill directory
deepagents skills create deepagents-cli

# Copy skill files into it
cp -r /path/to/deepagents-cli/* ~/.deepagents/<agent>/skills/deepagents-cli/

SDK Loading

For programmatic use with the Deep Agents SDK, skills can be loaded via any backend:

FilesystemBackend (recommended for local development):

from deepagents import create_deep_agent
from deepagents.backends.filesystem import FilesystemBackend

agent = create_deep_agent(
    backend=FilesystemBackend(root_dir="/path/to/project"),
    skills=["/path/to/project/.deepagents/skills/"],
)

StateBackend (default, for virtual filesystems):

from deepagents import create_deep_agent
from deepagents.backends.utils import create_file_data
from langgraph.checkpoint.memory import MemorySaver

# Load skill files into the virtual filesystem
skills_files = {
    "/skills/deepagents-cli/SKILL.md": create_file_data(open("SKILL.md").read()),
    # ... add reference files as needed
}

agent = create_deep_agent(
    skills=["./skills/"],
    checkpointer=MemorySaver(),
)

result = agent.invoke(
    {"messages": [...], "files": skills_files},
    config={"configurable": {"thread_id": "123"}}
)

Options

| Flag | Description | Default | |------|-------------|---------| | --personal | Install to ~/.deepagents/<agent>/skills/ (personal scope) | false | | --agent <name> | Agent name for personal install | default | | --path <dir> | Target directory for workspace installation | Current directory | | --force | Skip confirmation when skill directory already exists | false | | --help | Show usage information | — | | --version | Show installed version | — |

Updating

To update the skill after a new release, re-run the init command. Existing files are never overwritten; only files added in the new release will be created.

What Gets Installed

.deepagents/skills/deepagents-cli/
├── SKILL.md                        Main skill definition and quick-start reference
└── references/
    ├── cli-reference.md            Complete CLI commands, flags, and keyboard shortcuts
    ├── providers.md                LLM provider configuration and config.toml schema
    ├── skills-system.md            Skills creation, SKILL.md format, progressive disclosure
    ├── memory-and-persistence.md   Memory system, AGENTS.md, SDK long-term memory
    ├── sandboxes.md                Sandbox providers: Modal, Runloop, Daytona, LangSmith
    ├── sdk-customization.md        create_deep_agent(), middleware, subagents, backends, HITL
    ├── streaming.md                Streaming modes, subgraph streaming, frontend integration
    ├── acp.md                      Agent Client Protocol and editor integrations
    └── workflows.md                Automation patterns, CI/CD, troubleshooting

The skill follows the Agent Skills progressive disclosure model: SKILL.md is the primary context loaded by the agent, and the reference files are surfaced on-demand as the task requires them. This keeps the token footprint minimal while making the full surface area available.

Skill Resources

Each reference file is a structured knowledge document scoped to a specific area of the Deep Agents CLI. All content is sourced from the official LangChain Deep Agents documentation and aligned with the documented API.

SKILL.md

Purpose: Entry point for the skill. Contains a concise overview, quick-start examples, core concept summaries, and links to all reference files.

Value: The agent reads this file first when the skill is activated. It provides enough context to handle the most common tasks immediately and directs the agent to the appropriate reference file for deeper questions, keeping initial token usage minimal.

CLI Reference

File: references/cli-reference.md Source: CLI Overview

Complete reference for every command, flag, slash command, and keyboard shortcut in the Deep Agents CLI. Covers top-level commands (deepagents list, deepagents reset, deepagents skills), all launch flags (-M, -a, -n, -r, -q, --auto-approve, --shell-allow-list), all slash commands (/model, /remember, /threads, /trace, /clear, /tokens), keyboard shortcuts for the interactive REPL, the built-in tool inventory with approval requirements, and non-interactive mode behavior in detail.

Providers and Models

File: references/providers.md Source: Model Providers

Configuration reference for all 20+ supported LLM providers including OpenAI, Anthropic, Google Gemini, AWS Bedrock, Azure OpenAI, Ollama, Groq, DeepSeek, Mistral AI, Perplexity, xAI, OpenRouter, and more. Covers API key environment variables per provider, the ~/.deepagents/config.toml schema in full, model resolution order (-M flag → config default → recent → API key detection), and provider-specific parameters for local models such as Ollama.

Skills System

File: references/skills-system.md Source: Skills

Detailed guide to the Deep Agents skills system: the SKILL.md format and frontmatter fields, directory conventions for user-level (~/.deepagents/<agent>/skills/) and project-level (.deepagents/skills/) skills, the progressive disclosure loading model, override behavior when user and project skills share a name, and the full CLI for creating, listing, inspecting, and deleting skills.

Memory and Persistence

File: references/memory-and-persistence.md Source: Long-term Memory

Covers both layers of the Deep Agents memory system: the file-based layer (AGENTS.md and memories/) that persists across sessions per agent, and the SDK layer (InMemoryStore, AsyncPostgresStore) for programmatic long-term memory backends. Includes the agent directory layout, the /remember command and its optional context argument, deepagents reset behavior, and the distinction between agent-scoped and project-scoped AGENTS.md files.

Sandboxes

File: references/sandboxes.md Source: Sandboxes

Setup and configuration guide for all four supported sandbox providers: Modal (GPU and ML workloads), Runloop (disposable devboxes), Daytona (fast cold starts for TypeScript and Python development), and LangSmith (cloud-hosted execution). Covers --sandbox, --sandbox-setup, and --sandbox-id flags, provider-specific environment variables, setup script patterns, sandbox reuse across sessions, and the security isolation properties of each provider.

SDK Customization

File: references/sdk-customization.md Sources: Customization, Subagents, Backends, Human-in-the-Loop, Middleware

Programmatic usage of the Deep Agents SDK via create_deep_agent(). Covers the full function signature, model configuration, custom tool registration, system prompt customization, the middleware stack (request and response hooks for logging, rate limiting, and guardrails), subagent patterns (spawning agents as tools within a parent agent), backend types (local, sandbox, ACP), Human-in-the-Loop approval gates with interrupt and resume patterns, context management, and structured output configuration.

Streaming

File: references/streaming.md Sources: Streaming Overview, Streaming Frontend

Streaming output reference for both CLI and SDK usage. Covers the three streaming modes (text, events, full), subgraph streaming for multi-agent pipelines where each agent emits its own stream, Server-Sent Events integration for web frontends, WebSocket alternatives, and the frontend streaming protocol including event types and client-side consumption patterns.

Agent Client Protocol

File: references/acp.md Source: Agent Client Protocol

Reference for the Agent Client Protocol (ACP) — the open standard that allows editors and external clients to communicate with a running Deep Agents instance over a local socket. Covers the ACP server (deepagents serve), the request and response protocol, capability negotiation, and integration guides for Zed, VS Code, JetBrains IDEs, and Neovim.

Workflows and Patterns

File: references/workflows.md

Practical reference for automation and scripted usage. Covers non-interactive mode recipes for common tasks, CI/CD integration patterns with environment configuration, piped input workflows using stdin, multi-step subagent orchestration, shell access configuration with --shell-allow-list, output formatting with -q and --no-stream for downstream piping, and a troubleshooting index for the most common runtime errors.

Agent Skills Compliance

This skill is built to the Agent Skills open standard and the Deep Agents Skills specification:

| Requirement | Implementation | |-------------|----------------| | SKILL.md with YAML frontmatter | name, description, and compatibility fields present; description written for accurate progressive disclosure matching | | Narrow, outcome-focused scope | Skill scoped entirely to Deep Agents CLI knowledge; single domain, single responsibility | | Co-located supporting files | references/ directory co-located with SKILL.md inside the skill directory | | Progressive disclosure | SKILL.md is the primary context under 500 lines; reference files are loaded on-demand by topic | | Automatic discovery | Deep Agents loads the skill automatically when the description matches the task | | Personal and workspace scopes | --personal targets ~/.deepagents/<agent>/skills/; default targets <project>/.deepagents/skills/ | | Never overwrites existing files | The installer skips any file that already exists at the target path |

Official Documentation

All technical content in this skill is sourced from and cross-referenced against the official LangChain Deep Agents documentation:

| Topic | URL | |-------|-----| | Deep Agents Overview | https://docs.langchain.com/oss/python/deepagents/overview | | Quickstart | https://docs.langchain.com/oss/python/deepagents/quickstart | | CLI Overview | https://docs.langchain.com/oss/python/deepagents/cli/overview | | Model Providers | https://docs.langchain.com/oss/python/deepagents/cli/providers | | Customization | https://docs.langchain.com/oss/python/deepagents/customization | | Harness Capabilities | https://docs.langchain.com/oss/python/deepagents/harness | | Backends | https://docs.langchain.com/oss/python/deepagents/backends | | Subagents | https://docs.langchain.com/oss/python/deepagents/subagents | | Human-in-the-Loop | https://docs.langchain.com/oss/python/deepagents/human-in-the-loop | | Long-term Memory | https://docs.langchain.com/oss/python/deepagents/long-term-memory | | Skills | https://docs.langchain.com/oss/python/deepagents/skills | | Sandboxes | https://docs.langchain.com/oss/python/deepagents/sandboxes | | Streaming Overview | https://docs.langchain.com/oss/python/deepagents/streaming/overview | | Streaming Frontend | https://docs.langchain.com/oss/python/deepagents/streaming/frontend | | Agent Client Protocol | https://docs.langchain.com/oss/python/deepagents/acp | | Middleware | https://docs.langchain.com/oss/python/deepagents/middleware |

Deep Agents Skills specification: https://docs.langchain.com/oss/python/deepagents/skills Agent Skills open standard: https://agentskills.io/specification

Requirements

• Node.js >= 18
• LangGraph Deep Agents

License

MIT — see LICENSE for details.

Author

GitMaxd · @gitmaxd