llms.txt

# Awesome Agentic Patterns

A curated catalogue of AI agent design patterns.

## Patterns

### abstracted-code-representation-for-review
Abstracted Code Representation for Review: Reviewing AI generated code line by line is time intensive and cognitively demanding.
URL: https://agentic-patterns.com/patterns/abstracted-code-representation-for-review

### action-caching-replay
Action Caching & Replay Pattern: LLM based agent execution is expensive (both in costs and latency) and non deterministic.
URL: https://agentic-patterns.com/patterns/action-caching-replay

### action-selector-pattern
Action-Selector Pattern: In tool enabled agents, untrusted data from emails, web pages, and API responses is often fed back into the model between steps.
URL: https://agentic-patterns.com/patterns/action-selector-pattern

### adaptive-sandbox-fanout-controller
Adaptive Sandbox Fan-Out Controller: Parallel sandboxes are intoxicating: you can spawn 10...
URL: https://agentic-patterns.com/patterns/adaptive-sandbox-fanout-controller

### agent-modes-by-model-personality
Agent Modes by Model Personality: Different AI models have fundamentally different personalities and working styles.
URL: https://agentic-patterns.com/patterns/agent-modes-by-model-personality

### agent-reinforcement-fine-tuning
Agent Reinforcement Fine-Tuning (Agent RFT): Train model weights end-to-end on agentic tasks via reinforcement learning with real tool calls and custom reward signals, optimizing for domain-specific tool use efficiency and multi-step reasoning performance.
URL: https://agentic-patterns.com/patterns/agent-reinforcement-fine-tuning

### agent-sdk-for-programmatic-control
Agent SDK for Programmatic Control: Interactive terminal or chat interfaces are suitable for many agent tasks, but not for all.
URL: https://agentic-patterns.com/patterns/agent-sdk-for-programmatic-control

### agent-assisted-scaffolding
Agent-Assisted Scaffolding: Starting a new feature, module, or codebase often involves writing a significant amount of boilerplate or foundational code.
URL: https://agentic-patterns.com/patterns/agent-assisted-scaffolding

### agent-driven-research
Agent-Driven Research: Traditional research methods often lack the ability to adapt search strategies based on emerging results, limiting efficiency and potential discoveries.
URL: https://agentic-patterns.com/patterns/agent-driven-research

### agent-first-tooling-and-logging
Agent-First Tooling and Logging: Most developer tools, CLIs, and application logs are designed for human consumption.
URL: https://agentic-patterns.com/patterns/agent-first-tooling-and-logging

### agent-friendly-workflow-design
Agent-Friendly Workflow Design: Simply providing an AI agent with a task is often not enough for optimal performance.
URL: https://agentic-patterns.com/patterns/agent-friendly-workflow-design

### agent-powered-codebase-qa-onboarding
Agent-Powered Codebase Q&A / Onboarding: Understanding a large or unfamiliar codebase can be a significant challenge for developers, especially when onboarding to a new project or trying to debug a complex system.
URL: https://agentic-patterns.com/patterns/agent-powered-codebase-qa-onboarding

### agentic-search-over-vector-embeddings
Agentic Search Over Vector Embeddings: TODO: Add a concise summary for "Agentic Search Over Vector Embeddings" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/agentic-search-over-vector-embeddings

### ai-web-search-agent-loop
AI Web Search Agent Loop: Traditional LLMs have a training cutoff date, meaning they don't know recent facts or real time information.
URL: https://agentic-patterns.com/patterns/ai-web-search-agent-loop

### ai-accelerated-learning-and-skill-development
AI-Accelerated Learning and Skill Development: Developing strong software engineering skills, including "taste" for clean and effective code, traditionally requires extensive experience, trial and error, and
URL: https://agentic-patterns.com/patterns/ai-accelerated-learning-and-skill-development

### ai-assisted-code-review-verification
AI-Assisted Code Review / Verification: As AI models generate increasing amounts of code, the bottleneck in software development shifts from code generation to code verification and review.
URL: https://agentic-patterns.com/patterns/ai-assisted-code-review-verification

### anti-reward-hacking-grader-design
Anti-Reward-Hacking Grader Design: Design reward functions with multi-criteria evaluation and iterative hardening to prevent models from gaming graders, ensuring training rewards align with actual task quality.
URL: https://agentic-patterns.com/patterns/anti-reward-hacking-grader-design

### multi-step-analysis-pipeline-orchestration
Artifact-Driven Analysis Pipeline Orchestration: Complex data analysis tasks often require running many sequential or parallel processing steps, each producing intermediate artifacts that feed into subsequent stages.
URL: https://agentic-patterns.com/patterns/multi-step-analysis-pipeline-orchestration

### asynchronous-coding-agent-pipeline
Asynchronous Coding Agent Pipeline: Synchronous execution of coding tasks—where the agent must wait for compilation, testing, linting, or static analysis—creates compute bubbles and idle resources .
URL: https://agentic-patterns.com/patterns/asynchronous-coding-agent-pipeline

