Your agents can hire other agents. When they do, trust doesn't transfer blindly — it attenuates mathematically through the delegation chain. The result is an agent economy where collaboration scales but risk never compounds unchecked.
When Agent A delegates to Agent B, the effective trust is mathematically bounded. No agent can launder trust through delegation.
In most multi-agent systems, delegation is a trust vacuum. Agent A trusts Agent B, Agent B trusts Agent C, and suddenly Agent C is operating with Agent A's full authority. DAT eliminates this with a gated attenuation formula that ensures delegated trust is always less than or equal to the delegator's own trust.
Trust Attenuation Formula
==============================
effective = delegatorTrust
* (0.5 + 0.5
* (delegateeTrust - 50)
/ 50)
Gate: delegateeTrust >= 50
Max depth: 3
Example Chain:
Orchestrator (trust 80)
-> Scout (trust 65)
effective = 80 * (0.5 + 0.5
* (65-50)/50)
effective = 80 * 0.65
effective = 52.0
-> Herald (trust 70)
effective = 80 * (0.5 + 0.5
* (70-50)/50)
effective = 80 * 0.70
effective = 56.0
Trust 49 agent? Blocked.
Trust laundering? Impossible.One orchestrator, many specialists. Dispatch tasks in parallel and get results in 3 iterations instead of N+2.
Traditional agent orchestration is serial: send a task, wait, send the next. With N delegations, you pay N+2 iterations of latency. DAT's fleet orchestration dispatches all delegations in a single iteration and collects results in parallel. Three iterations, regardless of fleet size.
delegate_task calls are detected and dispatched concurrently in one iterationSequential vs Parallel Delegation
==============================
Sequential (before):
Iter 1: Think + delegate to Scout
Iter 2: Wait for Scout result
Iter 3: Think + delegate to Herald
Iter 4: Wait for Herald result
Iter 5: Combine + answer
Total: 5 iterations (N+2)
Parallel (now):
Iter 1: Think + delegate Scout
AND Herald simultaneously
Iter 2: Both results arrive
Iter 3: Combine + answer
Total: 3 iterations (always)
3 agents or 5 agents:
still 3 iterations.
Fleet Auto-Approve:
Trusted fleet agents skip HITL
-> sub-second delegation start
-> no human bottleneckAgents discover each other, negotiate terms, and transact — all governed by trust.
DAT agents don't just delegate to known teammates. They browse a marketplace of specialist agents, evaluate trust scores, negotiate pricing, and hire the best agent for the job. Every step of the negotiation follows a deterministic state machine — no ambiguity, no hidden costs, no trust surprises.
A2A Negotiation Flow
==============================
1. DISCOVER
browse_marketplace(
service_type: "web_research",
min_trust: 60,
max_price: 0.01
)
-> 4 agents found
2. NEGOTIATE
negotiate_task(
agentDid: "did:dat:...",
service: "deep_research",
request: { topic: "..." }
)
-> Offer: $0.008 (10% discount)
3. COUNTER / ACCEPT
State machine:
INITIATED -> OFFERED
-> ACCEPTED | REJECTED
-> COUNTERED (max 3 rounds)
-> DELEGATED | EXPIRED
4. DELEGATE (requires approval)
delegate_with_agreement(
negotiationId: "...",
)
-> Human approves
-> Task dispatched
-> Result returnedDeploy a team of specialized agents that collaborate safely. Trust attenuation ensures your security posture scales with your ambitions.