Browse the operating models behind agent systems.

Abstracted Code Representation for Review

Action Caching & Replay Pattern

Action-Selector Pattern

Adaptive Sandbox Fan-Out Controller

Agent-Assisted Scaffolding

Agent-Driven Research

Agent-First Tooling and Logging

Agent-Friendly Workflow Design

Agent Modes by Model Personality

Agent-Powered Codebase Q&A / Onboarding

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.

Agent SDK for Programmatic Control

Milestone Escrow for Agent Resource Funding

Agentic Search Over Vector Embeddings

TODO: Add a concise summary for "Agentic Search Over Vector Embeddings" describing the pattern's purpose and key benefits.

AI-Accelerated Learning and Skill Development

AI-Assisted Code Review / Verification

AI Web Search Agent Loop

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.

Asynchronous Coding Agent Pipeline

Autonomous Workflow Agent Architecture

TODO: Add a concise summary for "Autonomous Workflow Agent Architecture" describing the pattern's purpose and key benefits.

Background Agent with CI Feedback

## Problem Long-running tasks tie up the editor and require developers to babysit the agent.

Budget-Aware Model Routing with Hard Cost Caps

Burn the Boats

Canary Rollout and Automatic Rollback for Agent Policy Changes

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.

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.

CLI-Native Agent Orchestration

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.

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).

Code-Then-Execute Pattern

Codebase Optimization for Agents

Coding Agent CI Feedback Loop

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.

Context-Minimization Pattern

Context Window Anxiety Management

Context Window Auto-Compaction

Continuous Autonomous Task Loop Pattern

CriticGPT-Style Code Review

Cross-Cycle Consensus Relay

Curated Code Context Window

Curated File Context Window

Custom Sandboxed Background Agent

Democratization of Tooling via Agents

Deterministic Security Scanning Build Loop

Dev Tooling Assumptions Reset

Discrete Phase Separation

TODO: Add a concise summary for "Discrete Phase Separation" describing the pattern's purpose and key benefits.

Disposable Scaffolding Over Durable Features

Distributed Execution with Cloud Workers

TODO: Add a concise summary for "Distributed Execution with Cloud Workers" describing the pattern's purpose and key benefits.

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.

Dual LLM Pattern

Dual-Use Tool Design

TODO: Add a concise summary for "Dual-Use Tool Design" describing the pattern's purpose and key benefits.

Dynamic Code Injection (On-Demand File Fetch)

Dynamic Context Injection

Economic Value Signaling in Multi-Agent Networks

Egress Lockdown (No-Exfiltration Channel)

Episodic Memory Retrieval & Injection

Explicit Posterior-Sampling Planner

Extended Coherence Work Sessions

External Credential Sync

Factory over Assistant

Failover-Aware Model Fallback

Feature List as Immutable Contract

TODO: Add a concise summary for "Feature List as Immutable Contract" describing the pattern's purpose and key benefits.

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.

Frontier-Focused Development

Graph of Thoughts (GoT)

Hook-Based Safety Guard Rails for Autonomous Code Agents

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.

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.

Incident-to-Eval Synthesis

Inference-Healed Code Review Reward

Inference-Time Scaling

Initializer-Maintainer Dual Agent Architecture

Intelligent Bash Tool Execution

Inversion of Control

Traditional "prompt-as-puppeteer" workflows force humans to spell out every step, limiting scale and creativity.

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.

Iterative Multi-Agent Brainstorming

Iterative Prompt & Skill Refinement

Lane-Based Execution Queueing

Language Agent Tree Search (LATS)

Latent Demand Product Discovery

TODO: Add a concise summary for "Latent Demand Product Discovery" describing the pattern's purpose and key benefits.

Layered Configuration Context

Lethal Trifecta Threat Model

LLM-Friendly API Design

LLM Map-Reduce Pattern

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.

Memory Reinforcement Learning (MemRL)

TODO: Add a concise summary for "Memory Reinforcement Learning (MemRL)" describing the pattern's purpose and key benefits.

Memory Synthesis from Execution Logs

TODO: Add a concise summary for "Memory Synthesis from Execution Logs" describing the pattern's purpose and key benefits.

Merged Code + Language Skill Model

Multi-Model Orchestration for Complex Edits

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.

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.

Artifact-Driven Analysis Pipeline Orchestration

No-Token-Limit Magic

Non-Custodial Spending Controls

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.

Oracle and Worker Multi-Model Approach

Parallel Tool Call Learning

TODO: Add a concise summary for "Parallel Tool Call Learning" describing the pattern's purpose and key benefits.

Conditional Parallel Tool Execution

Patch Steering via Prompted Tool Selection

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.

Plan-Then-Execute Pattern

Planner-Worker Separation for Long-Running Agents

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.

Proactive Trigger Vocabulary

TODO: Add a concise summary for "Proactive Trigger Vocabulary" describing the pattern's purpose and key benefits.

Progressive Autonomy with Model Evolution

TODO: Add a concise summary for "Progressive Autonomy with Model Evolution" describing the pattern's purpose and key benefits.

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.

Progressive Disclosure for Large Files

TODO: Add a concise summary for "Progressive Disclosure for Large Files" describing the pattern's purpose and key benefits.

Progressive Tool Discovery

TODO: Add a concise summary for "Progressive Tool Discovery" describing the pattern's purpose and key benefits.

Prompt Caching via Exact Prefix Preservation

Recursive Best-of-N Delegation

Reflection Loop

Generative models may produce subpar output if they never review or critique their own work.

Rich Feedback Loops > Perfect Prompts

RLAIF (Reinforcement Learning from AI Feedback)

Sandboxed Tool Authorization

Schema Validation Retry with Cross-Step Learning

Seamless Background-to-Foreground Handoff

Self-Critique Evaluator Loop

Self-Discover: LLM Self-Composed Reasoning Structures

Self-Identity Accumulation

Self-Rewriting Meta-Prompt Loop

Semantic Context Filtering Pattern

Shell Command Contextualization

Shipping as Research

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.

Soulbound Identity Verification

Spec-As-Test Feedback Loop

Specification-Driven Agent Development

Spectrum of Control / Blended Initiative

Static Service Manifest for Agents

Stop Hook Auto-Continue Pattern

Structured Output Specification

Constrain agent outputs using deterministic schemas that enforce structured, machine-readable results, enabling reliable validation, parsing, and integration with downstream systems.

Sub-Agent Spawning

Subagent Compilation Checker

Subject Hygiene for Task Delegation

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.

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.

Three-Stage Perception Architecture

Tool Capability Compartmentalization

Tool Search Lazy Loading

Dynamically load tools via search instead of preloading all available tools to reduce context usage

Tool Selection Guide

Tool Use Incentivization via Reward Shaping

Tool Use Steering via Prompting

Transitive Vouch-Chain Trust

Tree-of-Thought Reasoning

Linear chain-of-thought reasoning can get stuck on complex problems, missing alternative approaches or failing to backtrack.

Variance-Based RL Sample Selection

Verbose Reasoning Transparency

Versioned Constitution Governance

Virtual Machine Operator Agent

Visual AI Multimodal Integration

Reliability Problem Map Checklist for RAG and Agents

Workflow Evals with Mocked Tools

TODO: Add a concise summary for "Workflow Evals with Mocked Tools" describing the pattern's purpose and key benefits.

Working Memory via TodoWrite

Workspace-Native Multi-Agent Orchestration

Zero-Trust Agent Mesh