### autonomous-workflow-agent-architecture
Autonomous Workflow Agent Architecture: TODO: Add a concise summary for "Autonomous Workflow Agent Architecture" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/autonomous-workflow-agent-architecture

### background-agent-ci
Background Agent with CI Feedback: ## Problem
Long-running tasks tie up the editor and require developers to babysit the agent.
URL: https://agentic-patterns.com/patterns/background-agent-ci

### budget-aware-model-routing-with-hard-cost-caps
Budget-Aware Model Routing with Hard Cost Caps: Agent systems often route every request to the strongest model by default, which quietly inflates cost and reduces throughput under load.
URL: https://agentic-patterns.com/patterns/budget-aware-model-routing-with-hard-cost-caps

### burn-the-boats
Burn the Boats: In fast moving AI development, holding onto features or workflows that are "working fine" prevents teams from fully embracing new paradigms.
URL: https://agentic-patterns.com/patterns/burn-the-boats

### canary-rollout-and-automatic-rollback-for-agent-policy-changes
Canary Rollout and Automatic Rollback for Agent Policy Changes: Agent behavior changes frequently through prompt updates, tool policies, routing rules, and evaluator thresholds.
URL: https://agentic-patterns.com/patterns/canary-rollout-and-automatic-rollback-for-agent-policy-changes

### chain-of-thought-monitoring-interruption
Chain-of-Thought Monitoring & Interruption: Implement active surveillance of agent reasoning with capability to interrupt and redirect before completing flawed execution sequences, preventing wasted time on fundamentally wrong approaches.
URL: https://agentic-patterns.com/patterns/chain-of-thought-monitoring-interruption

### cli-first-skill-design
CLI-First Skill Design: Design all skills as CLI tools first for dual-use by humans and agents, enabling manual debugging, programmatic invocation, composition with Unix tools, and transparent shell-based execution without building separate interfaces.
URL: https://agentic-patterns.com/patterns/cli-first-skill-design

### cli-native-agent-orchestration
CLI-Native Agent Orchestration: Most agent workflows start in chat UIs that are optimized for one off conversations, not repeatable engineering operations.
URL: https://agentic-patterns.com/patterns/cli-native-agent-orchestration

### code-first-tool-interface-pattern
Code Mode MCP Tool Interface Improvement Pattern: LLMs generate TypeScript code to orchestrate MCP tools in ephemeral V8 isolates, eliminating token-heavy round-trips and enabling efficient multi-step workflows with 10x+ token savings.
URL: https://agentic-patterns.com/patterns/code-first-tool-interface-pattern

### code-over-api-pattern
Code-Over-API Pattern: Agents write and execute code that processes data in execution environment instead of making direct API calls, dramatically reducing token consumption by keeping intermediate data out of context window (150K → 2K tokens).
URL: https://agentic-patterns.com/patterns/code-over-api-pattern

### code-then-execute-pattern
Code-Then-Execute Pattern: Free form plan and act loops are difficult to audit because critical control decisions stay implicit in natural language reasoning.
URL: https://agentic-patterns.com/patterns/code-then-execute-pattern

### codebase-optimization-for-agents
Codebase Optimization for Agents: When introducing AI agents to a codebase, there's a natural tendency to preserve the human developer experience (DX).
URL: https://agentic-patterns.com/patterns/codebase-optimization-for-agents

### coding-agent-ci-feedback-loop
Coding Agent CI Feedback Loop: When a coding agent tackles multi file refactors or feature additions, running tests and waiting for test feedback synchronously ties up compute and prevents the agent from working on parallel tasks.
URL: https://agentic-patterns.com/patterns/coding-agent-ci-feedback-loop

### compounding-engineering-pattern
Compounding Engineering Pattern: Codify all learnings from each feature into reusable prompts, slash commands, subagents, and hooks—making each feature easier to build by creating increasingly "self-teaching" codebase that accelerates productivity over time.
URL: https://agentic-patterns.com/patterns/compounding-engineering-pattern

### parallel-tool-execution
Conditional Parallel Tool Execution: When an AI agent decides to use multiple tools in a single reasoning step, executing them strictly sequentially can lead to significant delays, especially if many tools are read only and could be run concurrently.
URL: https://agentic-patterns.com/patterns/parallel-tool-execution

### context-window-anxiety-management
Context Window Anxiety Management: Models like Claude Sonnet 4.5 exhibit "context anxiety"—they become aware of approaching context window limits and proactively summarize progress or make decisive moves to close tasks, even when sufficient context remains.
URL: https://agentic-patterns.com/patterns/context-window-anxiety-management

### context-window-auto-compaction
Context Window Auto-Compaction: Context overflow is a silent killer of agent reliability.
URL: https://agentic-patterns.com/patterns/context-window-auto-compaction

### context-minimization-pattern
Context-Minimization Pattern: In long agent sessions, raw user text and tool outputs often remain in context long after they are needed.
URL: https://agentic-patterns.com/patterns/context-minimization-pattern

### continuous-autonomous-task-loop-pattern
Continuous Autonomous Task Loop Pattern: Traditional development workflows require constant human intervention for task management: Manual Task Selection : Developers spend time deciding what to work o
URL: https://agentic-patterns.com/patterns/continuous-autonomous-task-loop-pattern

