A Claude Code skill that scaffolds a Deep Agents (LangChain) agent for you: it interviews you, then drops a ready-to-run agent into whatever project you are in.
Bring your own model provider: the agents it scaffolds run on any OpenAI-compatible API, with nothing hard-coded and no vendor lock-in.
Quick Start • What You Can Build • The Skill • Providers • FAQ
Install the skill once, then run /new-dcode-agent in any project. Pick either install method.
git clone https://github.com/EliaAlberti/dcode-agent-kit.git
mkdir -p ~/.claude/skills
cp -r dcode-agent-kit/skills/new-dcode-agent ~/.claude/skills//new-dcode-agent is now available in every project.
In Claude Code:
/plugin marketplace add EliaAlberti/dcode-agent-kit
/plugin install dcode-agent-kit@dcode-agent-kit
Installed as a plugin, the skill is namespaced: invoke it as
/dcode-agent-kit:new-dcode-agent(the manual install in Option 1 keeps the plain/new-dcode-agent).
/new-dcode-agent
Answer a few questions. The skill shows you a plan, then writes a ready-to-run agent folder into your current project.
You: /new-dcode-agent
Claude: What form should this agent take?
1. SDK program 2. dcode agent 3. both
You: 1
Claude: Name it (kebab-case):
You: release-notes
Claude: In a sentence or two, what is it for?
You: Summarise merged pull requests into release notes.
Claude: Closest flavour? custom / project / work-jira / vps-ops / personal
You: project
Claude: Can it change things, or is it read-only?
You: read-only
Claude: Here is the spec [what it will create in ./release-notes/]. Scaffold it?
You: yes
Claude: Created ./release-notes/ (agent.py + model.py + README.md), wired to your
provider, and ran a smoke test. Run it with: cd release-notes && python agent.py
- The
/new-dcode-agentskill: install it once, run it in any project. It interviews you and writes a complete, working agent where you are. - Provider-agnostic agents: each agent it builds works with any OpenAI-compatible API (OpenAI itself, or a compatible gateway), set in one environment variable.
- Self-contained output: each agent is a small folder (
agent.py+model.py+README.md) with no shared dependencies, so you can move it, commit it, or deploy it anywhere. - Safe by default: an agent that can change things gets an approval gate that pauses and asks before it acts.
Deep Agents is a LangChain framework for building capable AI agents in Python. You call create_deep_agent(...) with a system prompt and some tools (plain Python functions), and you get an agent that can plan, use those tools, run sub-agents, and pause for your approval before risky actions.
dcode (the deepagents-code CLI) is a terminal coding agent built on that same framework. You can add agents to it: named identities you chat with, each with its own knowledge and rules. The built-ins are coder and researcher, and you switch with /agents.
This skill builds both: standalone Python agents you run or deploy, and dcode agents you chat with. You do not need to know the internals. The skill handles the wiring.
The skill can create three kinds of agent. You pick one when it asks.
| Form | What it is | Where it goes | Best for |
|---|---|---|---|
| SDK program | A standalone Python agent (create_deep_agent) you run, schedule, or deploy |
./<name>/ in your current project |
Automation, headless jobs, anything you put on a server |
| dcode agent | A named identity you chat with inside the dcode CLI | ~/.deepagents/<name>/ |
An interactive expert you switch into with /agents |
| Both | A dcode agent that acts as the cockpit for a deployed SDK program | both locations | A monitor you can run headless and also talk to |
An agent that can change things (restart a service, post an update, write a file) gets an approval gate so it pauses and asks before it acts.
/new-dcode-agent walks through four steps and never runs git, so committing stays your call.
+----------------------------------------------------------------+
| 1. Interview form, name, purpose, flavour, tools, |
| model, safety |
| 2. Spec shows you the plan and waits for your OK |
| 3. Scaffold writes a self-contained agent folder into |
| your current project |
| 4. Smoke-test imports and runs it once to prove it works |
+----------------------------------------------------------------+
- Interview. It asks what you want: an SDK program, a dcode agent, or both; a name; what it is for; the closest flavour; which tools and MCP servers it needs; which model; and whether it can change things (if so, it adds an approval gate).
- Spec. It shows you exactly what it will create and waits. Nothing is written until you confirm.
- Scaffold. It writes a self-contained agent folder (
agent.py+ a siblingmodel.py+README.md) into your current project, wired to your provider. - Smoke-test. It imports the new agent and runs it once. If the agent can change things, it proves the approval gate actually pauses before acting.
You end up with a working agent that already follows the safe defaults: read-only first, approval required before anything destructive.
Every scaffolded agent gets its model from a sibling model.py (chat_model()), which reads your settings from the environment or a .env. No provider is baked into the code.
| Variable | Required | What it does |
|---|---|---|
LLM_API_KEY |
Yes | Your provider API key (OPENAI_API_KEY also works) |
LLM_BASE_URL |
No | Your provider's endpoint. Leave blank for OpenAI's default |
LLM_MODEL |
No | The model id to use (it must exist on your provider) |
USE_RESPONSES_API |
No | Set to 1 only if your provider supports the OpenAI Responses API |
Point LLM_BASE_URL at any OpenAI-compatible gateway and your agents run on that provider.
| Path | What it is |
|---|---|
skills/new-dcode-agent/SKILL.md |
The skill: the whole wizard, self-contained |
.claude-plugin/plugin.json |
Plugin manifest (for the marketplace install) |
.claude-plugin/marketplace.json |
Marketplace listing for this plugin |
reference/deepagents-guide.md |
A concise Deep Agents and dcode reference |
assets/dak.png |
The banner |
Where does the skill build the agent?
Into your current project. Run /new-dcode-agent from the folder you are working in, and it writes a ./<name>/ agent folder right there. You are never locked into this repo.
Do I need to clone this repo every time?
No. You install the skill once (Option 1 or 2 above). After that, /new-dcode-agent is available in every project without cloning anything.
Do I need the dcode CLI?
No. The SDK agents this skill builds run on their own with just Python and your API key. dcode is only needed if you choose the dcode agent form, the chat-with-it identity.
Which model providers work?
Any provider with an OpenAI-compatible API. Set LLM_API_KEY, and if you are not using OpenAI, set LLM_BASE_URL to your provider's endpoint and LLM_MODEL to a model it offers. Nothing else changes.
Is my API key safe?
Yes. Keys are read from the environment or a .env at runtime. Nothing is written into the generated code, and a scaffolded agent's README.md reminds you to keep .env out of git.
What is the difference between a dcode agent and an SDK program?
An SDK program is a standalone Python agent you run or deploy (good for automation and headless jobs). A dcode agent is an identity you chat with interactively inside the dcode CLI. You can build either, or both together, where the dcode agent is the cockpit for a deployed program.
The skill mentions an "approval gate". What is that?
It is a safety pause. An agent that can change things is set up so it stops and asks for your approval before running a tool that acts (for example restarting a service). Under the hood this is the SDK's interrupt_on paired with a checkpointer, and the skill verifies the pause actually fires before it hands the agent over.
Created by Elia Alberti. Built with and for Claude Code and LangChain Deep Agents.
MIT. See LICENSE.