Multi-Agent System Observability with Temporal: How We Cut Cost 65% and Latency 70%

Failure mode here can take the form of the worker consuming the entire request budget, preventing the reviewer from starting and leaving the orchestrator with only a late exception.

The terminal message was blunt:

The next request would exceed the request_limit of 50

That is pydantic-ai’s default ceiling on model requests per agent.run() — a safety net, not a product SLA we had chosen. In a multi-agent design it is catastrophic: you pay for the loop and you never get the quality gate.

One model activity in that run lasted more than two minutes. Context grew from tens of kilobytes toward hundreds. We were not waiting on a database. We were buying turns for a button the model should not have had.

The looping call was not a knowledge lookup. It was string hygiene — strip a leading v from a version — exposed as a first-class tool.

In a Temporal + pydantic-ai world, every tool call is an activity. Every accidental press is durable, billed, and visible… after you have already paid.

We re-drew the boundary:

def compute_deterministic_verdict(
    ctx,
    current_version: str,
    releases: list[dict],
    is_eol: bool,
    is_incompatible: bool,
    no_compatible_version_available: bool = False,
) -> dict:
    current = normalize_version(current_version)  # local, free
    # …pure verdict math…
    return {
        "upgrade_recommended": ...,
        "recommended_version": ...,
    }

# Agent tools: retrieval and policy — not string hygiene
tools = [compute_deterministic_verdict, ...]

The system prompt had told the model it must call the normalizer. Prompt and tool surface had been collaborating on the loop. We removed both.