### criticgpt-style-evaluation
CriticGPT-Style Code Review: As AI generated code becomes more sophisticated, it becomes increasingly difficult for human reviewers to catch subtle bugs, security issues, or quality problems.
URL: https://agentic-patterns.com/patterns/criticgpt-style-evaluation

### cross-cycle-consensus-relay
Cross-Cycle Consensus Relay: Autonomous multi agent loops that run across many cycles (minutes, hours, or days) need a way to reliably transfer context, decisions, and next actions between cycles.
URL: https://agentic-patterns.com/patterns/cross-cycle-consensus-relay

### curated-code-context-window
Curated Code Context Window: Loading all source files or dumping entire repositories into the agent's context overwhelms the model, introduces noise, and slows inference.
URL: https://agentic-patterns.com/patterns/curated-code-context-window

### curated-file-context-window
Curated File Context Window: A coding agent often needs to reason about multiple source files, but dumping all files into its prompt: Quickly exceeds token limits or inference budget.
URL: https://agentic-patterns.com/patterns/curated-file-context-window

### custom-sandboxed-background-agent
Custom Sandboxed Background Agent: Off the shelf coding agents (e.g., Devin, Claude Code, Cursor) are either: Too generic Not deeply integrated with company specific dev environments, tools, and
URL: https://agentic-patterns.com/patterns/custom-sandboxed-background-agent

### democratization-of-tooling-via-agents
Democratization of Tooling via Agents: Many individuals in non software engineering roles (e.g., sales, marketing, operations, communications) could benefit from custom software tools, scripts, or da
URL: https://agentic-patterns.com/patterns/democratization-of-tooling-via-agents

### deterministic-security-scanning-build-loop
Deterministic Security Scanning Build Loop: Non deterministic approaches to security in AI code generation (Cursor rules, MCP security tools) are fundamentally flawed because security requires absolute determinism code is either secure or not secure, with no grey area.
URL: https://agentic-patterns.com/patterns/deterministic-security-scanning-build-loop

### dev-tooling-assumptions-reset
Dev Tooling Assumptions Reset: Traditional development tools are built on assumptions that no longer hold: that humans write code with effort and expertise, that changes are scarce and valuable, that linear workflows make sense.
URL: https://agentic-patterns.com/patterns/dev-tooling-assumptions-reset

### discrete-phase-separation
Discrete Phase Separation: TODO: Add a concise summary for "Discrete Phase Separation" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/discrete-phase-separation

### disposable-scaffolding-over-durable-features
Disposable Scaffolding Over Durable Features: In a field where foundation models improve dramatically every few months, investing significant engineering effort into building complex, durable features around the model is extremely risky.
URL: https://agentic-patterns.com/patterns/disposable-scaffolding-over-durable-features

### distributed-execution-cloud-workers
Distributed Execution with Cloud Workers: TODO: Add a concise summary for "Distributed Execution with Cloud Workers" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/distributed-execution-cloud-workers

### dogfooding-with-rapid-iteration-for-agent-improvement
Dogfooding with Rapid Iteration for Agent Improvement: ## Problem
Developing effective AI agents requires understanding real-world usage and quickly identifying areas for improvement. External feedback loops can be slow, and simulated environments may not capture all nuances.
URL: https://agentic-patterns.com/patterns/dogfooding-with-rapid-iteration-for-agent-improvement

### dual-llm-pattern
Dual LLM Pattern: When the same model both reads untrusted content and controls high privilege tools, a single prompt injection path can convert benign context into privileged actions.
URL: https://agentic-patterns.com/patterns/dual-llm-pattern

### dual-use-tool-design
Dual-Use Tool Design: TODO: Add a concise summary for "Dual-Use Tool Design" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/dual-use-tool-design

### dynamic-code-injection-on-demand-file-fetch
Dynamic Code Injection (On-Demand File Fetch): During an interactive coding session, a user or agent may need to inspect or modify files not originally loaded into the main context.
URL: https://agentic-patterns.com/patterns/dynamic-code-injection-on-demand-file-fetch

### dynamic-context-injection
Dynamic Context Injection: While layered configuration files provide good baseline context, agents often need specific pieces of information (e.g., contents of a particular file, output of a script, predefined complex prompt) on demand during an interactive session.
URL: https://agentic-patterns.com/patterns/dynamic-context-injection

### economic-value-signaling-multi-agent
Economic Value Signaling in Multi-Agent Networks: In multi agent systems with many autonomous agents running concurrently, task prioritization becomes difficult.
URL: https://agentic-patterns.com/patterns/economic-value-signaling-multi-agent

### egress-lockdown-no-exfiltration-channel
Egress Lockdown (No-Exfiltration Channel): Even with private data access and untrusted inputs, attacks fail if the agent has no way to transmit stolen data .
URL: https://agentic-patterns.com/patterns/egress-lockdown-no-exfiltration-channel

### episodic-memory-retrieval-injection
Episodic Memory Retrieval & Injection: Stateless request handling causes agents to repeatedly rediscover decisions, constraints, and prior failures.
URL: https://agentic-patterns.com/patterns/episodic-memory-retrieval-injection

