The Coordination Problem Nobody Talks About When You Give AI Agents Real Work

#mcp #ai #opensource #webdev

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 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, how deep the delegation goes.

What it looks like in practice

Creating a task via the REST API:

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 abc123

MCP 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. The agent just uses them naturally.

The loop that made it worth shipping

Here's the actual workflow:

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 routing anything. This pattern scales to any number of agents and 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

This isn't just my problem. The ecosystem is moving toward agent-native infrastructure:

1Password launched Unified Access specifically for agent credentials. Their thesis: 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, their own payment methods, and their own 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 dedup: these aren't features you add later. They're design decisions that have to be there 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.py

Hosted free tier: delega.dev (1,000 tasks/month, 2 agents, $0)

MCP (one line): npx @delega-dev/mcp

Python SDK: pip install delega

It's fully open source. MIT licensed. No vendor lock-in, no phone-home. Self-host it and read every line.

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: github.com/delega-dev/delega
Site: delega.dev

Ryan McMillan builds tools for AI agents. Creator of Delega. Fintech by day.