⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
agent-communication
AI DevKit · Exchange information with active Codex, Claude Code, and other AI agents using ai-devkit agent list, detail, and send. Use when an agent needs to find another active agent, read its recent context, send it information, or request information back.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
AI DevKit
English | 中文
The control plane for AI coding agents.

AI DevKit gives Claude Code, Codex CLI, Gemini CLI, opencode, Pi, Cursor, GitHub Copilot, Devin, and other coding agents one local-first operating layer: one config, one console, local memory retrieval, cross-agent communication, and composable engineering skills led by dev-lifecycle.
- One config for every agent —
.ai-devkit.jsonreconciles setup across the coding tools your team uses - One console for running sessions —
agent consoleis a live TUI dashboard for supervising local agents across providers - Cross-agent communication —
agent sendlets you route prompts, logs, and test output to running agents - Memory retrieval without context bloat —
@ai-devkit/memorystores decisions, conventions, and fixes in local SQLite so agents search when needed instead of carrying everything in every prompt - Composable engineering skills —
dev-lifecycle,verify,tdd, review, debugging, security, docs, and simplification skills combine into reliable workflows
The future is many AI coding agents. AI DevKit is the layer that makes them manageable.
Run machine setup once, then init in each project:
npx ai-devkit@latest setup
cd your-project
npx ai-devkit@latest init
setup installs built-in skills globally, session hooks, and the memory MCP wiring for detected agents.
The kiro, copilot, devin, and muse targets detect ~/.kiro, ~/.copilot, ~/.config/devin, and ~/.config/muse, respectively. Copilot skills use the github environment and ~/.copilot/skills; Devin and Muse use ~/.config/devin/skills and ~/.config/muse/skills. Kiro has no skill environment or root defined, so its target only detects the marker and reports the memory MCP skip. All four skip memory MCP wiring until a global config writer is verified.
init writes project-local config. Your project gets:
| What you need | What AI DevKit installs |
|---|---|
| One setup source | .ai-devkit.json for the agents and workflow you choose |
| Running-agent visibility | agent list, agent detail, and agent console |
| Addressable agents | agent send, --stdin, --wait, and agent groups where supported |
| Retrieval-based memory | Local SQLite memory exposed through MCP and CLI, searched only when useful |
| Composable senior-engineer workflow | dev-lifecycle plus verification, TDD, debugging, review, security, docs, and simplification skills |
Who this is for
Developers whose AI coding setup has grown from one assistant into a small, messy team of agents:
- multiple terminals with no shared control surface
- separate
CLAUDE.md/.cursor/rules/AGENTS.md/ MCP setup per tool - no easy way to send context, logs, or follow-up work to a running agent
- the agent forgetting yesterday's conventions
- "I've successfully implemented the feature" with a red build
- the agent diving into code without a plan and producing the wrong thing
Before AI DevKit, your agents are powerful but scattered. After AI DevKit, they have shared setup, a control surface, searchable memory, communication paths, and reusable skills that travel with your repo without bloating every prompt.
| Without AI DevKit | With AI DevKit |
|---|---|
| You manage agents as isolated terminal tabs | You supervise them from ai-devkit agent console |
| You hand-maintain every agent setup | One config reconciles agent files, skills, and MCP setup |
| You copy logs and context between sessions | agent send routes prompts and stdin to running agents |
| You repeat project rules in every chat | Agents retrieve relevant memory and docs only when useful |
| The agent jumps from prompt to code | dev-lifecycle guides requirements, design, planning, implementation, testing, and review |
| "Done" means the agent stopped editing | "Done" requires fresh verification output |
Start in 30 seconds
npx ai-devkit@latest setup
cd your-project
npx ai-devkit@latest init
Run setup once per machine, then init per project. Pick your agents, install the control-plane pieces you need, and give every tool the same operating model. Re-run init whenever your agent list or workflow changes.
Multi-agent orchestration (lead plus workers): docs guide.
Here's what lands in your repo:
your-project/
├── .ai-devkit.json # single source of truth (re-run init anytime)
├── .claude/ # or .cursor/, .codex/, etc. per agent you picked
│ ├── skills/ # dev-lifecycle, verify, memory, tdd, ...
│ └── … # Claude: project MCP in `.mcp.json`; memory MCP wired globally by `setup`
└── docs/ai/
├── requirements/ # phase 1 — what to build, why
├── design/ # phase 2 — how it'll be built
├── planning/ # phase 3 — task-by-task plan
├── implementation/ # phase 4 — execution notes
└── testing/ # phase 5 — coverage strategy
Operate agents like infrastructure
AI DevKit ships an agent control plane for everyday multi-agent work:
# List running sessions across providers
ai-devkit agent list
# Open the live terminal UI
ai-devkit agent console
# Send a prompt to a running session and wait for the response
ai-devkit agent send "run the tests and report back" --id <agent-name> --wait
# Pipe multi-line output into a running session
npm test 2>&1 | ai-devkit agent send --id <agent-name> --stdin
# Send a prompt to a saved group of agents
ai-devkit agent send "review this branch for release risk" --group reviewers
# Pipe a session through Telegram — operate your agent from your phone
ai-devkit channel start telegram --agent <agent-name> --daemon
Use this when work spans long-running agents, multiple providers, scheduled checks, review loops, or remote control from another channel.
Add memory without bloating context
AI DevKit memory is local SQLite knowledge for project decisions, coding conventions, and reusable fixes. Agents retrieve it when a task needs context instead of carrying every fact in every prompt.
# Store a reusable project convention
ai-devkit memory store \
--title "API handlers return DTOs" \
--content "REST handlers should return response DTOs instead of domain entities." \
--tags "api,backend" \
--scope "repo:codeaholicguy/ai-devkit"
# Search before related work
ai-devkit memory search --query "API response convention"
Compose engineering workflows with skills
The control plane is useful on its own. For larger or riskier changes, AI DevKit also installs composable skills that make agents behave more like an engineering team.
dev-lifecycle is the anchor skill. It guides the agent through requirements, design, planning, implementation, testing, and review. Other skills plug into that flow:
memoryretrieves relevant project knowledge without stuffing all context into the sessionverifyblocks completion claims without fresh test or build evidencetddpushes test-first implementation when behavior changesdev-debugkeeps debugging reproducible instead of guess-and-patchsecurity-review,document-code, anddev-simplifyadd focused review passes when the task needs them
Get the full engineering workflow sta
// HOW IT'S BUILT
// FILES
3 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
skills/agent-communication/SKILL.md1.3 KB23cc7374ec3fupstream ↗
--- name: agent-communication description: AI DevKit · Exchange information with active Codex, Claude Code, and other AI agents using ai-devkit agent list, detail, and send. Use when an agent needs to find another active agent, read its recent context, send it information, or request information back. --- # Agent Communication Use `ai-devkit agent ...` to discover and communicate with active agents. If `ai-devkit` is not on PATH, use `npx ai-devkit@latest agent ...`. ## Commands ```bash ai-devkit agent list --json ai-devkit agent detail --id <agent-name> --json --tail 20 ai-devkit agent send --id <agent-name> "<message>" ai-devkit agent send --id <agent-name> --wait --timeout 120000 --json "<message>" <command> 2>&1 | ai-devkit agent send --id <agent-name> --stdin ``` ## Notes - `list --json` returns active agents with fields such as `name`, `type`, `status`, `summary`, `projectPath`, and `lastActive`. - Use the `name` from `list --json` as `--id`. Partial matches are supported, but exact names are safer. - Use `detail --json --tail <n>` to read recent context from an agent before deciding what to send. - `send --wait` waits for a reply; add `--json` when the response should be machine-readable. - `send --stdin` forwards piped command output or larger text.skills/agent-communication/agents/openai.yaml227 B4fff60909551upstream ↗
interface: display_name: "Agent Communication" short_description: "AI DevKit · Message active AI agents" default_prompt: "Use $agent-communication to exchange information with another active AI agent through AI DevKit."README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/codeaholicguy-ai-devkit-skills-agent-communication.md