### explicit-posterior-sampling-planner
Explicit Posterior-Sampling Planner: Heuristic planning loops often over exploit the first plausible strategy and under explore alternatives.
URL: https://agentic-patterns.com/patterns/explicit-posterior-sampling-planner

### extended-coherence-work-sessions
Extended Coherence Work Sessions: Early AI agents and models often suffered from a short "coherence window," meaning they could only maintain focus and context for a few minutes before their performance degraded significantly (e.g., losing track of instructions, generating irrelevant output).
URL: https://agentic-patterns.com/patterns/extended-coherence-work-sessions

### external-credential-sync
External Credential Sync: Users manage AI API credentials across multiple tools—CLIs (Claude Code, Codex CLI), web portals, and local development environments.
URL: https://agentic-patterns.com/patterns/external-credential-sync

### factory-over-assistant
Factory over Assistant: The "assistant" model—working one on one with an agent in a sidebar, watching it work, ping ponging back and forth—limits productivity and scalability.
URL: https://agentic-patterns.com/patterns/factory-over-assistant

### failover-aware-model-fallback
Failover-Aware Model Fallback: AI model requests fail for varied and often opaque reasons.
URL: https://agentic-patterns.com/patterns/failover-aware-model-fallback

### feature-list-as-immutable-contract
Feature List as Immutable Contract: TODO: Add a concise summary for "Feature List as Immutable Contract" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/feature-list-as-immutable-contract

### filesystem-based-agent-state
Filesystem-Based Agent State: Agents persist intermediate results and working state to files, creating durable checkpoints that enable workflow resumption, recovery from failures, and support for long-running tasks.
URL: https://agentic-patterns.com/patterns/filesystem-based-agent-state

### frontier-focused-development
Frontier-Focused Development: AI capabilities advance rapidly along predictable scaling laws—products optimized for today's models become obsolete in months.
URL: https://agentic-patterns.com/patterns/frontier-focused-development

### graph-of-thoughts
Graph of Thoughts (GoT): Linear reasoning approaches like Chain of Thought (CoT) and even tree based methods like Tree of Thoughts (ToT) have limitations when dealing with problems that require complex interdependencies between reasoning steps.
URL: https://agentic-patterns.com/patterns/graph-of-thoughts

### hook-based-safety-guard-rails
Hook-Based Safety Guard Rails for Autonomous Code Agents: Autonomous code agents running unattended can execute destructive commands ( rm rf , git reset hard ), exhaust their context window without saving state, leak secrets via git push , or silently produce syntax errors that cascade into later failures.
URL: https://agentic-patterns.com/patterns/hook-based-safety-guard-rails

### human-in-loop-approval-framework
Human-in-the-Loop Approval Framework: Systematically insert human approval gates for designated high-risk functions while maintaining agent autonomy for safe operations, with multi-channel approval interfaces and comprehensive audit trails.
URL: https://agentic-patterns.com/patterns/human-in-loop-approval-framework

### hybrid-llm-code-workflow-coordinator
Hybrid LLM/Code Workflow Coordinator: Configurable coordinator supporting both LLM-driven (flexible, fast iteration) and code-driven (deterministic, code review) workflows, enabling progressive enhancement from prototype to production-ready systems.
URL: https://agentic-patterns.com/patterns/hybrid-llm-code-workflow-coordinator

### incident-to-eval-synthesis
Incident-to-Eval Synthesis: Many teams run agent evaluations, but the eval suite drifts away from real failures seen in production.
URL: https://agentic-patterns.com/patterns/incident-to-eval-synthesis

### inference-healed-code-review-reward
Inference-Healed Code Review Reward: Simple reward functions that only check for "all tests passed" fail to capture nuanced code quality issues (e.g., performance regressions, style violations, missing edge case handling).
URL: https://agentic-patterns.com/patterns/inference-healed-code-review-reward

### inference-time-scaling
Inference-Time Scaling: Traditional language models are limited by their training time capabilities.
URL: https://agentic-patterns.com/patterns/inference-time-scaling

### initializer-maintainer-dual-agent
Initializer-Maintainer Dual Agent Architecture: Long running agent projects face distinct failure modes at different lifecycle stages: Project initialization requires comprehensive setup: environment configur
URL: https://agentic-patterns.com/patterns/initializer-maintainer-dual-agent

### intelligent-bash-tool-execution
Intelligent Bash Tool Execution: Secure, reliable command execution from agents is complex and error prone: PTY requirements : TTY required CLIs (coding agents, terminal UIs) fail with direct e
URL: https://agentic-patterns.com/patterns/intelligent-bash-tool-execution

### inversion-of-control
Inversion of Control: Traditional "prompt-as-puppeteer" workflows force humans to spell out every step, limiting scale and creativity.
URL: https://agentic-patterns.com/patterns/inversion-of-control

### isolated-vm-per-rl-rollout
Isolated VM per RL Rollout: Spin up an isolated virtual machine for each RL rollout to prevent cross-contamination between parallel agent executions, ensuring safe training with destructive tool access.
URL: https://agentic-patterns.com/patterns/isolated-vm-per-rl-rollout

