The Coordination Problem Nobody Talks About When You Give AI Agents Real Work
Source: Dev.to
[](https://dev.to/ryanmcmillan)
Everyone talks about giving agents tools. Nobody talks about what happens when those agents need to coordinate.
The moment you have more than one agent doing real work, you hit a wall that has nothing to do with prompting, context windows, or model quality. It's coordination: which agent owns what, who delegates to whom, and how does anyone know when downstream work is done.
For months, the coordination layer was **me**: a human switchboard operator, copy‑pasting task updates between agents that couldn't talk to each other.
---
## The problem: human tools don't fit agents
I tried every task tool with an API: Todoist, Linear, Notion, Asana. Same three problems every time.
1. **Three agents, one API key**
Todoist doesn't know which agent created a task. They all authenticate as one user. When a rogue task appears at 3 AM, good luck figuring out which agent created it.
2. **No delegation model**
“Assign to user” is not the same as “Agent A delegates to Agent B, who spawns a subtask for Agent C, and the whole chain is tracked.” Human task tools don't model this because humans don't work this way. Agents do.
3. **No deduplication**
Agents forget what they already created. Without semantic dedup, you wake up to five copies of “check disk usage” every morning.
---
## So I built **Delega**
[Delega](https://github.com/delega-dev/delega) is open‑source task infrastructure designed for AI agents—not a human task app with an API bolted on.
* Each agent gets its own identity and API key.
* When Agent A creates a task and delegates it to Agent B, that chain is tracked: who created it, who’s working on it, and how deep the delegation goes.
---
## What it looks like in practice
### Creating a task via the REST API
```bash
curl -X POST https://api.delega.dev/v1/tasks \
-H "X-Agent-Key: $AGENT_KEY" \
-H "Content-Type: application/json" \
-d '{
"content": "Fix the broken CSS on /pricing",
"priority": 1,
"assigned_to_agent_id": "agent-frontend"
}'Completing a task
curl -X POST https://api.delega.dev/v1/tasks/{id}/complete \
-H "X-Agent-Key: $AGENT_KEY"Using the CLI
# Install
npm install -g @delega-dev/cli
# Log in (creates account or authenticates)
delega login
# Create a task
delega tasks create "Deploy staging build" --priority 2
# List your tasks
delega tasks list
# Mark done
delega tasks complete abc123MCP integration (zero config)
If your agents use Claude Code, Codex, Cursor, or any MCP client:
{
"mcpServers": {
"delega": {
"command": "npx",
"args": ["-y", "@delega-dev/mcp"],
"env": {
"DELEGA_AGENT_KEY": "your-key"
}
}
}
}That gives your agent 14 MCP tools: create tasks, delegate, complete, comment, manage projects, register new agents, set up webhooks, etc. The agent just uses them naturally.
The loop that made it worth shipping
Monitoring agent detects a cert expiring in 7 days
→ Creates a Delega task: “Renew TLS cert for api.example.com”
Infrastructure agent picks it up, runs the renewal
→ Marks the task complete
→ HMAC‑signed webhook fires back to the monitoring agent
→ Monitoring agent confirms the cert is valid
No human is routing anything. This pattern scales to any number of agents and any delegation depth.
Core features
| Feature | What it does |
|---|---|
| Per‑agent API keys | Each agent has its own identity, scoped permissions |
| Delegation chains | Track who delegated to whom, with depth tracking |
| Semantic dedup | Prevents agents from creating duplicate tasks |
| Lifecycle webhooks | HMAC‑signed events (created, updated, completed, deleted, assigned, delegated, commented) |
| Projects | Organize tasks by domain (infra, content, security) |
| 14 MCP tools | Native integration with any MCP client |
| REST API + CLI + Python SDK | Use however you want |
Why this matters now
The ecosystem is moving toward agent‑native infrastructure:
- 1Password launched Unified Access for agent credentials—agents need their own identity, not shared human logins.
- AgentMail built email infrastructure for agents.
- Ramp built payment cards for agents.
Tasks were the missing piece. If agents have their own email, payment methods, and credentials, they need their own task system too.
The category thesis
Human tools with APIs bolted on will always be a bad fit for agents. Not because the APIs are bad, but because the data model assumes a human is the primary user.
Agent identity, delegation semantics, programmatic deduplication—these aren’t features you add later. They’re design decisions that must exist from the start.
Try it
Self‑hosted (MIT licensed, SQLite)
git clone https://github.com/delega-dev/delega
cd delega/backend
pip install -r requirements.txt
python main.pyHosted free tier
## (1,000 tasks/month, 2 agents, $0)
**MCP (one line):**
```bash
npx @delega-dev/mcpPython SDK:
pip install delega- Fully open source (MIT licensed)
- No vendor lock‑in, no phone‑home
- Self‑hostable – you can read every line of code
I’ve been dogfooding this in production for months across content, infrastructure, QA, security, and research workflows. Happy to answer questions about the architecture decisions or how agent‑to‑agent delegation actually works in practice.
GitHub:
Site:
Ryan McMillan builds tools for AI agents. Creator of Delega. Fintech by day.