OWASP ASI08 Cascading Failures: limits that hold at machine speed

One fault spreads through many agents faster than people can follow. A breaker between planner and executor, budgets that cannot be raced, and a pause for the last resort.

· 7 min read

ASI08 Cascading Failures is the eighth risk in OWASP’s Top 10 for Agentic Applications. One fault, such as a hallucination, a poisoned input or a corrupted tool, spreads from agent to agent and grows into damage across systems. OWASP is precise about the scope: ASI08 is “the propagation and amplification of an initial fault”, not the fault itself. The poisoned memory is ASI06; the hundred agents acting on it is ASI08.

It is also the entry where OWASP is most candid about people. It names a gap between “the speed and scale of fault propagation in a multi-agent system and the ability of humans to keep up”, and says some risk will stay unmitigated. A person approving each step is not the answer here. Limits that hold without a person are.

How a cascade shows itself

OWASP lists symptoms that double as detection hooks, which makes the entry practical:

Fast fan-out
One decision sets off many downstream agents or tasks within a short time.
Spread across borders
The effect reaches other domains or tenants than the one it started in.
Loops
Retries that oscillate, or agents that feed on each other's output and amplify it.
Storms
Queues filling up downstream, or the same intent repeated again and again.

Its examples include a trading system where an injected analysis agent inflates risk limits and the execution agents trade bigger while compliance sees only “within-parameter” activity, and a “governance drift cascade”: oversight weakens after a run of successes, and bulk approvals let drift through unchecked.

Separate the planner from the executor

Two mitigations make the same point: validate “every high-impact tool invocation against a policy-as-code rule before executing it”, and keep planning and execution apart so a corrupt plan cannot act on its own. In practice the executor treats each planned step as untrusted, sends every step that changes something through the gate, where rules answer the routine ones, and stops a storm without waiting for anyone:

// The executor treats every planned step as untrusted. It counts per run
// and by action, so 500 steps that differ only by tenant trip it too.
const MAX_PER_ACTION = 20;

async function executeRun(run: Run) {
  const counts = new Map<string, number>();
  for (const step of run.steps) {
    const count = (counts.get(step.action) ?? 0) + 1;
    counts.set(step.action, count);
    if (count > MAX_PER_ACTION) {
      throw new CircuitOpen(`${step.action} planned ${count} times; run stopped`);
    }
    if (READ_ONLY.has(step.action)) {
      await tools[step.action](step.args);
      continue;
    }
    // Every step that changes something asks; rules answer the routine ones.
    await approvals.guard(
      {
        action: step.action,
        summary: describe(step),
        details: { run: run.id, step: step.index, planned_by: step.plannerAgent },
      },
      () => tools[step.action](step.args)
    );
  }
}

The per-run counter is the blast-radius guardrail OWASP calls a “circuit breaker between planner and executor”. The request details name the run, the step and the planner, so a person deciding, and the record afterwards, can see which plan produced it.

Limits that hold at machine speed

OWASP asks for “quotas, progress caps, circuit breakers” and rate limiting that can “throttle or pause on anomalies”. The parts an approval service can enforce for you:

# The rule approves up to €1,000 a day on its own; past that, a person decides.
{ "action": "infra.provision", "effect": "allow",
  "limit_amount": "200.00", "limit_currency": "EUR",
  "budget_amount": "1000.00", "budget_currency": "EUR", "budget_period": "day" }

# A change that goes out everywhere at once needs two people.
{ "action": "config.rollout_all", "effect": "ask", "approvals": 2 }
  • Budgets do not race. Requests that arrive at the same moment are counted one after the other, so a burst of agents can never take a rule past its budget. Past it, requests wait for a person.
  • Fan-out actions ask. A change that reaches every region or tenant gets its own action name and an ask rule, with two people for the largest.
  • Each key has a rate limit. One agent key may make 600 calls a minute to the approvals API; a storm beyond that is refused.

A pause as the last breaker

When the symptoms show, someone has to be able to stop it in one move. A pause of one agent, or of the whole workspace, makes every answer read not allowed, including what was approved before, until an owner resumes. Any member can pull it, from the app or from a runbook:

# On-call runbook: stop one agent while you look (any member).
curl -X PUT https://api.variantgate.com/v1/workspaces/WORKSPACE_ID/agent-keys/KEY_ID/pause \
  -H "authorization: Bearer $SIGNED_IN_TOKEN"

# Or stop every agent in the workspace.
curl -X PUT https://api.variantgate.com/v1/workspaces/WORKSPACE_ID/pause \
  -H "authorization: Bearer $SIGNED_IN_TOKEN"

The pause call needs a person’s sign-in token, not an agent key, so it belongs to the on-call person’s tooling. The breaker inside the executor is what reacts in milliseconds.

Watch the oversight itself

Governance drift is a cascade in slow motion: people approve more and read less. OWASP’s mitigation is to “track decisions vs baselines”. Insights shows the share of requests answered by rules over 7, 30 or 90 days, against the period before: the number to watch when rules quietly grow broader. Every decision and workspace change sits in a sealed record, the audit trail OWASP’s last mitigation asks for, though tracing messages between your agents is still yours to log.

A gate can only stop what passes through it. Put the executor, not the planner, in front of every tool that changes something, and the cascade has one place where it must stop and ask.

Rogue agents, the other runaway risk, are covered in ASI10 Rogue Agents. All ten risks are in the OWASP agentic Top 10 overview.

Sources

  1. OWASP Top 10 for Agentic Applications for 2026, ASI08 Cascading Failures
  2. Google SRE book: Addressing Cascading Failures