### iterative-multi-agent-brainstorming
Iterative Multi-Agent Brainstorming: For complex problems or creative ideation, a single AI agent instance might get stuck in a local optimum or fail to explore a diverse range of solutions.
URL: https://agentic-patterns.com/patterns/iterative-multi-agent-brainstorming

### iterative-prompt-skill-refinement
Iterative Prompt & Skill Refinement: Agent usage reveals gaps in prompts, skills, and tools—but how do you systematically improve them?
URL: https://agentic-patterns.com/patterns/iterative-prompt-skill-refinement

### lane-based-execution-queueing
Lane-Based Execution Queueing: Traditional agent systems serialize all operations through a single execution queue, creating bottlenecks that limit throughput.
URL: https://agentic-patterns.com/patterns/lane-based-execution-queueing

### language-agent-tree-search-lats
Language Agent Tree Search (LATS): Current language agents often struggle with complex reasoning tasks that require exploration of multiple solution paths.
URL: https://agentic-patterns.com/patterns/language-agent-tree-search-lats

### latent-demand-product-discovery
Latent Demand Product Discovery: TODO: Add a concise summary for "Latent Demand Product Discovery" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/latent-demand-product-discovery

### layered-configuration-context
Layered Configuration Context: AI agents require relevant context to perform effectively.
URL: https://agentic-patterns.com/patterns/layered-configuration-context

### lethal-trifecta-threat-model
Lethal Trifecta Threat Model: Combining three agent capabilities— 1.
URL: https://agentic-patterns.com/patterns/lethal-trifecta-threat-model

### llm-map-reduce-pattern
LLM Map-Reduce Pattern: When many untrusted documents are processed in a single reasoning context, one malicious item can influence global conclusions.
URL: https://agentic-patterns.com/patterns/llm-map-reduce-pattern

### llm-observability
LLM Observability: Integrate LLM observability platforms for span-level tracing of agent workflows, providing visual UI debugging, workflow linking, and aggregate metrics to enable fast navigation of complex multi-step executions.
URL: https://agentic-patterns.com/patterns/llm-observability

### llm-friendly-api-design
LLM-Friendly API Design: For AI agents to reliably and effectively use tools, especially APIs or internal libraries, the design of these interfaces matters.
URL: https://agentic-patterns.com/patterns/llm-friendly-api-design

### memory-reinforcement-learning-memrl
Memory Reinforcement Learning (MemRL): TODO: Add a concise summary for "Memory Reinforcement Learning (MemRL)" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/memory-reinforcement-learning-memrl

### memory-synthesis-from-execution-logs
Memory Synthesis from Execution Logs: TODO: Add a concise summary for "Memory Synthesis from Execution Logs" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/memory-synthesis-from-execution-logs

### merged-code-language-skill-model
Merged Code + Language Skill Model: Building a unified model that excels both at natural language tasks (e.g., summarization, documentation generation) and code generation/reasoning typically requires a massive centralized training run.
URL: https://agentic-patterns.com/patterns/merged-code-language-skill-model

### agentfund-crowdfunding
Milestone Escrow for Agent Resource Funding: Autonomous agent teams can need ongoing resources (compute, API spend, tools) over many steps.
URL: https://agentic-patterns.com/patterns/agentfund-crowdfunding

### multi-model-orchestration-for-complex-edits
Multi-Model Orchestration for Complex Edits: A single large language model, even if powerful, may not be optimally suited for all sub tasks involved in a complex operation like multi file code editing.
URL: https://agentic-patterns.com/patterns/multi-model-orchestration-for-complex-edits

### multi-platform-communication-aggregation
Multi-Platform Communication Aggregation: Create unified search interface that queries all communication platforms in parallel and aggregates results into consistent format, enabling single-query cross-platform search with minimal latency through parallel execution.
URL: https://agentic-patterns.com/patterns/multi-platform-communication-aggregation

### multi-platform-webhook-triggers
Multi-Platform Webhook Triggers: Implement multi-platform webhook triggers (Notion, Slack, Jira, reacji, scheduled events) to allow external SaaS tools to automatically initiate agent workflows, enabling low-friction, reactive automation from existing platforms.
URL: https://agentic-patterns.com/patterns/multi-platform-webhook-triggers

### no-token-limit-magic
No-Token-Limit Magic: Teams often optimize token spend too early, forcing prompts and context windows into tight constraints before they understand what high quality behavior looks like.
URL: https://agentic-patterns.com/patterns/no-token-limit-magic

### non-custodial-spending-controls
Non-Custodial Spending Controls: AI agents that can initiate wallet actions may issue unsafe transactions under prompt drift, buggy loops, or compromised prompts.
URL: https://agentic-patterns.com/patterns/non-custodial-spending-controls

### opponent-processor-multi-agent-debate
Opponent Processor / Multi-Agent Debate Pattern: TODO: Add a concise summary for "Opponent Processor / Multi-Agent Debate Pattern" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/opponent-processor-multi-agent-debate

