Ten 95% Reliable Agents Chained Together Give You a 60% System. Microservices Solved This a Decade Ago.

# The reliability compounding math:

def system_reliability(agent_count, individual_reliability):
    return individual_reliability  agent_count

# Real-world scenarios:
scenarios = {
    "3_agents_99%": system_reliability(3, 0.99),   # 97.0% - acceptable
    "5_agents_95%": system_reliability(5, 0.95),   # 77.4% - concerning
    "10_agents_95%": system_reliability(10, 0.95), # 59.8% - unacceptable
    "10_agents_99%": system_reliability(10, 0.99), # 90.4% - barely ok
    "15_agents_95%": system_reliability(15, 0.95), # 46.3% - broken
}

# The problem: most agent failures happen at HANDOFF POINTS
# Not inside the agent. Between agents.
# - Message not received (network, queue full, timeout)
# - Message misinterpreted (schema mismatch, stale context)
# - Response ignored (sender moved on, retry exhausted)
# - Cascade triggered (one failure propagates to all downstream)

# Microservices solution: service mesh (Istio, Linkerd)
# - Automatic retries with exponential backoff
# - Circuit breakers to prevent cascade
# - Load balancing across replicas
# - Mutual TLS for identity
# - Observability built into every call

# Agent equivalent: does not exist in standard tooling

# Microservices before service mesh (2014):
# Every service implements its own:
# - Retry logic (inconsistent across teams)
# - Timeout handling (some services: 5s, others: 60s, nobody knows)
# - Circuit breaking (most services: none)
# - Load balancing (hardcoded IPs in config)
# - Observability (some teams log, most don't)
# Result: cascading failures, 3 AM pages, blame games

# Microservices after service mesh (2017+):
# Infrastructure handles:
# - Automatic retries (configurable, consistent)
# - Timeouts (enforced at mesh level)
# - Circuit breaking (automatic, per-service)
# - Load balancing (intelligent, health-aware)
# - Observability (every call traced automatically)
# Result: 99.9% reliability, self-healing, observable

# AI agents in 2026: STILL IN THE "BEFORE" STATE
# Every agent framework implements its own:
# - Retry logic (LangChain: yes, CrewAI: different, custom: maybe)
# - Timeout handling (per-framework, inconsistent)
# - Circuit breaking (almost nobody)
# - Load balancing (not applicable? actually yes: agent replicas)
# - Observability (framework-specific, not standardized)
# Result: 41-87% failure rates. Exactly where microservices were in 2014.

from rosud_call import AgentMesh, ReliabilityPolicy

# The service mesh equivalent for AI agents:
mesh = AgentMesh.configure(
    reliability=ReliabilityPolicy(
        # Automatic retries (not left to each agent)
        retry={
            "max_attempts": 3,
            "backoff": "exponential",
            "retry_on": ["timeout", "stale_context", "quality_below_threshold"]
        },

        # Circuit breaker (prevent cascade)
        circuit_breaker={
            "failure_threshold": 0.3,  # Trip at 30% failure rate
            "recovery_timeout_s": 30,
            "half_open_requests": 3
        },

        # Timeout enforcement (consistent across all agents)
        timeout={
            "per_message_ms": 5000,
            "per_workflow_ms": 30000,
            "on_timeout": "escalate_or_fallback"
        },

        # Health checking (know which agents are degraded)
        health_check={
            "interval_ms": 10000,
            "criteria": ["response_time", "output_quality", "context_freshness"]
        }
    )
)

# System reliability with mesh:
# 10 agents at 95% individual + mesh retry/circuit breaker:
# Effective per-handoff reliability: 99.7% (retries catch transient failures)
# System reliability: 0.997^10 = 97.0%
# vs without mesh: 59.8%
# Improvement: 59.8% → 97.0% (from 4 out of 10 failing to 3 out of 100)