Delegator MCP: Delegation as a Native Tool in Claude

The Model Context Protocol (MCP) is a standard that lets Claude — in Claude Desktop or Claude Code — call external tools defined by third-party servers. We built an MCP server that exposes the full Worksona delegation engine as a set of callable tools. The result: Claude can now decompose a complex task, dispatch it to a coordinated team of specialized agents, and return a synthesized report, all within a single conversation turn.

What is it?

The Delegator MCP is a Node.js server that implements the MCP protocol and registers five tools against it: delegate_task, execute_delegation_pattern, get_delegation_results, list_patterns, and analyze_task_complexity. When configured in Claude Desktop, these tools appear alongside any other MCP tools Claude has access to. Claude can call them directly when it determines that a user's query warrants multi-agent treatment.

Why is it useful?

Without this, using the delegation system meant opening a browser interface, pasting a query, and waiting. That workflow is friction. The MCP integration removes the browser entirely. A Claude Desktop user asks a complex question; Claude calls delegate_task with appropriate parameters; the delegation engine spins up specialized agents; the result comes back into the conversation. The user never left their chat window.

It also means delegation is composable. Claude can decide autonomously when to delegate. If a user asks for a competitive analysis of three cloud providers, Claude can choose to invoke the competitive delegation pattern — three agents working independently, a fourth evaluating and selecting — rather than answering from its own context alone. The choice lives with the model.

How does it work?

The server runs via StdioServerTransport, which is how Claude Desktop communicates with MCP processes — over stdin/stdout rather than a network socket. The server registers tools with JSON Schema definitions for their parameters, so Claude knows exactly what inputs each tool accepts. Underneath, the tools delegate into the same delegation engine used across the entire Worksona system.

// MCP tool call from a Claude client
const task = await use_mcp_tool('delegator', 'create_delegation_task', {
  query: "Analyze the competitive landscape for renewable energy storage",
  pattern: "hierarchical",
  config: {
    maxAgents: 6,
    timeLimit: 600,
    temperature: 0.4
  }
});

const results = await use_mcp_tool('delegator', 'get_delegation_results', {
  taskId: task.taskId
});

Configuration is handled through claude_desktop_config.json. The server path, Node version requirement (18+), and API keys are declared once. After a restart, the tools are available.

{
  "mcpServers": {
    "delegator-mcp": {
      "command": "node",
      "args": ["/path/to/delegator-mcp/dist/server.js"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

The server supports all six delegation patterns. hierarchical is the default: a coordinator decomposes the task, workers execute in parallel, a synthesizer integrates the output. iterative passes work through a sequential refinement loop with a quality gate. competitive runs the same task through multiple agents independently, then selects or merges the best result. federation adds a second tier of domain coordinators for tasks that span several knowledge domains. peer-to-peer runs agents as equals who share and negotiate findings. adaptive selects a pattern dynamically based on a complexity score computed at runtime.

Agent configuration is carried over from the core system: each agent is a JSON template with defined personality traits, a role-specific system prompt, a temperature tuned to its function (0.2 for analysts, 0.6 for writers), and a token budget matched to the depth of work expected. The MCP layer is thin — its job is to receive a call, route it to the correct pattern handler, and return the result.

Where and how it applies

The primary target is Claude Desktop users who want access to structured multi-agent analysis without switching tools. It also fits Claude Code workflows: a developer can invoke delegation mid-session to offload a research or content task while continuing to work in the terminal. Because the MCP server supports Docker deployment and PM2 process management, it can run as a persistent background service on a development machine or a shared team server, making it available to anyone on the team whose Claude client points at the same server.

The package is distributed as a tarball and published as an npm package. Installation is: npm install, npm run build, update claude_desktop_config.json, restart Claude Desktop.