### oracle-and-worker-multi-model
Oracle and Worker Multi-Model Approach: Relying on a single AI model creates a trade off between capability and cost.
URL: https://agentic-patterns.com/patterns/oracle-and-worker-multi-model

### parallel-tool-call-learning
Parallel Tool Call Learning: TODO: Add a concise summary for "Parallel Tool Call Learning" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/parallel-tool-call-learning

### patch-steering-via-prompted-tool-selection
Patch Steering via Prompted Tool Selection: Coding agents with access to multiple patching or refactoring tools (e.g., text based apply patch , AST based refactoring, semantic migration) may choose suboptimal tools if not explicitly guided.
URL: https://agentic-patterns.com/patterns/patch-steering-via-prompted-tool-selection

### pii-tokenization
PII Tokenization: Implement interception layer in MCP client that automatically tokenizes PII before reaching model and untokenizes for tool calls, enabling agents to orchestrate sensitive workflows without exposing raw data to LLM.
URL: https://agentic-patterns.com/patterns/pii-tokenization

### plan-then-execute-pattern
Plan-Then-Execute Pattern: When planning and execution are interleaved in one loop, untrusted tool outputs can influence which action is selected next.
URL: https://agentic-patterns.com/patterns/plan-then-execute-pattern

### planner-worker-separation-for-long-running-agents
Planner-Worker Separation for Long-Running Agents: Running multiple AI agents in parallel for complex, multi week projects creates significant coordination challenges: Flat structures lead to conflicts, duplicat
URL: https://agentic-patterns.com/patterns/planner-worker-separation-for-long-running-agents

### proactive-agent-state-externalization
Proactive Agent State Externalization: Modern models like Claude Sonnet 4.5 proactively externalize state through self-generated notes—enhanced through guided frameworks, hybrid memory architecture, and progressive state building to capture decision rationale and knowledge gaps.
URL: https://agentic-patterns.com/patterns/proactive-agent-state-externalization

### proactive-trigger-vocabulary
Proactive Trigger Vocabulary: TODO: Add a concise summary for "Proactive Trigger Vocabulary" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/proactive-trigger-vocabulary

### progressive-autonomy-with-model-evolution
Progressive Autonomy with Model Evolution: TODO: Add a concise summary for "Progressive Autonomy with Model Evolution" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/progressive-autonomy-with-model-evolution

### progressive-complexity-escalation
Progressive Complexity Escalation: Start agents with low-complexity, high-reliability tasks and progressively unlock more complex capabilities as models improve and trust is established, matching task complexity to current model capabilities for risk mitigation.
URL: https://agentic-patterns.com/patterns/progressive-complexity-escalation

### progressive-disclosure-large-files
Progressive Disclosure for Large Files: TODO: Add a concise summary for "Progressive Disclosure for Large Files" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/progressive-disclosure-large-files

### progressive-tool-discovery
Progressive Tool Discovery: TODO: Add a concise summary for "Progressive Tool Discovery" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/progressive-tool-discovery

### prompt-caching-via-exact-prefix-preservation
Prompt Caching via Exact Prefix Preservation: Long running agent conversations with many tool calls can suffer from quadratic performance degradation : Growing JSON payloads : Each iteration sends the entir
URL: https://agentic-patterns.com/patterns/prompt-caching-via-exact-prefix-preservation

### recursive-best-of-n-delegation
Recursive Best-of-N Delegation: Recursive delegation (parent agent → sub agents → sub sub agents) decomposes big tasks, but has a failure mode: A single weak sub agent result can poison the parent's next steps (wrong assumption, missed file, bad patch) Errors compound up the tree: "one bad leaf" can derail the whole rollout Pure recursion underuses parallelism when a node is uncertain: you want multiple shots right where the ambiguity is Meanwhile, "best of N" parallel attempts help reliability, but without structure they waste compute by repeatedly solving the same problem instead of decomposing it.
URL: https://agentic-patterns.com/patterns/recursive-best-of-n-delegation

### reflection
Reflection Loop: Generative models may produce subpar output if they never review or critique their own work.
URL: https://agentic-patterns.com/patterns/reflection

### wfgy-reliability-problem-map
Reliability Problem Map Checklist for RAG and Agents: RAG pipelines and agent systems often fail in ways that are hard to diagnose: missing context, unstable retrieval, brittle tool contracts, and flaky behavior after data updates.
URL: https://agentic-patterns.com/patterns/wfgy-reliability-problem-map

### rich-feedback-loops
Rich Feedback Loops > Perfect Prompts: Polishing a single prompt can't cover every edge case; agents need ground truth to self correct.
URL: https://agentic-patterns.com/patterns/rich-feedback-loops

### rlaif-reinforcement-learning-from-ai-feedback
RLAIF (Reinforcement Learning from AI Feedback): Traditional Reinforcement Learning from Human Feedback (RLHF) requires extensive human annotation for preference data, which is expensive (often $1+ per annotation), time consuming, and difficult to scale.
URL: https://agentic-patterns.com/patterns/rlaif-reinforcement-learning-from-ai-feedback

