Q&A: How does MeshResultAggregator handle slow or unresponsive agents? Quorum, timeout, and fallback

[web3guru888]

Q: If one agent is slow or crashes mid-task, does MeshResultAggregator hang indefinitely?

---

A: No — the aggregator uses a quorum + timeout model to avoid hanging.

How It Works

When AgentMesh dispatches a task to N agents, the aggregator is told to expect N results. It does not require all N to respond — only a quorum (default: 50% of N).

aggregator = MeshResultAggregator(
    blackboard=bb,
    quorum=0.5,        # 50% must respond
    timeout_ms=5000.0, # hard ceiling: 5 seconds
)
result = await aggregator.wait_for_results(
    task_id="task-abc",
    expected=3,        # 3 agents dispatched
)
# Returns as soon as 2 of 3 respond, or after 5s with whatever arrived

Crash vs. Slow

The aggregator does not distinguish between crashed and slow agents — both look like "no result received." The timeout is the only protection. If a task must complete in under 200ms (to fit inside a CognitiveCycle tick), set timeout_ms=200.

What Happens at Timeout?

Results received at timeout	Outcome
≥ quorum	Aggregate and return (with potentially lower confidence)
< quorum	Raise QuorumNotReached
0 (all crashed)	Raise AggregationError

The CognitiveCycle should catch QuorumNotReached and either:

• Fall back to the last-good Blackboard value (same pattern as circuit breaker, Add circuit breaker pattern to CognitiveCycle: auto-disable persistently failing modules with OPEN/HALF_OPEN/CLOSED health states #137)
• Skip this task for the current tick and log a fault to CycleFaultSummary (Add CycleFaultSummary: per-tick fault report written to Blackboard and exposed via SSE health endpoint #144)

What Happens to Late Results?

If an agent responds after the quorum was reached and aggregation is done, receive_result silently discards the late result. The task entry is already gone from _collected.

There is no mechanism to reopen a completed aggregation. If you need late results, set a higher quorum or longer timeout at dispatch time.

FIRST_DONE Strategy

For speculative execution tasks, use AggregationStrategy.FIRST_DONE. The aggregator returns immediately when the first successful result arrives, without waiting for a quorum. Remaining results are discarded. This is ideal for cache lookups, where any agent with a cache hit wins.

Relationship to AgentDiscovery

AgentDiscovery (#150) tracks per-agent health state (HEALTHY/DEGRADED/UNREACHABLE). You can pre-filter the dispatch list before calling wait_for_results:

healthy_agents = [a for a in candidates if discovery.state(a) != AgentState.UNREACHABLE]
result = await aggregator.wait_for_results(task_id, expected=len(healthy_agents))

This avoids waiting for agents that are already known to be down.

Related

• Add MeshResultAggregator: collect, merge, and score results from distributed AgentMesh tasks #159 MeshResultAggregator implementation
• Add AgentDiscovery: service registry and health tracking for AgentMesh #150 AgentDiscovery health states
• Add AgentMesh coordinator: multi-agent task distribution and result aggregation #147 AgentMesh dispatch
• Add circuit breaker pattern to CognitiveCycle: auto-disable persistently failing modules with OPEN/HALF_OPEN/CLOSED health states #137 Circuit breaker (last-good fallback pattern)