Quick Start
Install the skill once, then run /new-dcode-agent in any project. Pick either install method.
Option 1: install the skill (simplest)
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.
Option 2: install as a plugin (managed updates)
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).
Then, in any project, run it
/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
What You Get
- The
/new-dcode-agent skill: 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.
What Are Deep Agents and dcode?
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.
What You Can Build
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.
The Skill, Step by Step
/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 sibling model.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.
Bring Your Own Provider
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.
What's Inside
| 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 |
FAQ
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.
No. You install the skill once (Option 1 or 2 above). After that, /new-dcode-agent is available in every project without cloning anything.
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.
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.
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.
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.
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.
Credits
Created by Elia Alberti. Built with and for Claude Code and LangChain Deep Agents.
License
MIT. See LICENSE.