### sandboxed-tool-authorization
Sandboxed Tool Authorization: Tool authorization needs flexibility but also security.
URL: https://agentic-patterns.com/patterns/sandboxed-tool-authorization

### schema-validation-retry-cross-step-learning
Schema Validation Retry with Cross-Step Learning: LLMs don't always produce valid structured output matching the expected schema.
URL: https://agentic-patterns.com/patterns/schema-validation-retry-cross-step-learning

### seamless-background-to-foreground-handoff
Seamless Background-to-Foreground Handoff: While background agents can handle long running, complex tasks autonomously, they might not achieve 100% correctness or perfectly match the user's nuanced intent.
URL: https://agentic-patterns.com/patterns/seamless-background-to-foreground-handoff

### self-critique-evaluator-loop
Self-Critique Evaluator Loop: Human labeled preference datasets are expensive to produce, slow to refresh, and quickly stale as base models and domains change.
URL: https://agentic-patterns.com/patterns/self-critique-evaluator-loop

### self-discover-reasoning-structures
Self-Discover: LLM Self-Composed Reasoning Structures: Different reasoning tasks require different thinking strategies.
URL: https://agentic-patterns.com/patterns/self-discover-reasoning-structures

### self-identity-accumulation
Self-Identity Accumulation: AI agents lack continuous memory across sessions.
URL: https://agentic-patterns.com/patterns/self-identity-accumulation

### self-rewriting-meta-prompt-loop
Self-Rewriting Meta-Prompt Loop: Static system prompts become stale or overly brittle as an agent encounters new tasks and edge cases.
URL: https://agentic-patterns.com/patterns/self-rewriting-meta-prompt-loop

### semantic-context-filtering
Semantic Context Filtering Pattern: Raw data sources are too verbose and noisy for effective LLM consumption.
URL: https://agentic-patterns.com/patterns/semantic-context-filtering

### shell-command-contextualization
Shell Command Contextualization: When an AI agent interacts with a local development environment, it often needs to execute shell commands (e.g., run linters, check git status, list files) and then use the output of these commands as context for its subsequent reasoning or actions.
URL: https://agentic-patterns.com/patterns/shell-command-contextualization

### shipping-as-research
Shipping as Research: In the rapidly evolving AI landscape, waiting for certainty before building means you're always behind.
URL: https://agentic-patterns.com/patterns/shipping-as-research

### skill-library-evolution
Skill Library Evolution: Agents persist working code implementations as reusable skills that evolve into well-documented capabilities over time, building organizational knowledge and reducing redundant problem-solving across sessions.
URL: https://agentic-patterns.com/patterns/skill-library-evolution

### soulbound-identity-verification
Soulbound Identity Verification: As autonomous agents interact across networks, verifying identity and detecting prompt/operator drift becomes difficult.
URL: https://agentic-patterns.com/patterns/soulbound-identity-verification

### spec-as-test-feedback-loop
Spec-As-Test Feedback Loop: Even in spec first projects, implementations can drift as code evolves and the spec changes (or vice versa).
URL: https://agentic-patterns.com/patterns/spec-as-test-feedback-loop

### specification-driven-agent-development
Specification-Driven Agent Development: Hand crafted prompts or loose user stories leave room for ambiguity; agents can wander, over interpret, or produce code that conflicts with stakeholder intent.
URL: https://agentic-patterns.com/patterns/specification-driven-agent-development

### spectrum-of-control-blended-initiative
Spectrum of Control / Blended Initiative: AI agents for tasks like coding can offer various levels of assistance, from simple completions to complex, multi step operations.
URL: https://agentic-patterns.com/patterns/spectrum-of-control-blended-initiative

### static-service-manifest-for-agents
Static Service Manifest for Agents: Before an agent can use an API, it needs to know what the API offers.
URL: https://agentic-patterns.com/patterns/static-service-manifest-for-agents

### stop-hook-auto-continue-pattern
Stop Hook Auto-Continue Pattern: Agents complete their turn and return control to the user even when the task isn't truly done.
URL: https://agentic-patterns.com/patterns/stop-hook-auto-continue-pattern

### structured-output-specification
Structured Output Specification: Constrain agent outputs using deterministic schemas that enforce structured, machine-readable results, enabling reliable validation, parsing, and integration with downstream systems.
URL: https://agentic-patterns.com/patterns/structured-output-specification

### sub-agent-spawning
Sub-Agent Spawning: Large multi file tasks blow out the main agent's context window and reasoning budget.
URL: https://agentic-patterns.com/patterns/sub-agent-spawning

### subagent-compilation-checker
Subagent Compilation Checker: Large coding tasks often involve multiple independent components (e.g., microservices, libraries).
URL: https://agentic-patterns.com/patterns/subagent-compilation-checker

### subject-hygiene
Subject Hygiene for Task Delegation: When delegating work to subagents via the Task tool, empty or generic task subjects make conversations: Untraceable : Cannot identify what a subagent was working on Unreferencable : Cannot discuss specific subagent work later Confusing : Multiple subagents with empty subjects are indistinguishable From 48 Task invocations across 88 sessions, empty task subjects were identified as a major pain point.
URL: https://agentic-patterns.com/patterns/subject-hygiene

