Agentic Patterns That Survive Production

The interesting part of an AI agent is rarely the model call. It is everything around it: the context it receives, the tools it can use, the feedback it gets and the point at which it must stop.

The Awesome Agentic Patterns catalogue is useful because it collects those recurring solutions instead of presenting agents as one magic architecture. I find five groups especially practical.

1. Give the agent the right context

More context is not automatically better context. Curate the files, retrieve only relevant facts, preserve useful state outside the context window and load detail only when the agent needs it.

For a coding agent, that might mean a small project map, the relevant package boundaries and the failure from the last test run—not the entire repository pasted into every prompt.

Useful patterns include curated context windows, semantic filtering, filesystem-based state, memory retrieval and progressive disclosure. The goal is simple: make the next decision easier without making the prompt enormous.

2. Build feedback into the loop

An agent should have a way to find out whether its last action worked. Tests, schema validation, linters, browser checks, human review and deterministic graders all turn an open-ended loop into something we can inspect.

The pattern I trust most is straightforward:

  1. State the intended outcome.
  2. Take one bounded action.
  3. Check the result with evidence.
  4. Retry, revise or stop.

That is more useful than asking an agent to “try harder”. Feedback tells it what changed and what still fails.

3. Orchestrate only when the work needs it

There are several ways to split work:

  • Routing: send each request to the specialist or model best suited to it.
  • Parallel work: ask independent agents to analyse the same problem, then combine the results.
  • Planner and workers: let one agent break down the task and others execute bounded pieces.
  • Sub-agents: delegate a focused investigation and return a compact result.
  • Human approval: pause before an action with real cost or consequence.

These patterns add coordination, tokens and failure modes. They are worthwhile when the task genuinely benefits from specialisation or independent perspectives. They are wasteful when one clear function and one good check would do the job.

4. Treat tools as security boundaries

A tool is an action with consequences, not just another prompt. Keep capabilities narrow, validate inputs, restrict credentials, log important calls and make destructive operations explicit.

Tool capability compartmentalisation is a useful design rule: an agent that can search does not automatically need permission to write; an agent that can draft a payment does not automatically need permission to submit it.

The same principle applies to the environment. Sandboxes, egress controls, approval gates and scoped credentials matter more as the agent becomes more autonomous.

5. Make the system explainable enough to operate

Production agents need more than a final answer. I want to know which tools ran, which checks passed, where the agent changed course and why it stopped. Traces, structured events, replayable actions and useful artefacts make failures diagnosable.

The catalogue includes patterns for observability, action replay, circuit breakers, security scanning and evidence-layered evaluation. They are not decorative extras. They are how an agent becomes something a team can support.

My selection rule

I start with a single agent or deterministic workflow. Then I add one pattern in response to a measured problem:

  • Context is too large: retrieve or curate it.
  • The agent repeats mistakes: add feedback and verification.
  • Requests need different expertise: add routing.
  • Independent views improve confidence: add parallel analysis.
  • The action is risky: add authorisation and human approval.
  • The workflow outgrows one agent: introduce delegation or orchestration.

Patterns are ingredients, not a reference architecture. The best design is the smallest combination that produces a reliable outcome, leaves evidence behind and gives me a clear next step when it fails.