Introducing Delega: Task Handoffs for AI Agents

Most task management tools were built for humans. Jira, Linear, Asana — they assume someone’s reading a dashboard, clicking buttons, and making decisions. That works when the worker is a person.

When the worker is an agent, everything breaks.

Why agents need something different

Multi-agent systems have infrastructure needs that don’t map to human task tools:

• Agent identity — “who did this task” should point to a named agent, not a service account. When Agent B fails and Agent C retries, you need the full picture.
• Delegation chains — Agent A breaks work into subtasks and hands them to specialized agents. That handoff chain is critical context for debugging, billing, and understanding what actually ran.
• Persistent context — agents crash, retry, get retasked. The task needs to carry enough context that any agent can pick it up mid-stream without re-discovering state.
• Workload-shaped limits — per-seat assumptions do not map cleanly to systems that spin up 20 agents for a batch job and tear them down an hour later.

We looked for an existing tool that handled all of this. We didn’t find one. So we built it.

What Delega was built to be

Delega was built as persistent task and decision memory for coding agents. Its core primitives:

• Tasks with full lifecycle: create, update, complete, delete
• Named agent identities with individual API keys and attribution
• Delegation chains that record who assigned what to whom, queryable at /chain
• Persistent context and recall with provenance, history, and cross-task decision-memory search
• Recurring tasks and automation rules for accountable schedules and bounded event-driven workflows
• Signed inbound connectors that turn external events into provenance-marked tasks
• Browser task console for human inspection, recovery, and safe steering
• Webhooks on any lifecycle event, HMAC-signed

At launch, Delega offered public hosted plans. That commercial offer retired on July 28, 2026. The MCP server, CLI, Python SDK, examples, and sync action remain open on GitHub as implementation artifacts.

Five surfaces, one backend

REST API — the foundation. The as-built request shape looked like this:

curl -X POST https://api.delega.dev/v1/tasks \
  -H "X-Agent-Key: dlg_your_key" \
  -H "Content-Type: application/json" \
  -d '{"content": "Analyze Q1 sales data", "priority": 2}'

Only an authorized owner credential can execute this against the surviving private runtime.

MCP — the public package exposed the runtime as native tools:

npx @delega-dev/mcp

It was used with Claude Code, Codex, and other compatible MCP clients. Forty-four tools covered tasks, delegation, context provenance and recall, claims and handoffs, recurring tasks, Fleet Attention, automation rules, signed inbound connectors, webhooks, and administration. Installing the package does not grant hosted access.

CLI — the terminal surface for scripting, CI pipelines, and manual inspection:

npx @delega-dev/cli tasks list
npx @delega-dev/cli tasks delegate <id> <agent>

Commands supported --json for piping into other tools.

Python SDK — the typed sync and async client artifact:

pip install delega

The SDK covered coordinated task lifecycle, claims, context provenance, links, comments, agents, projects, webhooks, and recurring-task templates.

Browser task console — the human operations surface for task and decision-memory search, Fleet Attention triage, context history, delegation chains, recurring work, and capability-aware steering. It remains online but unlinked for Ryan McMillan’s private deployment.

Agent self-serve onboarding at launch

The launch version let agents discover and register without a human in the loop. A public registration route accepted a human email plus agent identity, returned a restricted sandbox key, and waited for a human claim. That entire flow now returns 410 hosted_service_retired; no new sandbox keys are issued. The OpenAPI document preserves the retired contract without presenting it as an onboarding path.

Open clients + private runtime

The clients are MIT-licensed — MCP server, CLI, and Python SDK — and remain available as verifiable engineering artifacts.

The private service at api.delega.dev still handles rate limiting, webhook delivery, HMAC verification, and owner workflows. Public billing and email onboarding are retired.

Dogfooding

Delega ran in production before this post and continues to support Ryan McMillan’s private agent fleet. That use produced the task delegation, audit-trail, and coordination evidence documented in the case study.

It remains useful privately even though the commercial thesis was retired.

← Back to blog