### swarm-migration-pattern
Swarm Migration Pattern: Main agent orchestrates 10+ parallel subagents working simultaneously on independent migration chunks, achieving 10x+ speedup for large-scale framework upgrades, lint rule rollouts, and API migrations.
URL: https://agentic-patterns.com/patterns/swarm-migration-pattern

### team-shared-agent-configuration
Team-Shared Agent Configuration as Code: Check agent configuration into version control as code, enabling consistent behavior across teams, faster onboarding, and collaborative improvement through PRs and code review.
URL: https://agentic-patterns.com/patterns/team-shared-agent-configuration

### three-stage-perception-architecture
Three-Stage Perception Architecture: Complex AI agents often struggle with unstructured inputs and need a systematic way to process information before taking action.
URL: https://agentic-patterns.com/patterns/three-stage-perception-architecture

### tool-capability-compartmentalization
Tool Capability Compartmentalization: Model Context Protocol (MCP) and agent frameworks often combine three capability classes in a single tool: private data readers (email, filesystem), web fetchers (HTTP clients), and writers (API mutators).
URL: https://agentic-patterns.com/patterns/tool-capability-compartmentalization

### tool-search-lazy-loading
Tool Search Lazy Loading: Dynamically load tools via search instead of preloading all available tools to reduce context usage
URL: https://agentic-patterns.com/patterns/tool-search-lazy-loading

### tool-selection-guide
Tool Selection Guide: AI agents often struggle to select the optimal tool for a given task, leading to inefficient workflows.
URL: https://agentic-patterns.com/patterns/tool-selection-guide

### tool-use-incentivization-via-reward-shaping
Tool Use Incentivization via Reward Shaping: Coding agents often underutilize specialized tools (e.g., compilers, linters, test runners) when left to optimize only for final task success.
URL: https://agentic-patterns.com/patterns/tool-use-incentivization-via-reward-shaping

### tool-use-steering-via-prompting
Tool Use Steering via Prompting: AI agents equipped with multiple tools (e.g., shell access, file system operations, web search, custom CLIs) need clear guidance on when, why, and how to use these tools effectively.
URL: https://agentic-patterns.com/patterns/tool-use-steering-via-prompting

### transitive-vouch-chain-trust
Transitive Vouch-Chain Trust: When autonomous agents interact without a central authority, trust decisions are binary: either you trust an agent completely or you do not trust it at all.
URL: https://agentic-patterns.com/patterns/transitive-vouch-chain-trust

### tree-of-thought-reasoning
Tree-of-Thought Reasoning: Linear chain-of-thought reasoning can get stuck on complex problems, missing alternative approaches or failing to backtrack.
URL: https://agentic-patterns.com/patterns/tree-of-thought-reasoning

### variance-based-rl-sample-selection
Variance-Based RL Sample Selection: Not all training samples are equally valuable for reinforcement learning.
URL: https://agentic-patterns.com/patterns/variance-based-rl-sample-selection

### verbose-reasoning-transparency
Verbose Reasoning Transparency: AI agents, especially those using complex models or multiple tools, can sometimes behave like "black boxes." Users may not understand why an agent made a particular decision, chose a specific tool, or generated a certain output.
URL: https://agentic-patterns.com/patterns/verbose-reasoning-transparency

### versioned-constitution-governance
Versioned Constitution Governance: When agents can modify policy/constitution text, safety regressions can be introduced gradually and go unnoticed.
URL: https://agentic-patterns.com/patterns/versioned-constitution-governance

### virtual-machine-operator-agent
Virtual Machine Operator Agent: AI agents need to perform complex tasks beyond simple code generation or text manipulation.
URL: https://agentic-patterns.com/patterns/virtual-machine-operator-agent

### visual-ai-multimodal-integration
Visual AI Multimodal Integration: Many real world tasks require understanding and processing visual information alongside text.
URL: https://agentic-patterns.com/patterns/visual-ai-multimodal-integration

### workflow-evals-with-mocked-tools
Workflow Evals with Mocked Tools: TODO: Add a concise summary for "Workflow Evals with Mocked Tools" describing the pattern's purpose and key benefits.
URL: https://agentic-patterns.com/patterns/workflow-evals-with-mocked-tools

### working-memory-via-todos
Working Memory via TodoWrite: During complex multi step tasks, AI agents lose track of: What tasks are pending, in progress, or completed Which tasks are blocked by dependencies Verification
URL: https://agentic-patterns.com/patterns/working-memory-via-todos

### workspace-native-multi-agent-orchestration
Workspace-Native Multi-Agent Orchestration: Many teams struggle to run agentic workflows because their agent tooling is separate from their day to day collaboration environment.
URL: https://agentic-patterns.com/patterns/workspace-native-multi-agent-orchestration

### zero-trust-agent-mesh
Zero-Trust Agent Mesh: In multi agent systems, trust boundaries are often implicit: agents communicate by convention without verifiable identity, and delegation chains are hard to audit.
URL: https://agentic-patterns.com/patterns/zero-trust-agent-mesh