Delegato — Intelligent Delegation for Multi-Agent AI Systems
Production-ready Python framework for safe, observable, and reliable agent-to-agent delegation at scale
Core Delegation Pipeline
Delegato implements a structured 5-stage pipeline that transforms complex tasks into safely delegated, verified, and consensus-validated results across multiple AI agents.
1. Decomposition
Task Breaking & Analysis
- Breaks complex tasks into atomic sub-tasks
- Identifies dependencies and execution order
- Estimates complexity for routing decisions
- Builds a directed acyclic graph (DAG) of work
2. Assignment
Trust-Aware Routing
- Matches sub-tasks to agents by capability
- Trust scores track agent reliability over time
- Privilege attenuation limits scope per delegation
- Load balancing across available agents
3. Verification
Multi-Judge Evaluation
- Independent judges evaluate task outputs
- Structured rubrics for consistent grading
- Detects hallucinations and quality issues
- Configurable pass/fail thresholds
4. Consensus
Multi-Agent Agreement
- Multiple agents vote on final output quality
- Weighted consensus based on agent trust scores
- Disagreement resolution strategies
- Prevents single-agent failure modes
5. Parallel DAG Execution
Concurrent Task Orchestration
- Executes independent sub-tasks concurrently for maximum throughput
- Respects dependency ordering from the decomposition phase
- Handles partial failures without losing completed work
- Real-time progress tracking across all execution branches
Safety & Adaptability
Trust System
- Dynamic trust scores per agent
- Earned through successful delegations
- Decays on failures or timeouts
- Influences future task assignment
Circuit Breakers
- Automatic failure detection thresholds
- Stops cascading delegation failures
- Configurable recovery strategies
- Half-open state for gradual recovery
Audit Trail
- Complete delegation history
- Event system for observability
- Retry and reassign tracking
- Privilege attenuation logging
How It Works
Principal submits a complex task
The orchestrating agent receives a task too complex or specialized for it to handle alone
Decomposition engine breaks it into sub-tasks
A DAG of atomic sub-tasks is created with dependency edges and complexity estimates
Trust-aware assignment routes to delegate agents
Each sub-task is matched to the best available agent based on capabilities and trust scores
Parallel execution with verification gates
Independent sub-tasks run concurrently; each result passes through multi-judge verification
Consensus validation and result aggregation
Final outputs undergo consensus voting, trust scores update, and verified results return to the principal
Quick Start
pip install delegato
from delegato import DelegationPipeline, Agent, Task
# Define your agents
researcher = Agent(name="researcher", capabilities=["research", "analysis"])
writer = Agent(name="writer", capabilities=["writing", "summarization"])
# Create a pipeline
pipeline = DelegationPipeline(
agents=[researcher, writer],
verification_judges=2,
consensus_threshold=0.7
)
# Delegate a complex task
task = Task(
description="Research and summarize recent advances in multi-agent AI",
required_capabilities=["research", "writing"]
)
result = await pipeline.execute(task)
print(result.output) # Final verified output
print(result.trust_scores) # Updated agent trust scores
print(result.audit_trail) # Complete delegation historyAdvanced Features
Multi-Judge Consensus
Configure multiple independent judges with weighted voting to ensure output quality surpasses any single-agent evaluation.
Circuit Breakers
Automatic failure thresholds prevent cascading delegation failures. Configurable half-open recovery for graceful degradation.
Complexity Floor
Prevents over-delegation by only routing sufficiently complex sub-tasks to agents. Simple tasks execute inline without overhead.
Event System
Full observability through structured events for every delegation lifecycle step — assignment, execution, verification, and consensus.
Research Foundation
Delegato is based on the principles outlined in "Intelligent AI Delegation" by Tomasev et al. (Google DeepMind, February 2026), which formalizes the delegation problem in multi-agent systems and proposes structured frameworks for safe, verifiable agent-to-agent task routing.
The paper identifies trust calibration, privilege attenuation, and multi-judge verification as critical building blocks for production multi-agent systems — all of which are implemented in Delegato.