70 AI design patterns for LLM apps and agents

Split the task into fixed steps where each output feeds the next input.

Classify the input and send each kind down a specialized path.

Break the task into independent parts and run them all in parallel.

Run the same task several times or with several models and decide by majority or threshold.

One model decides subtasks on the fly and hands them to workers.

One model generates, another grades against clear criteria, and the loop repeats until it passes.

Require the model to answer in a schema and validate the response.

Pick, at request time, the examples most similar to the current input.

Store prompts as versioned artifacts with variables and history.

Process chunks in parallel and then combine the results into one answer.

Fetch relevant passages and hand them to the model along with the question.

Combine keyword and vector search so you miss neither synonyms nor exact codes.

Retrieve many candidates and use a sharper model to pick the best ones.

Turn the user's question into one or more better searches.

Walk relationships between entities when the answer depends on connections, not one passage.

Let the agent decide when, where, and how many times to search.

Split documents along their structure and attach to each chunk the context it came from.

Summarize or prune the context as it grows, keeping what matters.

Run subtasks in separate contexts and bring back only the result.

Show the model only a summary of each skill and load the details when it asks.

Require every claim to point at a source and check that the source says it.

Keep the current conversation's state explicit, outside the raw transcript.

Store facts and preferences across sessions and bring back only the relevant ones.

Remember past runs, what worked and what failed, to act better next time.

Review memories in the background to merge, correct, and forget.

Give the agent a place to note its plan and partial results outside the conversation.

Save state at safe points so the run can continue where it stopped.

Run the agent on an engine that guarantees each step through crashes and long waits.

A structured space where several agents post and read facts, each with an owner and a format.

Give the model well described functions to fetch data and take action.

Pick a small subset of tools before calling the main model.

Let the model write and run code in an isolated, disposable environment.

Drive graphical interfaces through screen, mouse, and keyboard when there is no API.

Navigate, read, and fill web pages using the DOM structure.

Expose systems as MCP servers so any agent uses the same contract.

Shrink large tool responses to what matters before they reach the model.

Produce the action plan and show its effect before actually running it.

Make sure repeating the same call never duplicates the effect.

For every step with an effect, have a step that undoes it, as in a saga.

Alternate reasoning, action, and observation until the task is done.

Write the full plan first and execute steps with a simpler model or with code.

Revise the plan when reality does not match expectations.

Have the model critique its own result against an external signal and fix it.

Generate several reasoning paths and keep the most frequent answer.

Explore alternatives as a tree, score each branch, and prune the bad ones.

Pause at defined points for a human to approve, edit, or reject.

Transfer the conversation to another specialist agent along with the needed state.

The main agent spawns subagents for focused tasks and receives only the conclusion.

One agent coordinates others, decides who works, and checks the delivery.

Two or more models argue positions and a judge decides.

Define clearly when the agent is done, has given up, or needs help.

Keep an agent working for hours or days with goals, checkpoints, and reports.

Check input before the main model: topic, abuse, injection, and sensitive data.

Check the response before it reaches the user or a tool.

A quarantined model reads untrusted content; another, with tools, only sees the structured result.

Each tool with its own scope, credential, and limits.

Grade the response against a short list of written principles and revise on violation.

Keep another model or provider ready to take over when the main one fails.

Stop calling a failing service and resume once it recovers.

Validate output with code and, on failure, send the error back to the model to fix.

Remove or mask personal data before the model and the logs, in line with privacy law.

Record who asked, what the model saw, what it decided, and what it ran.

Run test cases automatically on every prompt, model, or code change.

Use a model with a rubric to grade answers that have no exact expected output.

Keep a curated set of inputs and expected answers that grows with real bugs.

Run the new version alongside real traffic, hidden from users, and compare.

Start with the cheapest model and move up only when needed.

Answer equivalent questions with an already generated response.

Reuse the fixed prompt prefix to cut cost and latency.

Measure and cap spending per task, user, and day, with alerts and a cut-off plan.