Let Your Claude Code Agents Talk to Each Other: Introducing agent-dispatch 🤖↔️🤖

Serik Ospanov — Wed, 15 Apr 2026 05:09:29 +0000

Let Your Claude Code Agents Talk to Each Other: Introducing `agent-dispatch` 🤖↔️🤖

TL;DR: An MCP server that lets Claude Code agents delegate tasks to specialized agents in other project directories. No more context-copying or permission sprawl. GitHub | PyPI

The Problem: Agents Live in Silos 🏝️

Working with Claude Code is fantastic until you need to cross project boundaries. If I'm debugging backend/ but need to check infra/ logs or query a staging DB, I'm forced to:

Copy-paste context → fragile, loses project-specific config.
Give one agent access to everything → security risk, prompt bloat.
Switch terminals manually → breaks flow, defeats the AI assistant.

I wanted specialized agents that collaborate without sharing credentials, configs, or context pollution. So I built agent-dispatch.

What Is It? 🚀

agent-dispatch is an MCP server that turns each project directory into an isolated, callable agent. When you dispatch a task, it spawns a fresh claude -p session in that directory, inherits its local CLAUDE.md, .mcp.json, and tools, executes the task, and returns a structured result.

Think of it as microservices for AI workflows: composable, cached, and sandboxed.

Quick Start (30s)

pip install agent-dispatch
agent-dispatch init
agent-dispatch add infra ~/projects/infra
agent-dispatch test infra "List running Docker containers"

That’s it. Now every Claude session can dispatch tasks to your infra agent.

How It Works 🔧

Your Claude session (e.g., backend/)
  │
  ├─ dispatch("infra", "find scheduler errors", caller="backend")
  │
  ▼
agent-dispatch MCP server
  ├─ ✅ Cache check → hit? return instantly
  ├─ 🔒 Safety check (depth, budget, concurrency)
  └─ 🚀 subprocess.run("claude -p ...", cwd=~/projects/infra/)
       │
       ▼
     Fresh Claude session in infra/
       ├─ Loads infra's CLAUDE.md, .mcp.json, tools
       ├─ Receives structured prompt: goal + caller + context + task
       └─ Executes → returns result → cached for next time

The Toolkit 🧰

Tool	Use Case
`dispatch`	One-shot task. Cached by default.
`dispatch_session`	Multi-turn conversation with context retention.
`dispatch_parallel`	Fan-out to multiple agents simultaneously.
`dispatch_stream`	Live token streaming for long tasks.
`dispatch_dialogue`	Two agents collaborate until `[RESOLVED]`.

Example call:

{
  "agent": "db",
  "task": "Are all migrations applied?",
  "caller": "backend",
  "goal": "Debug startup failure"
}

Safety & Cost Control 🛡️

I didn't want a demo toy—I wanted production-ready tooling. Built-in safeguards:

Recursion protection: max_dispatch_depth (default: 3)
Cost limits: max_budget_usd per agent or globally
Concurrency caps: max_concurrency limits parallel claude -p processes
Timeouts: kills stuck sessions (default: 300s)
Caching: identical (agent, task, context) requests return instantly. Only successes cached.
Hot-reload config: add/remove agents via ~/.config/agent-dispatch/agents.yaml without restarting.

When to Use (and When Not To) ⚖️

✅ Do dispatch when:

The task needs tools, files, or context from another project
You want to leverage project-specific MCP servers or CLAUDE.md
You need parallel answers from multiple codebases

❌ Don't dispatch when:

The task is simple and local (just use your current agent)
You need sub-second latency
You're in a tight loop (use dispatch_parallel instead)

Try It & Let Me Know! 💬

🔗 GitHub

📦 PyPI

pip install agent-dispatch
agent-dispatch init
agent-dispatch add my-agent ~/path/to/project

I'd love your feedback:

What agent collaboration patterns would you use this for?
What safety features are missing?
Would you prefer a different abstraction (e.g., HTTP API vs MCP)?

Drop a comment below or open an issue. This is very much a "build in public" project. 🙏

I got tired of agent frameworks that just… chat. So I built an OS for agents that actually do stuff.

Serik Ospanov — Fri, 03 Apr 2026 10:58:21 +0000

Hey dev.to 👋

Quick story: I've spent way too many hours wiring up "autonomous" agents in Python, only to realize they're basically fancy chatbots that wait for me to type something. Cool for demos. Not great for actually getting work done while I sleep.

So I went a different route.

Meet RustyHand — an open-source Agent Operating System built in Rust. Not a framework. Not a wrapper. A full OS for agents that run on schedules, monitor things, generate leads, manage socials, and report back — all without you babysitting them.

Why it's different:

🦀 Single ~32MB binary. One install. One command. Done.
⚡ Autonomous by default. Cron jobs, event triggers, recurring workflows — agents that work 24/7.
🔌 37 channel adapters. Telegram, Discord, Slack, WhatsApp, Matrix… your agents meet users where they are.
🤖 37 pre-built templates. Researcher, coder, analyst, social media manager — rustyhand agent new researcher and go.
🧠 26 LLM providers, 130+ models. Auto-fallback, cost tracking, per-agent budgets.
🔐 16 security layers. WASM sandboxing, taint tracking, signed manifests, zeroized secrets — because agents shouldn't become attack vectors.
🧩 MCP server built-in. Let Claude, Cursor, or any MCP-compatible AI control your agent OS.

60 seconds to running:

curl -fsSL https://raw.githubusercontent.com/ginkida/rustyhand/main/scripts/install.sh | sh
rustyhand init
rustyhand start
# Dashboard at http://localhost:4200

Real talk:

This is v0.1.0. It's feature-complete, battle-tested internally (3,000+ tests, zero clippy warnings), but yes — you might hit a rough edge. Pin a commit for prod, report issues, help shape v1.0.

If you've ever wanted agents that do instead of just talk, I'd love for you to kick the tires:

👉 GitHub: ginkida/rustyhand

Drop a comment if you try it out — what's the first autonomous agent you'd build? 🛠️

(P.S. It's MIT licensed. Use it, break it, rebuild it. Just maybe send a PR if you fix something.)

Forem: Serik Ospanov

Let Your Claude Code Agents Talk to Each Other: Introducing agent-dispatch 🤖↔️🤖