What happened
A project titled Design Patterns for AI has been published as a catalog of patterns for building agentic systems that “verify their work with evidence, not opinion.” The site frames the work as an effort to make probabilistic systems more reliable by reducing variance and bias through explicit context, executable checks, and controlled orchestration.
The material is organized in a way that echoes classic software pattern books: it groups named patterns into categories and gives each one a clear purpose. The catalog also starts by separating two broad failure classes it wants to address:
- Variance failures, including sampling instability, ambient state, context contamination, asynchronous timing, and non-deterministic tool state.
- Bias failures, including sycophancy, self-review blindness, judge preference bias, confirmation framing, and same-family blind spots.
From there, the site presents three main sections of patterns:
- Context and State — patterns for making what exists before the model acts explicit and machine-readable.
- Verification — patterns for turning judgment into observable signals.
- Orchestration — patterns for controlling bias through independence and feedback routing.
Examples include Causal Tag, which stamps events with stable identifiers for attribution; Constitution, which makes verification criteria versioned and machine-readable; Guardrail Decorator, which wraps model or tool boundaries in policy code; Blind Oracle, which derives expected evidence without conditioning on the draft being reviewed; and Tool Adapter, which normalizes tool calls at a typed boundary.
The catalog’s core idea is that verification should be part of the system design, not an afterthought or a prompt instruction. It argues that “variance is the new coupling” and “anchoring is the new cohesion,” using that framing to describe how each pattern constrains a specific source of error.
Why it matters
The project is notable because it treats AI reliability as a software architecture problem. Instead of relying on vague instructions for a model to “be careful” or “self-check,” it pushes for explicit structures that can be inspected, validated, and repeated.
That approach matters most in agentic systems, where a model does more than generate text. Once a model can call tools, update state, hand off work, or trigger downstream effects, the cost of uncertainty rises. In that setting, the catalog’s emphasis on evidence-based verification becomes practical rather than theoretical.
Several ideas in the catalog point in the same direction:
- Make state explicit. Patterns such as State Baseline and Trajectory Cursor try to avoid inference from chat history alone.
- Separate generation from judgment. Patterns such as Admissibility Gate, Comparator, and Judge Harness aim to make verification more deterministic or at least more measurable.
- Reduce shared bias. Patterns such as Cross-Family, Debate, and Adversary route work through distinct roles or model families so a single failure mode is less likely to pass unchecked.
- Shift policy into code. Guardrail Decorator and Tool Adapter move critical checks to typed boundaries rather than asking the model to remember rules.
For teams building AI products, that framing offers a vocabulary for discussing reliability. Even without adopting the full catalog, developers can use the pattern names to identify whether a problem is about state, proof, orchestration, or evaluation.
The project also stands out stylistically. By borrowing the language of design patterns, it makes AI systems feel more like systems engineering and less like prompting folklore. That makes the catalog easier to discuss, compare, and extend.
What to watch
The most important question is whether these patterns become useful as a shared engineering language. A pattern catalog only matters if teams can apply it consistently and map it to real implementation choices.
A few things will be worth watching:
- Adoption as a reference vocabulary. If builders start naming reliability issues using terms like Blind Oracle or Admissibility Gate, the catalog could help standardize how teams talk about verification.
- Translation into code. The strongest patterns in the catalog are the ones that can be implemented as typed boundaries, replayable checks, and structured orchestration rather than purely descriptive guidance.
- Coverage of real-world failure modes. The source material focuses on bias and variance in AI behavior, especially in agentic workflows. The next test is whether the pattern set can address more complex production settings without becoming too abstract.
- Boundaries of determinism. The project is explicit that the goal is to approach deterministic behavior where full determinism is unavailable. That is an important constraint: the value here is not perfect certainty, but more reliable systems.
The source is a single project page, so the broader roadmap, implementation details, and real-world examples are not fully visible from the supplied material. Even so, the catalog itself is a clear statement of intent: make AI systems easier to verify by designing for evidence, structure, and controlled failure handling from the start.
