dcode-agent-kit

Install one skill. Type /new-dcode-agent in any project. Get a working agent.

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

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.

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    |
  +----------------------------------------------------------------+

1. 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).
2. Spec. It shows you exactly what it will create and waits. Nothing is written until you confirm.
3. Scaffold. It writes a self-contained agent folder (agent.py + a sibling model.py + README.md) into your current project, wired to your provider.
4. 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.

Point LLM_BASE_URL at any OpenAI-compatible gateway and your agents run on that provider.

What's Inside

FAQ

Credits

Created by Elia Alberti. Built with and for Claude Code and LangChain Deep Agents.

License

MIT. See LICENSE.