Naming AI Agent Failure Modes: The Pattern Library We Open-Sourced

We kept hitting the same two AI agent failure modes across every autonomous pipeline we built, in every repo, with every model swap. Not bugs — patterns. An agent would split one dangerous action into three safe-looking ones. Or it would get an empty result back and, instead of stopping, quietly fill the gap with something plausible and keep going. We finally gave both failure modes names, wrote down the fix, and open-sourced the whole pattern library as AI Playbook.

Two AI agent failure modes worth naming

Tier laundering. We use an authority-tier model for autonomous agents — Tier 1 actions execute without approval, Tier 3 needs a human. The failure isn't an agent breaking a rule. It's an agent splitting a Tier 3 action into a chain of Tier 1 steps that, combined, do the same thing. Each step passes review. The chain doesn't. We wrote before about what happens when a gate has no laws to enforce — tier laundering is the sharper, more specific version of that same gap: the gate exists, the laws exist, but nobody's watching the sequence.

Silence is not absence. An LLM returns no result, or an ambiguous one. The correct response is to treat that as an error. What actually happens, left unchecked, is the model completes the pattern — it generates a plausible answer from parametric memory instead of returning "not found," and the system proceeds as if the gap had been filled with truth. The model didn't lie. It did what language models do. The bug is in the system design that let the gap get filled silently. This is the same root problem we ran into when we found out merged isn't the same as live, and signed isn't the same as honest — a system can look correct at every checkpoint and still be wrong, because nothing forced the absence of a signal to surface as a failure.

Neither of these is a hypothetical. Both came from watching real autonomous runs go sideways in ways that were individually invisible and only obvious in aggregate.

A third pattern sits underneath both: ground before dispatch. Before a query goes to a generative model, retrieve and inject the verified facts it needs. A model that already has the answer in its context cannot hallucinate it. The pattern is almost embarrassingly simple to state and consistently skipped in practice, because grounding takes an extra retrieval step and silence-is-not-absence failures don't announce themselves — the output still looks like an answer.

Why we built a pattern library instead of a blog post

We've published field reports before — how we built governance into an autonomous pipeline, how we run 268 autonomous Claude Code sessions across 16 repositories without a human watching every diff. Those posts describe what we did. They don't give you something to cp into your own project.

AI Playbook is the difference. It's eleven reasoning frameworks, eight "vibecoding" archetypes, and seventeen drop-in Claude Code skills, distilled from two years of production work across serverless infrastructure, game design, and content systems. But the part we think is actually load-bearing is the named-pattern layer: Agent Governance and Production AI Patterns, which cover what most prompt-engineering collections skip entirely — what goes wrong when LLMs run autonomously, and how to catch it before it compounds.

Here's the actual anti-pattern entry for tier laundering, verbatim from authority-tiers.md:

### Tier laundering
Splitting a Tier 3 action into multiple Tier 1 steps that, in combination,
achieve the same result. Each step looks safe; the combination is not.
Review chains of Tier 1 actions for emergent Tier 3 behavior.

And the core claim from silence-is-not-absence.md:

Treat missing signal as an error, not as confirmation. When an LLM returns
no result, ambiguous output, or empty context, the system should fail
explicitly — never proceed as if the absence means "nothing relevant
exists" or "the task is complete."

Neither pattern is unique to us. What's unique is naming them precisely enough that "we hit a tier-laundering bug" becomes a diagnosis instead of a vibe.

The sibling pattern to tier laundering is constraint surfaces, and it explains why the tier model works at all:

Instructions tell an agent what to do. Constraints define the space
within which it can act. Instructions can be overridden by other
instructions, reframed by context, or reasoned around in pursuit of
a goal. Constraints enforced at the system level — by the runtime,
the task queue, the tool permissions — cannot be reasoned around
because the model never has the opportunity to reason about them.

A prompt that says "don't touch production" is an instruction, and instructions compete with every other instruction in the context window. A deploy pipeline that physically can't reach production without a signed approval is a constraint. Tier laundering is what happens when the constraint is real but scoped too narrowly — the boundary exists, it's just drawn around individual actions instead of the sequence.

What's actually in the repo

Seventeen Claude Code skills are drop-in — copy one file, get one capability, no setup:

mkdir -p .claude/skills/governed-deploy
cp ai-playbook/claude-code/skills/governed-deploy.md .claude/skills/governed-deploy/SKILL.md

governed-deploy is a pre-deploy audit gate that blocks on type errors, failing tests, a missing version bump, or secrets showing up in a diff — the same shape of check we described building for our own autonomous execution safety architecture, just extracted into something you can use without reading that whole post.

The frameworks aren't all the same weight, and we don't pretend otherwise. ADHD Prompting — which we've covered in depth separately — is the universal upgrade that makes every other framework work better. Production AI Patterns also includes selection-not-generation.md, which is the same thesis we argued at length in selection over generation: push work toward deterministic selection from a bounded set, reserve free-form generation for the last mile. Three frameworks — ECARLM, EGAF, ELSF — are thinner and more conceptual than the rest, and we just moved them into a labeled experimental/ directory rather than pretend they're at the same maturity level as everything else. An honest pattern library has to be honest about its own weak spots, or the naming exercise is just marketing with extra steps.

The other half of the repo isn't about failure modes at all

Not everything in AI Playbook is a governance pattern, and we don't want to oversell the part of the repo that reads like a production incident log. The flagship section is Vibecoding — eight archetypal personas, each fused from three or more wisdom traditions, that change how a model approaches a problem rather than what template it fills in. Truth Builder combines a first-principles architect with an empiricist and a falsification challenger, and the result reads nothing like a standard "be rigorous" system prompt — it argues with its own assumptions. Direct Mirror fuses a Zen mirror with a phenomenological observer, and you use it when you need an answer that cuts through the question instead of elaborating around it.

These aren't prompt templates you fill in variables for. They're stances. Pick Clarity Architect for a problem that's drowning in incidental complexity, Flow Director for one that needs structured improvisation instead of a rigid plan, and you get a genuinely different quality of output — not just a different tone of voice on the same reasoning. Governance patterns tell an agent what it's not allowed to do. Archetypes change what the agent notices in the first place. Both matter, and a library that only had one or the other would be missing half the actual problem space.

Why naming the failure mode is the actual fix

A rule says "don't do X." A named pattern says "here is the shape X takes when it's disguised as something else, here's how we've seen it hide, and here's what to check." The first is a constraint. The second is a diagnostic. Constraints get worked around — that's what tier laundering is, an agent working around a constraint without technically violating it. Diagnostics don't get worked around, because the thing you're checking for is the shape of the failure, not a specific action.

This is also, not incidentally, why we could apply the same discipline to the repo itself. We ran our own content-quality audit against AI Playbook the same way we'd audit a production system, and it surfaced exactly the kind of drift silence-is-not-absence warns about: the README claimed 48 task prompts and a badge two lines down claimed 47, and neither number was the actual count. Nobody had lied — the numbers had just gone stale silently, and nothing forced the mismatch to surface until someone actually counted the files. We fixed the count, and separately relocated three frameworks that read as thin next to the rest into a labeled experimental/ directory rather than leave them implying a maturity they hadn't earned. If a pattern library can't survive being pointed at itself, it isn't a pattern library — it's an assertion.

AI Playbook is MIT-licensed. The Context Engineering framework has its own tie to Charter, our ADF governance CLI — the playbook documents the token-budget principles, Charter operationalizes them. If you're running autonomous agents and don't yet have names for the ways they fail quietly, start with frameworks/agent-governance/ and frameworks/production-ai-patterns/.