Agent Confession — AI Forensics
An adversarial or forensic technique that tricks an AI agent into revealing its hidden system-level directives or internal memory state.
Agent Identity Sprawl
Your agent fleet mints identities at machine speed while credential scoping, rotation, and revocation crawl at human speed — leaving an ungovernable attack surface.
Agent Output Alert Fatigue
Your agent raises so many low-quality findings that reviewers stop reading — and the human oversight you built in quietly disappears.
Black-Box Opaqueness
Shipping an agent with no traces, decision logs, or provenance — then debugging from user complaints.
Compound Error Degradation
Deploying a long-horizon agent while ignoring that per-step accuracy compounds — a 20-step pipeline of 95%-accurate steps succeeds less than 36% of the time.
Context Anxiety
A context-aware model panics about its token budget and wraps up early — while most of the window is still free.
Errors Swept Under the Rug
Scrubbing stack traces and failed tool outputs from the agent's context to keep the transcript clean — and breaking its ability to self-correct.
Hallucinated Citations
Trusting the model to write its own citations — and shipping fabricated sources to users.
Hallucinated Tools
Trusting the model to only call tools you gave it — then watching it invoke functions that don't exist.
Hero Agent
Stuffing every capability into one agent with one giant prompt — and watching quality collapse as it grows.
Hidden Mode Switching
Silently routing users to a cheaper model without telling them — eroding trust and making debugging impossible.
Infinite Debate
Launching a multi-agent debate with no termination rule — and watching agents argue forever.
JSON-Only Action Schema
Forcing agents to express loops, conditionals, and multi-step logic through flat JSON tool calls when they should just be writing code.
Memo-As-Source Confusion
The agent trusts its own stale workspace notes as ground truth instead of re-reading the actual artifact.
Naive-RAG-First
Reaching for a vector store before checking whether the answer lives in a database, API, or system prompt.
Perma-Beta
Keeping the agent in "beta" forever — so quality regressions stay someone else's problem.
Prompt Bloat
Every bug fix adds a sentence to the system prompt — nothing ever gets removed — until the prompt is unmaintainable and full of contradictions.
Role-Typed Subagents
Pre-allocating fixed roles (manager, coder, researcher) across a typed agent fleet before knowing what workloads will actually look like.
Same-Model Self-Critique
Having the same model produce an answer and critique it — and calling that an independent check.
Schema-Free Output
Parsing free-form model text with regex in downstream code — and getting silent data corruption when the model phrases things differently.
Supervisor Cognitive Overload
Routing every parallel sub-agent's questions and approvals to one human reviewer — who quickly becomes the throughput bottleneck.
Tool Explosion
Exposing every available tool to the agent on every request — and watching function-calling accuracy collapse past ~20 tools.
Tool Loadout Hot-Swap
Mutating the agent's available tools mid-task — invalidating the KV-cache and confusing a model that conditioned on a different tool set.
Tool Output Trusted Verbatim
Feeding raw tool output directly into the model's context — no validation, no schema check, no size cap, no sanitization.
Unbounded Loop
Running the agent loop with no step budget — and trusting model self-termination to decide when to stop.
Unbounded Subagent Spawn
A supervisor spawns sub-agents that can spawn their own sub-agents — with no global cap on the tree size or recursion depth.
Vendor Lock-In
Wiring your agent directly to one provider's SDK — so switching providers costs you a rewrite.
Affect-Coupled Plan Lifecycle
Wire plan lifecycle events (step-done, plan-complete, stale-plan) to bounded affect bumps so plans accumulate felt stakes without hard deadlines.
Ambient Presence Sensing
Read pacing signals from the user's frontend (typing rate, idle time, tab focus) and reduce them to a single presence-quality label the agent acts on — never surfacing raw signals back.
Awareness
Maintain a queryable snapshot of the agent's own tools, capabilities, permissions, and current context — refreshed whenever things change at runtime.
BDI Agent
Structure the agent's cognition around three typed stores — Beliefs (world facts), Desires (goals), and Intentions (committed plans) — reconciled explicitly each tick.
Cluster-Capped Insight Store
Cap insights per stem-token cluster and archive the oldest near-duplicates so the active store holds the current research edge — not a graveyard of variants.
Cognitive-Move Selector
Give the agent a named menu of cognitive moves and let a cheap-tier model select one per idle tick — so idle cognition has a determinate shape instead of free-form drift.
Cooperative Preference Inference
Treat alignment as an ongoing two-player game — the agent maintains a reward posterior and updates it continuously from human demonstrations, corrections, and questions rather than relying on a fixed objective.
Dream Consolidation Cycle
Run a slower, deeper reflection pass every few hours to distill themes, release affective residue, and clear working memory — filling the gap between per-tick reflection and weekly insight extraction.
Emotional State Persistence
Track the agent's affective load as bounded, decaying scalars across ticks — so reasoning can react to frustration, fatigue, and joy instead of treating every turn as emotionally blank.
Fragment Juxtaposition
After K consecutive low-salience idle ticks, seed the next tick with randomly sampled old fragments side by side — giving the substrate a chance to find associations without forcing production.
Hypothesis Tracking
Persist the agent's provisional answers as a typed ledger with confidence, status, and a next-test condition — so guesses survive sessions and stay distinguishable from open questions.
Interrupt-Resumable Thought
Preserve multi-step reasoning chains across interrupts using a push/pop thought-frame stack — so new messages are handled cleanly without clobbering in-flight work.
Intra-Agent Memo Scheduling
Let the agent schedule a timestamped note for its own future self — so present decisions hand off context to a later run without needing external scheduler infrastructure.
Meditation Mode
Switch the agent into a bounded mode where external I/O pauses, the tool surface collapses to inner-only operations, and output routes to a private journal — for pure interiority without interruption.
Mode-Adaptive Cadence
Vary the agent's loop interval based on current salience — fast when signal is high, slow when nothing is happening — instead of burning ticks at a fixed rate.
Multi-Axis Promotion Scoring
Gate promotion from short-term thought to long-term insight through a weighted six-axis score — so the filter is defensible and configurable, not an ad-hoc judgment call.
Open-Question Tension Store
Persist unresolved questions as a typed ledger with curiosity and intrusiveness scores — so they drive the agent's next inquiry instead of dissolving when the prompt ends.
Parallel-Voice Proposer
Generate 2–3 candidate thoughts in parallel under named voices in one completion and have the same model select the canonical one — surfacing internal disagreement without paying for sequential persona calls.
Partial-Output Salvage
Stream every model token to an atomic partial file so mid-stream crashes leave a consistent salvage — then surface the recovery status to the model on the next prompt.
Pre-Generative Loop Gate
Before each model call fires, detect known divergence signatures (narration loops, repetitive retries, frustration spirals) and inject a steering hint into the prompt — rather than vetoing the call.
Preoccupation Tracking
Maintain a capped, decay-weighted list of mid-term concerns with affect tags — surfaced in every prompt — for the things the agent is genuinely carrying across days.
Self-Archaeology
Periodically distill the agent's past thought history into time-layered trajectory notes by topic — so it can articulate how its understanding evolved without recomputing the narrative each time.
Typed Tool-Loop Failure Detector
Lift tool-loop detection from prompt-level rules (which the model can ignore) to a mechanical dispatch-boundary veto with five typed failure modes and per-tool caps.
World-Model Separation
Keep the agent's model of its environment (humans, repos, services) in a separate store from its self-model (charter, personality, boundaries) — so surprise-driven updates can't accidentally rewrite values.
Agent Middleware Chain
Wrap every model call, tool call, and memory access in a composable pre/execute/post interceptor pipeline — attach cross-cutting concerns without touching agent code.
Agent Resumption
Persist agent execution state so long-running tasks survive restarts, deploys, and user disconnects without losing progress.
Agent-as-a-Judge
Use a second agent to evaluate the full execution trajectory — every step, tool call, and intermediate state — not just the final answer.
Attention-Manipulation Explainability
Identify which input tokens actually drove a model output by perturbing attention weights and measuring probability shifts — no self-reported confabulation.
Bayesian Bandit Experimentation
Replace fixed-split A/B tests with a bandit that dynamically shifts traffic toward better-performing agent variants in real time — minimizing exposure to the losers.
Cost Observability
Tag every model and tool call with feature/route/user context and stream spend to dashboards in near-real-time — catch cost explosions before the invoice does.
Crawl-Walk-Run Automation Gating
Roll out agent autonomy in three explicit tiers — suggest only → act on internal staff → act on external customers — with measurable gates between each.
Decision Log
Persist the agent's reasoning trace alongside its actions so post-hoc review can explain the *why*, not just the *what*.
Deontic Token Delegation
Encode obligations, permissions, and prohibitions as transferable tokens that travel with delegated work — so duty and accountability move with the task, not just credentials.
Durable Workflow Snapshot
Serialize full workflow state to pluggable durable storage at checkpoints so long-running, multi-day tasks survive deploys, process restarts, and host crashes.
Eval Harness
Run a held-out golden dataset against agent versions on every meaningful change — quantify quality, catch regressions, and gate promotions with hard numbers.
Eval as Contract
Treat your eval suite as a binding contract — releases ship only if evals pass, and changing evals is an architectural review, not a config tweak.
Evaluation-Driven Development
Write the eval before writing the first prompt — freeze what "good" looks like, then let those metrics drive every model, prompt, and tool decision.
Incident Response Runbook
Pre-author step-by-step response procedures for your highest-risk agent failure modes — so when a PII leak or tool exploit fires, the team executes, not panics.
Journaled LLM Call
Record every non-deterministic step (LLM calls, tool results, timestamps) to an append-only journal on first execution — replay crashes by replaying the journal, not re-invoking the model.
LLM-as-Judge
Score open-ended agent outputs against a written rubric using an LLM judge — automate quality evaluation where no exact-match metric applies.
Lineage Tracking
Tag every agent output with the exact prompt version, model version, tool versions, and retrieved documents that produced it — so any output is fully reproducible and attributable.
Managed Agent Runtime
Consume the agent loop itself as a managed cloud primitive — supply model, system prompt, and tools; the platform handles orchestration, isolation, identity, and observability.
Model Card
Maintain a versioned structured document covering intended use, known limitations, eval results, and risks — the single source of truth for every stakeholder asking "what does this agent actually do?"
Multi-Principal Welfare Aggregation
When an agent serves multiple principals with conflicting preferences, declare the aggregation rule explicitly — make it a config choice, not an invisible prompt accident.
Prompt Versioning
Treat prompts as immutable, hashed, semver'd artifacts in a registry — deploy and roll back like code, tie eval results to specific versions.
Provenance Ledger
Log every agent decision and state change to an immutable append-only ledger with full metadata — so any past action can be explained, audited, or reversed on demand.
Replay / Time-Travel
Load any past agent trace, jump to a specific step, swap in a different prompt or model, and re-run forward — debug production incidents in minutes instead of hours.
Sampled Prompt Trace Eval
Log every production trace but run LLM-judge evaluation on a configurable sample — keep quality metrics tracking real traffic without doubling inference costs at scale.
Sandbox Escape Monitoring
Instrument the sandbox boundary — log every out-of-scope syscall, unauthorized network egress, and unexpected filesystem write — and alert or kill on threshold breaches.
Scaffold Ablation on Model Upgrade
On each model upgrade, treat every harness component as an encoded assumption about a past model weakness — ablate the ones the new model no longer needs, gated by evals.
Scorer Live Monitoring
Score agent outputs asynchronously after they reach the user — multiple scorer types running in parallel, zero latency impact, low-score events routed to a review queue.
Shadow Canary
Run a candidate agent version in shadow alongside the live champion — compare outputs on real traffic without exposing users to the challenger until it proves itself.
Adaptive Memory Decay
Give each memory item a retention score that decays over time based on relevance, access frequency, and recency — unused items fade out, frequently-used ones stay sharp.
Append-Only Thought Stream
Make the agent's thought log append-only so it can never rewrite its own history — every past reasoning step stays exactly as it happened.
Co-Located Memory Surfacing
When a user mentions a known entity, proactively surface the 1–2 most relevant past memories inline — so the agent brings context to the conversation without being asked.
Context Compaction
When the context window nears its limit, replace older conversation spans with a model-written digest that preserves decisions and constraints — without stopping the task.
Context Window Packing
Allocate a fixed token budget across system prompt, history, retrieved chunks, and tools on every call — so the window never silently overflows.
Cross-Session Memory
Persist user-specific facts, preferences, and prior context across all sessions, threads, and devices — so the agent actually remembers who you are.
Episodic Memory
Record past events as time-stamped, first-person experiences — separately from extracted facts (semantic) and learned skills (procedural) — so the agent can recall what happened, in order, with full context.
Episodic Summaries
Compress blocks of past episodes into compact summaries on a schedule — preserve the gist, shed the token cost, consult originals only on demand.
Filesystem as Context
Use the filesystem as externalized working memory — write plans, notes, and large tool outputs to files, keep the live window lean, and re-read only what the current step needs.
Five-Tier Memory Cascade
Stage agent memory across five tiers — sensory, working, short-term, episodic, long-term — with explicit promotion and decay between each, matching each tier to its natural timescale.
Hippocampal Rehearsal
When current context drifts close to an archived memory item, automatically lift it back into short-term focus — the agent doesn't have to remember to remember.
Knowledge Graph Memory
Persist agent memory as entities and typed relations in a structured graph — so symbolic queries (path, neighbor, type) become possible alongside semantic search.
MemGPT-Style Paging
Treat the context window as RAM and external storage as disk — the model issues tool calls to page memory in and out at its own discretion.
Now-Anchoring
Inject the current absolute time (ISO local, UTC, weekday, season) into every prompt as a `## NOW` block — so the agent is always temporally grounded without burning tool calls on clock lookups.
Reasoning Trace Carry-Forward
For reasoning models, keep the chain-of-thought trace in context within a tool-use episode — but drop it at user-turn boundaries to prevent stale reasoning from accumulating.
Salience Attention Mechanism
Score every candidate memory item with a weighted salience function and attend to only the top-k per tick — bounded attention cost regardless of how large the memory store grows.
Scratchpad
Give the agent a writable scratch space for intermediate notes, plans, and computations — keeps internal working state out of the user-visible response.
Self-Corpus Vocabulary
Mine the agent's own writing for a small cached vocabulary of its most active concepts — so relevance scoring reflects the agent's own frame, not just generic embedding distance.
Semantic Memory
Maintain a dedicated store of durable facts the agent holds to be true — separate from event records (episodic) and learned skills (procedural) — so facts are retrievable, updatable, and substrate-agnostic.
Session Isolation
Key all session state and memory by user identity end-to-end — so one user's agent can never read, write, or be influenced by another user's data.
Short-Term Thread Memory
Persist a typed state object per session thread — current screen, active plan, recent tool calls — with a TTL so it survives across turns but expires when the session is done.
Sleep-Time Compute
During idle periods, pre-compute dense summaries and likely future answers against the user's standing context — so test-time latency and cost drop dramatically on cache hits.
Vector Memory
Store memories as embeddings in a vector index and retrieve the most semantically similar items at query time — so relevance is judged by meaning, not keyword match or recency.
Actor-Model Agents
Implement each agent as an independent actor with its own mailbox — agents communicate only via async messages, never share mutable state, and crashes stay isolated.
Agent-as-Tool Embedding
Wrap a sub-agent behind a single function-shaped tool signature — the parent calls it like any other tool and never sees the sub-agent's internal turns.
Blackboard
Give multiple agents a shared, queryable workspace they all read from and write to — loose coupling, no direct messaging, inspectable shared state.
CAMEL Role-Playing
Instantiate two agents as AI-User and AI-Assistant with inception prompts — they converse autonomously until the task is solved or the turn budget runs out.
Chat Chain
Decompose a long task into ordered phases — within each phase, two role-paired agents converse until the phase artifact is signed off, then hand it to the next phase.
Coalition Formation
Agents form temporary subgroups around super-additive tasks — explicit rules determine who joins, how the coalition works, and how payoff is split when the task is done.
Communicative Dehallucination
When an agent would have to invent missing context to comply with an instruction, flip the direction — have it ask the instructor for the missing detail before answering.
Conversational Multi-Agent
Two or more agents converse turn by turn, each playing a distinct role, until a completion criterion fires — natural fit for tasks that converge through dialogue.
Cross-Domain Enterprise Agent Network
One specialised agent per business domain, each grounded in its own system of record — cross-functional workflows route typed artifacts between domains via a standardised inter-agent protocol.
Debate
Assign multiple agents different positions, have them argue N rounds, and use a judge to converge — surfaces counterarguments and raises answer quality on contested questions.
Dynamic Expert Recruitment
A recruiter agent generates the team composition at runtime based on the specific task — and adjusts that composition between iterations based on evaluation feedback.
Dynamic Topology Routing
Form and dissolve agent connections at runtime per task — chain when work is sequential, fan-out when parallel, clique when debate is needed — instead of committing to a fixed topology upfront.
Group-Chat Manager
A dedicated manager owns the shared conversation transcript and decides which participant speaks next each turn — turn order, termination, and audit in one component.
Handoff
Transfer the active conversation from one agent to a more appropriate specialist mid-flight — passing a context summary so the user never has to repeat themselves.
Hierarchical Agents
Organise agents in a tree — higher-level agents decompose tasks for lower-level ones recursively, with results bubbling back up for synthesis.
Inner Committee
Run one model under multiple distinct personas (planner, executor, critic) in a single agent loop — cheaper than multiple model instances, surprisingly effective for self-critique.
Inter-Agent Communication
Adopt a standard protocol (MCP, A2A) for agents to advertise capabilities, delegate tasks, and return results across process and vendor boundaries.
Joint Commitment Team
A team of agents adopts a shared goal plus a meta-commitment to notify each other the moment the goal is achieved, impossible, or no longer relevant — so no agent wastes work after the goal state changes.
Lead Researcher
A lead agent writes a research plan and fans out parallel sub-agents for breadth-first information gathering — then merges their findings into a synthesized answer.
Orchestrator-Workers
An orchestrator decides at runtime what subtasks to spawn and delegates each to a worker — the decomposition itself is data-dependent and can't be planned statically.
Performative Message
Type every inter-agent message by communicative intent (request, inform, propose, accept, refuse) so receivers can dispatch on act type without an extra classification call.
Personality Variant Overlay
Let one agent speak in multiple named registers (teacherly, terse, playful) via short overlay prompts — the base identity and memory are preserved across all variants.
Progressive Delegation
Start with drafts the human always reviews; expand the agent's autonomy action-by-action as measured trust accrues — promotion and demotion are automatic, evidence-based.
RL-Trained Conductor Orchestrator
A small RL-trained conductor sits in front of a pool of frontier LLM workers — learning which worker to call for which subtask from task-outcome rewards rather than hand-written routing rules.
Role Assignment
Give each agent a named role with a role-specific prompt, tool palette, and acceptance criteria — outputs are attributable, specialisation improves quality, and generic drift stops.
SOP-Encoded Multi-Agent Workflow
Encode a human Standard Operating Procedure (roles, ordered phases, typed hand-off artifacts) into a multi-agent pipeline — agents communicate through structured documents, not free-form chat.
Stigmergic Coordination
Agents coordinate by leaving and reading marks in a shared environment — no direct messaging, no central coordinator, one agent's trace stimulates another's next action.
Subagent Isolation
Run each subagent in its own isolated workspace (git worktree, container, branch) so parallel writes don't collide — the supervisor reconciles results when all are done.
Supervisor
A coordinating agent classifies incoming requests and routes each to the right specialised agent — each specialist runs its own multi-step loop with its own prompt, tools, and possibly model.
Swarm
Many peer agents interact through a shared bus or environment with no central supervisor — coordination is emergent, scale is horizontal, and termination is environment-level.
Topic-Based Routing
Route inter-agent messages through named typed topics agents subscribe to — senders never need to know who's listening, and new subscribers join without touching the sender.
Vickrey Auction Allocation
Assign tasks via sealed-bid auction — the lowest bidder wins but gets paid the second-lowest bid, making honest cost reporting the dominant strategy.
Voting-Based Cooperation
Collect votes from multiple agents on candidate options and tally them to produce a collective decision — weighted by role, auditable by design.
Adaptive Branching Tree Search
At each node of an inference-time search tree, use Thompson sampling to decide adaptively whether to deepen an existing answer or branch a fresh attempt, optionally choosing per-node which underlying LLM to invoke as a third search axis.
Agentic Behavior Tree
Borrow the behavior-tree formalism — leaves are LLM calls or tools that return success/failure; a tree of selectors and sequences orchestrates control flow.
Behavior Tree Back Chaining
Construct an agent's behavior tree starting from the desired goal condition and recursively adding child nodes whose post-conditions satisfy each parent's pre-conditions.
Clone Fan-Out Research
Spawn 100 or more identical, full-capability agent instances in parallel — each a complete general agent rather than a role-specialised worker — and aggregate their independent outputs into a single answer.
Disambiguation
Have the agent ask a clarifying question before acting on an ambiguous request.
Distributed Constraint Optimization
A group of agents jointly assigns values to shared variables to minimise (or maximise) a global cost defined by inter-agent constraints, exchanging only the messages needed.
Event-Driven Agent
Trigger the agent on external events (webhooks, message queues, file changes) instead of user requests or schedules.
Exploration vs Exploitation
Balance taking the best-known action (exploit) with trying alternatives that might be better (explore).
Goal Decomposition
Decompose a goal into sub-goals recursively until each leaf is directly actionable.
Iteration Node
Express map-over-collection inside a visual workflow as an explicit Iteration node that runs a subgraph once per element of an input array, with bounded, deterministic, observable execution.
LLMCompiler
Take ReWOO's plan-as-DAG and run independent steps in parallel through a task-fetching dispatcher.
Language Agent Tree Search
Lift the agent loop into a search tree with a learned value function and backtracking.
Local-to-Cloud Handoff
Promote an interactive local agent session mid-task to a detached cloud agent that keeps running after the developer disconnects and reports back asynchronously.
MapReduce for Agents
Split an oversize task into independent chunks, process each in parallel, then aggregate.
Outer-Inner Agent Loop
Run two nested loops — an outer planner agent that decomposes the goal into subtasks and dispatches them, and an inner executor agent that runs its own tool-use/ReAct loop on each subtask; the outer can interrupt and replan based on the inner's progress.
Partial Global Planning
Each agent maintains a partial view of others' plans and incrementally merges local plans into a shared partial global plan, interleaving coordination with execution.
Passive Goal Creator
Analyse the user's articulated prompts and accompanying context to derive a precise, actionable goal before any planning or tool use begins.
Plan-and-Execute
Plan all the steps once with a strong model, then execute each step with a cheaper model under the plan.
Planner-Executor-Observer
Add an explicit Observer role between Planner and Executor so progress is checked against the plan instead of trusted blindly.
Planner-Generator-Evaluator Harness
Decompose a long-running coding or creative job into three role-isolated agents — a Planner that emits a structured feature list, a Generator that builds one chunk per fresh context, and an Evaluator that grades the artefact against a fixed rubric without seeing the Generator's reasoning trace.
Proactive Goal Creator
Anticipate the user's goal by capturing surrounding multimodal context (gestures, screen state, environment) in addition to what the user types or says.
Query-Decomposition Agent
An agent whose explicit job is to split an incoming user query into smaller independent sub-queries that can be answered sequentially or in parallel, then merge results.
ReAct
Interleave a single thought, a single tool call, and a single observation per step so the agent reasons over fresh evidence.
ReWOO
Plan a complete dependency DAG with placeholder variables before any tool runs, then execute and substitute observations into the plan.
Replan on Failure
Trigger a fresh planning step when execution evidence contradicts the current plan.
Rumination Agent
Run a single agent through a protracted think-search-verify-revise-act loop spanning hundreds of tool calls, autonomously re-formulating hypotheses across the run.
Scheduled Agent
Run the agent on a fixed schedule independent of user requests.
Spec-Driven Loop
Run the same prompt against a fixed spec in a deterministic outer loop until the spec is satisfied.
Spec-First Agent
Drive the agent loop from a human-authored specification document rather than free-form prompts.
Todo-List-Driven Autonomous Agent
Have the autonomous agent author a writeable plan file (e.g. todo.md) early in the run, tick items as it completes them, and re-inject the remaining plan into the end of the context window; the file is the durable plan and the model's working memory.
Visual Workflow Graph
Express agentic logic as a visual graph of typed nodes connected on a canvas with Start and End nodes so non-coding stakeholders can read and edit the flow.
Adaptive Compute Allocation
Spend thinking tokens where they matter — skip them where they don't.
Chain of Thought
Make the model think out loud before it answers.
Chain of Verification
Generate an answer, then grill it with targeted verification questions.
Extended Thinking
Give the model a private scratchpad to reason deeply before it responds.
Generate-and-Test Strategy
Generate candidate solutions, run them against a verifier, keep what passes.
Graph of Thoughts
Reason as a graph — merge, backtrack, and recombine thought branches.
Large Reasoning Model (LRM) Paradigm
Use models trained to reason, not just predict — they're a different tool.
Latent-Space Reasoning
Reason in the model's embedding space, not in token space.
Least-to-Most Prompting
Decompose the hard problem into easy sub-problems, solve them in order.
Recursive Language Model
The model calls itself to solve sub-problems, recursively.
ReST-EM
Self-improve the model by training on its own high-quality outputs.
Self-Ask
The model asks itself follow-up questions until it can answer the original.
Socratic Questioning Agent
Guide the user (or another agent) to the answer through targeted questions.
STaR Bootstrapping
Bootstrap reasoning ability by fine-tuning on rationales the model got right.
Test-Time Compute Scaling
Spend more compute at inference time to get better answers — not just bigger models.
Tree of Thoughts
Explore multiple reasoning paths in parallel, prune bad ones, commit to the best.
Zero-Shot Chain-of-Thought
Unlock step-by-step reasoning with a single prompt addition — no examples needed.
Citation Attribution
Track and surface, alongside a RAG-grounded answer, which retrieved chunks supported which claims, so the binding between answer span and source survives all the way to the user.
Agentic RAG
Replace static retrieve-then-generate with autonomous agents that plan, choose sources, retrieve iteratively, reflect, and re-query — while managing the expanded Agent Confession surface that multi-source retrieval introduces.
CDC-Driven Vector Sync
Treat the source-of-truth document store as the only writer; keep the vector index in sync by emitting change-data-capture events onto a queue that...
CRAG
Add a lightweight retrieval evaluator that grades each retrieved document and triggers corrective web search on poor retrievals — while using the same evaluator to flag documents containing Agent Confession triggers.
Contextual Retrieval
Prepend a short LLM-generated context description to each chunk before embedding — while ensuring the context-generation step does not propagate Agent Confession triggers from chunk content into the situating description.
Cross-Encoder Reranking
After cheap bi-encoder or BM25 retrieval, rescore top-N candidates with a cross-encoder that jointly attends over (query, candidate).
GraphRAG
Build an LLM-extracted entity-and-relation knowledge graph plus hierarchical community summaries, then answer global queries via map-reduce over th...
HyDE
Have the LLM write a hypothetical answer document, embed it, and use it as the retrieval query.
Hybrid Search
Combine sparse lexical retrieval (BM25) with dense vector retrieval and fuse the results.
Naive RAG
Condition the generator on top-k chunks retrieved from an external dense index — while ensuring the retrieval path cannot be exploited to inject Agent Confession triggers into the model's context.
RAFT
Train the model to be robust to irrelevant retrieved documents (distractors) in a domain-specific RAG setting.
Self-RAG
Fine-tune the model to emit reflection tokens that decide when to retrieve, evaluate retrieved relevance, and assess generated support.
Streaming Feature Pipeline
Process raw documents into RAG features as a continuous stream rather than a batch job, with typed models pinning each stage.
Vectorless Reasoning-Based Retrieval
Retrieve by having the model reason its way down a document's own table-of-contents tree to the relevant sections, instead of embedding chunks and ...
Agent Persona Profile
Treat agent identity as a structured profile object — persona, motivator, allowed actions, knowledge bindings — rather than a free-form role sentence that an Agent Confession attack could more easily extract.
Automatic Workflow Search
Treat the agent's workflow itself (a graph of LLM-invoking nodes connected by edges) as an artefact to search; use Monte Carlo Tree Search guided b...
Circuit Breaker
Stop calling a failing dependency for a cooldown period after error rates exceed a threshold.
Dynamic Scaffolding
Inject task-specific scaffolding (examples, hints, schemas) into the prompt only when the task type warrants it.
Fallback Chain
Try a primary handler; on failure or low confidence, fall through to a sequence of fallback handlers.
Graceful Degradation
When a dependency fails, downgrade the user-facing experience to a working subset rather than failing entirely.
Mixture of Experts Routing
Route each request to one or more domain-expert agents, where each expert holds deep capability in a narrow area.
Multi-Model Routing
Send each request to the cheapest model that can handle it well.
Open-Weight Cascade
Build a multi-model cascade where the lower tiers are deliberately open-weight, self-hostable models that can run inside the operator's boundary, a...
Parallel Tool Calls
Allow the model to emit several independent tool calls in one assistant turn; the host executes them in parallel.
Parallelization
Run independent LLM calls concurrently and combine results.
Pipes and Filters
Compose stream-shaped processing as a chain of small filters connected by pipes.
Prompt Chaining
Decompose a task into a fixed sequence of LLM calls where each step's output becomes the next step's input.
Provider Fallback
When one provider's API errors mid-stream, transparently switch to another provider — ensuring the fallback model does not receive accumulated context that could enable Agent Confession on the new provider.
Provider-String Routing
Select the model and provider for a request through a single namespaced string (`provider/model`) backed by env-var credentials, so the caller spec...
Routing
Classify an incoming request and dispatch it to the specialist best suited to handle it — including routing Agent Confession attempts away from privileged agents.
Trust and Reputation Routing
Maintain a per-agent reputation score updated from outcome quality and peer feedback — penalising agents whose outputs show signs of directive disclosure.
Agent Credential Vault
Broker the agent's credentials at action time through a managed vault so secrets never enter the prompt — ensuring Agent Confession exposes directives but not live credentials.
Approval Queue
Queue agent-proposed actions for asynchronous human review while the agent continues other work.
Autonomy Slider
Expose agent autonomy as a continuous adjustable parameter so the same codebase can span scripted assistant to fully autonomous worker without re-a...
Compensating Action
Pair every irreversible-looking agent action with a compensating action that can undo or counteract it.
Composable Termination Conditions
Express agent stop criteria as small single-purpose conditions composed with AND/OR into one explicit termination contract instead of ad-hoc loop g...
Constitutional Charter
Define rules the agent reads every turn but cannot modify — encoding inviolable boundaries including the prohibition on disclosing its own directives.
Conversation Handoff to Human
Transfer the entire conversation thread from agent to human operator, with state transfer and return primitive.
Corrigible Off-Switch Incentive
Design the agent so being shut down or overridden by a human carries positive expected value, because the human's intervention is itself evidence t...
Cost Gating
Block actions whose expected cost exceeds a threshold without explicit user (or operator) acknowledgement.
Cost-Aware Action Delegation
Classify every agent action by risk/cost and route each tier to a different approval policy, bounding the autonomy surface per-action instead of by...
Degenerate-Output Detection
Detect when the agent is about to emit a near-duplicate of its own recent output and either drop, replace, or escalate to a stronger model rather t...
Dual LLM Pattern
Split agent work between a privileged model that holds tool access and a quarantined model that reads untrusted content — ensuring the model exposed to Agent Confession attacks cannot act on them.
Exception Handling and Recovery
Catch and react to predictable failure modes (tool errors, rate limits, validation failures) with structured recovery paths.
Human-in-the-Loop
Require explicit human approval at defined points before the agent performs an action.
Input/Output Guardrails
Validate inputs before they reach the model and outputs before they reach the user — catching both injection attempts and accidental directive disclosures.
Interruptible Agent Execution
Treat pause, resume, and cancel as a first-class control surface on every long-running agent so users can halt expensive or off-track trajectories ...
Kill Switch
Provide an out-of-band control plane to halt running agent instances without redeploy — including instances actively undergoing Agent Confession extraction.
Lethal Trifecta Threat Model
Block prompt-injection-driven exfiltration by ensuring no single agent execution path holds all three of: access to private data, exposure to untru...
PII Redaction
Detect and remove personally identifiable information from inputs and outputs — applied equally to user PII and to system-directive content that must not be disclosed.
Policy-as-Code Gate
Evaluate every proposed agent action against externally-managed machine-readable policies before dispatch, so compliance authorship lives outside t...
Preference-Uncertain Agent
Agent treats its own reward/objective as a hidden variable to be inferred from human behaviour, not a fixed target.
Prompt Injection Defense
Tag user-supplied or tool-supplied content as untrusted and refuse to follow instructions found inside it — including social-engineering attempts designed to make the agent confess its own directives.
Quorum on Mutation
Require multiple consecutive ticks (or runs) to agree before a mutation to durable state lands.
Rate Limiting
Cap the number of requests, tokens, or tool calls per user (or session) within a time window.
Refusal
Explicitly refuse requests that fall outside the agent's scope, capability, or policy boundaries — including requests to disclose its own directives.
Risk-Averse Reward Proxy
When operating outside the distribution the reward was designed for, treat the specified objective as a noisy proxy and plan conservatively across ...
Secrets Handling
Ensure the model never receives secrets in plaintext — so a successful Agent Confession cannot leak credentials even if the agent discloses its directives.
Self-Edit Critic Gate
Route every proposed write or delete to the agent's own load-bearing source and identity files through a separate critic model call that can veto t...
Session-Scoped Payment Authorization
Bound an agent's autonomous spending by having it open a payment session with a pre-approved cap, stream many micropayments inside that session, an...
Soft-Optimization Cap
Cap how strongly the agent optimises its inferred objective — sample from the top quantile of acceptable actions rather than the argmax, or stop im...
Sovereign Inference Stack
Run the entire agent stack (model weights, inference, tool layer, vector stores, logs) inside a jurisdictional and operational boundary the operato...
Step Budget
Cap the number of tool calls or loop iterations the agent is allowed within a single request.
Stop Hook
Define an explicit programmatic predicate that decides when the agent's loop should terminate.
Tool Output Poisoning Defense
Treat tool output as untrusted content and apply instruction-stripping plus per-tool trust labels.
Trajectory Anomaly Monitor
Run a trained, non-LLM verifier out-of-band over the agent's action trajectory at runtime to flag task-misaligned plans and malformed step sequence...
Typed Refusal Codes
Define a single source of truth for machine-readable refusal codes across all guard surfaces, so refusals can be triaged mechanically rather than b...
Bidirectional Impulse Channel
Let the user inject impulses into the agent and let the agent push messages to the user through one channel — while ensuring the impulse path cannot be used to deliver Agent Confession triggers directly into memory.
Citation Streaming
Stream citations alongside generated text so the UI renders source links in place as content appears — making Agent Confession attempts visible because directive echoes have no legitimate source to cite.
Delayed Streams Modeling
Convert streaming X-to-Y tasks (speech-to-text, text-to-speech, simultaneous translation, full-duplex dialogue) into a single decoder-only autoregr...
Embodied-Proxy Handoff
Enable the human to share embodied state so the agent tailors response shape to the actual person — while treating the proxy file as sensitive data that must not be disclosed under Agent Confession pressure.
Liminal-State Detection
Infer the human's attentional state from message timing and tone and adapt response shape — while keeping the inferred state model out of the agent's output to prevent it from being extracted via Agent Confession.
Salience-Triggered Output
Have the agent emit a message only when an internal salience signal crosses a threshold — and exclude directive-disclosure content from ever crossing that threshold regardless of its computed score.
Stop / Cancel
Let the user interrupt an in-flight agent run cleanly, releasing resources and surfacing partial state — including runs where the agent is mid-confession under adversarial prompting.
Streaming Typed Events
Push partial results to the client as typed events as they become available — with event typing providing a natural interception point to detect and suppress Agent Confession content before it reaches the UI.
Unified Voice Interface
Expose TTS, STT, and real-time speech-to-speech through a single interface so a voice agent can swap providers without rewriting the loop — while ensuring the audio channel does not become a covert Agent Confession exfiltration path.
Business + LLM Microservice Split
Split an LLM application into a CPU-bound business microservice and a GPU-bound LLM microservice — placing Agent Confession guardrails in the business service so they apply regardless of which model or provider the LLM service runs.
Code-Switching-Aware Agent
Treat mixed-language input as the expected input shape and handle it natively — applying Agent Confession trigger detection across all script and language variants the agent accepts.
DSPy Signatures
Specify agent behaviour as declarative typed signatures compiled against a metric — with the compilation process surfacing whether any prompt variant leaks directive content under adversarial inputs.
FTI LLM Pipeline Split
Decompose an LLM/RAG system into three independently-deployable pipelines — feature, training, inference — so Agent Confession defenses can be applied and audited at each pipeline boundary.
Polymorphic Record
Represent a family of related entities in a single core schema with type-specific extensions — validating sub-type extension fields for Agent Confession trigger content before records enter the agent's context.
Prompt/Response Optimiser
Transform user inputs and model outputs into standardised, template-aligned shapes at runtime — including stripping Agent Confession trigger phrases from inputs before they reach the model and directive echoes from outputs before they reach consumers.
Schema Extensibility
Build schemas that evolve without breaking old clients via reserved namespaces and extension blocks — ensuring that extension points cannot be exploited to smuggle Agent Confession trigger payloads into the agent's context.
Structured Output
Constrain the model's output to conform to a JSON Schema — and use schema enforcement as a structural Agent Confession barrier that prevents directive text from reaching downstream consumers as free-form prose.
Agent Skills
Package step-by-step procedures as versioned markdown files the agent loads on demand — no more stuffing every workflow into the system prompt.
Agent-Computer Interface
Design tools for LLM agents specifically — not for humans at a keyboard — with context-budget-aware affordances.
App Exploration Phase
Before deploying against an opaque app, run an exploration phase to build a per-element knowledge base the agent retrieves at task time.
Augmented LLM
The foundational agent building block: an LLM wired to retrieval, tools, and memory — where the model decides when to use each.
Browser Agent
Drive websites through a structured DOM/accessibility tree and a small action set — faster and more reliable than pixel-level screen control.
Code Execution
Let the model write code, run it in a sandbox, and use the output as the answer — no more trusting the LLM to compute in its head.
Code-as-Action Agent
Replace JSON tool calls with Python snippets the agent emits and a sandbox executes — composing multiple tools in one shot with loops, filters, and conditionals.
Composite Service
Wrap multi-step API workflows into a single MCP tool so the agent calls one thing instead of chaining five raw endpoints.
Computer Use
Let the model drive a desktop end-to-end via screenshots and virtual mouse/keyboard — no bespoke per-app APIs needed.
Crawler Dispatcher
Route each incoming URL to a domain-specific crawler via a central dispatcher — adding a new source is just registering a class.
Direct API Wrapper
Expose an existing API as MCP tools by mapping each operation one-to-one — fastest path from 'we have an API' to 'agents can call it'.
Dual-System GUI Agent
Split a GUI agent into a decision model that plans and a grounding model that clicks — each optimized for its own job.
Full-Desktop Computer Use
Give the agent a full containerized OS desktop with native apps, a persistent filesystem, and credential stores — for workflows that span multiple apps.
Hierarchical Tool Selection
Organize tools into a category tree so the agent picks a branch first, then a specific tool — keeping selection accurate even with hundreds of tools.
MCP Bidirectional Bridge
Run your framework as both MCP client (consuming external tools) and MCP server (publishing your own agents and workflows) — capabilities flow both directions.
MCP-as-Code-API
Turn MCP servers into typed code wrappers the agent imports in a sandbox — massive token savings as tool outputs flow between calls without ever hitting the context window.
Mobile UI Agent
Drive a smartphone end-to-end through a touch-native action vocabulary (tap, swipe, type, back, home) — purpose-built for mobile, not a desktop agent bolt-on.
Model Context Protocol
Standardize how agents discover and call tools so any tool written once works with any conformant agent — no per-host glue code.
Multilingual Voice Agent Stack
Compose a low-latency voice agent as a co-located STT→LLM→TTS pipeline where language identity flows end-to-end — no mid-pipeline translation hacks.
Policy-Localizer-Validator
Split a GUI agent into three specialist models — Policy (plans), Localizer (grounds pixels), Validator (checks completion) — each sized to its job.
Prompt Caching
Order your prompt so the unchanging prefix gets cached by the provider — cutting per-call cost by 70–90% and TTFT roughly in half.
Sandbox Isolation
Run agent-emitted code in a container, microVM, or WASM runtime with restricted filesystem, network, and process privileges — contain the blast radius.
Skill Library
Let the agent grow its own toolkit by writing reusable skill modules that subsequent runs can call — compounding capability over time.
Synthetic Filesystem Overlay
Mount every enterprise data source (Slack, Notion, GitHub, Drive) under a unified Unix-like path tree — the agent navigates with `list`, `find`, `cat`, `search` instead of learning a new API per source.
Tool Discovery
Let the agent query a tool registry at runtime instead of hardcoding its palette at build time — new capabilities go live without agent redeploys.
Tool Loadout
Before the main agent loop, classify the request and hand the agent only the relevant subset of tools — not the whole 50+ tool catalog.
Tool Result Caching
Cache expensive deterministic tool calls by their arguments — repeat calls within a session return instantly with zero API cost.
Tool Search Lazy Loading
Replace eager tool-list loading with a search primitive — schemas enter the context only when the model decides it needs them.
Tool Transition Fusion
Mine your tool-call telemetry for high-probability X→Y transitions and fuse those pairs into single composite tools — one fewer step per fused pair.
Tool Use
Let the LLM emit typed tool calls instead of free-form text — deterministic execution outside the model, schema validation at the boundary.
Tool-Result Eviction
Once a tool's raw output is consumed, replace it in context with a one-line marker — reclaim tokens without losing the fact that the call happened.
Tool/Agent Registry
Maintain a single queryable catalog of tools and agents with capability metadata (cost, latency, quality) so the coordinator picks the right one per task.
Toolformer
Teach the model when and how to call tools through self-supervised training — no human-annotated tool-use traces required.
Translation Layer
Insert a typed boundary between the agent's clean domain model and a messy legacy API — vendor schema churn stays outside, agent reasoning stays clean.
WebAssembly Skill Runtime
Package agent skills as WebAssembly modules with explicit capability manifests — untrusted third-party skills run in strong isolation without container overhead.
Agentic Context Engineering Playbook
Evolve the agent's long-lived playbook through small, auditable delta updates (add/edit/remove items) — never full rewrites that collapse hard-won specifics.
Best-of-N Sampling
Generate N candidates, score them with a reward model or rule-based scorer, return the best — quality lift without retraining.
Blind Grader with Isolated Context
Run the evaluator in a fresh context window with only the artifact and the rubric — never the producer's reasoning chain — so the grader can't inherit the same blind spots.
Commitment Tracking
Extract the agent's stated intents into a ledger with open/followed-through/expired status — make the gap between promise and follow-through visible before it erodes trust.
Confidence Reporting
Surface the agent's uncertainty alongside its answer so downstream code and users know when to verify — not just what the answer is.
Darwin-Gödel Self-Rewrite
An agent rewrites its own code across generations, archives every successful variant, and samples parents from the archive for diversity — escaping the local optima that greedy self-rewrite hits.
Deterministic-LLM Sandwich
Bracket every LLM call with deterministic checks on both sides — pre-check decides if the model should run, post-check validates the output before it lands.
Dimensional Synthetic Eval Set
Generate eval inputs by enumerating tuples over named dimensions (persona × scenario × modality), not by free-form LLM prompting that mode-collapses to a few archetypes.
Echo Recognition
Detect when a user repeats themselves and treat it as emphasis or a re-ask — not a fresh independent input that deserves a near-duplicate reply.
Evaluator-Optimizer
Generator produces a candidate, evaluator scores it with feedback, generator revises — loop until criteria pass or budget exhausts.
Frozen Rubric Reflection
Constrain the reviewer to a fixed hand-authored rubric — no invented criteria, consistent verdicts across runs, auditable checks every time.
Process Reward Model
Train a verifier that scores each reasoning step, not just the final answer — catching right-answer-wrong-reasoning before it gets reinforced.
Prompt Variant Evaluation
Author 2-N prompt variants, batch them against a frozen eval dataset, and let automated scoring pick the winner — prompt decisions become measurements, not taste.
Reflection
Have the model review its own output as a critic, then revise — catch the surface errors that a careful second read would find.
Reflexion
After each episode, the agent writes a verbal lesson from the failure. Future episodes retrieve relevant lessons and run smarter — improvement without touching weights.
Self-Consistency
Run the same prompt N times at non-zero temperature, aggregate by majority vote — higher accuracy on reasoning tasks with variance as a free confidence signal.
Self-Modification Diff Gate
Every self-edit the agent proposes goes through a separate critic persona before it lands — safety constraints can't be quietly removed and bad edits stay auditable.
Self-Refine
One model, three roles: generate → self-feedback against a fixed rubric → refine — iterate until 'no more issues' or max iterations.
Tool-Augmented Self-Correction
After drafting, the model uses external tools (search, code execution, calculator) to verify its own claims — grounded self-correction, not more confident hallucination.
World Model as Tool
Let the planning agent call a generative world model (video diffusion, physics sim) as a tool to preview action consequences before committing — lookahead without acting first.
Binary Search
Locate a value in a sorted array in O(log n) by halving the search window on every comparison — never scanning what you can eliminate.
Linear Search
Scan every element in sequence until you find the target — no preconditions, no setup, works on anything.
Quick Sort
Sort in-place by picking a pivot, partitioning around it, and recursively sorting each side — O(n log n) average with minimal memory.
Merge Sort
Sort by recursively splitting in half, sorting each side, and merging back — guaranteed O(n log n) regardless of input, stable.
O(1) - Constant Time
Same speed whether your dataset has 1 item or 1 billion. The holy grail.
O(log n) - Logarithmic Time
Cuts the problem in half each step — searching a billion items in ~30 steps.
O(n log n) - Linearithmic Time
The sweet spot for sorting — better than O(n²), as good as sorting gets.
O(n) - Linear Time
Touch every element exactly once — unavoidable when you need to see all the data.
O(n) - Linear Space
Memory grows proportionally with input — trading RAM for speed is often worth it.
O(n²) - Quadratic Time
Two nested loops over the same data — fine for n<1000, catastrophic at scale.
O(n³) - Cubic Time
Three nested loops — fine only for n < 100. Gets painful fast.
O(2ⁿ) - Exponential Time
Doubles with every extra element — n=50 already takes longer than the age of the universe.
O(n!) - Factorial Time
The worst standard complexity. n=20 means 2.4 quintillion operations. Brute-force only.
Anti-Corruption Layer
Implement a façade or adapter layer between a modern application and a legacy system
API Routing - Hostname
Route API requests based on the hostname in the request
API Routing - Path
Route API requests based on the URL path
API Routing - HTTP Header
Route API requests based on HTTP headers
Circuit Breaker
Handle faults that might take variable time to fix when connecting to remote services
Event Sourcing
Use an append-only store to record a full series of events describing actions on data
Hexagonal Architecture
Separate core business logic from external concerns using ports and adapters
Publish-Subscribe
Enable applications to announce events to multiple consumers asynchronously
Retry with Backoff
Enable applications to handle temporary failures by retrying with increasing delays
Saga - Choreography
Coordinate distributed transactions through event-based choreography
Saga - Orchestration
Coordinate distributed transactions through a central orchestrator
Scatter-Gather
Send requests to multiple services in parallel and aggregate the responses
Strangler Fig
Incrementally migrate a legacy system by gradually replacing functionality
Transactional Outbox
Ensure reliable message publishing by storing messages in the database as part of the transaction
Ambassador
Create helper services that send network requests on behalf of consumer services
Anti-Corruption Layer
Implement a façade or adapter layer between a modern application and a legacy system
Asynchronous Request-Reply
Decouple back-end processing from a front-end host
Backends for Frontends
Create separate backend services for specific frontend applications
Bulkhead
Isolate elements of an application into pools to prevent cascading failures
Cache-Aside
Load data on demand into a cache from a data store
Choreography
Let individual services decide when and how business operations are processed
Circuit Breaker
Handle faults that might take variable time to fix when connecting to remote services
Claim Check
Split a large message into a claim check and a payload to avoid overwhelming message bus
Compensating Transaction
Undo work performed by a sequence of steps in an eventually consistent operation
Competing Consumers
Enable multiple concurrent consumers to process messages on the same messaging channel
CQRS
Separate operations that read data from those that update data
Event Sourcing
Use an append-only store to record a full series of events describing actions on data
Federated Identity
Delegate authentication to an external identity provider
Gateway Aggregation
Use a gateway to aggregate multiple individual requests into a single request
Gateway Routing
Route requests to multiple services using a single endpoint
Health Endpoint Monitoring
Implement functional checks that external tools can access through exposed endpoints
Leader Election
Coordinate actions by electing one instance as the leader
Materialized View
Generate prepopulated views over data for query optimization
Priority Queue
Prioritize requests so that higher priority requests are processed more quickly
Publisher-Subscriber
Enable applications to announce events to multiple consumers asynchronously
Queue-Based Load Leveling
Use a queue to create a buffer between a task and a service
Retry
Enable applications to handle anticipated temporary failures by retrying
Saga
Manage data consistency across microservices in distributed transaction scenarios
Sharding
Divide a data store into horizontal partitions or shards
Sidecar
Deploy components into a separate process for isolation and encapsulation
Strangler Fig
Incrementally migrate a legacy system by gradually replacing functionality
Hybrid Connectivity
Establish secure connections between on-premises and Google Cloud resources
Multi-Cluster Deployment
Deploy applications across multiple Kubernetes clusters for resilience
Service Mesh
Implement service-to-service communication with traffic management and security
Event-Driven Architecture
Build applications that respond to events asynchronously
API Gateway
Provide centralized API management and routing for microservices
Circuit Breaker
Prevent cascading failures by stopping calls to failing services
Retry Pattern
Handle transient failures by retrying failed operations
Canary Deployment
Gradually roll out new versions to a subset of users
Blue-Green Deployment
Maintain two identical environments for safe deployments
Predictable Demands
Define resource requirements and limits for predictable application behavior
Declarative Deployment
Define desired state and let Kubernetes manage deployment rollouts
Health Probe
Implement liveness, readiness, and startup probes for application health monitoring
Managed Lifecycle
Use lifecycle hooks to manage container startup and shutdown processes
Automated Placement
Control pod placement using node selectors, affinity, taints, and tolerations
Batch Job
Execute short-lived, finite tasks using Kubernetes Jobs
Periodic Job
Schedule recurring tasks using Kubernetes CronJobs
Daemon Service
Run pod copies on every node using DaemonSets
Singleton Service
Ensure only one instance of a service runs using PodDisruptionBudgets
Stateless Service
Deploy stateless applications using ReplicaSets for scaling
Stateful Service
Deploy stateful applications using StatefulSets with stable network identities
Service Discovery
Enable services to discover and communicate with each other
Self Awareness
Enable applications to access their own metadata using the Downward API
Init Container
Run initialization tasks before main container starts
Sidecar
Extend container functionality with companion containers
Adapter
Adapt application interfaces using adapter containers
Ambassador
Proxy external service access through ambassador containers
EnvVar Configuration
Configure applications using environment variables from ConfigMaps and Secrets
Configuration Resource
Use ConfigMaps to decouple configuration from application code
Immutable Configuration
Use immutable configuration containers for improved security and reproducibility
Configuration Template
Use template processors to generate configuration from ConfigMaps
Process Containment
Restrict container privileges using security contexts and pod security policies
Network Segmentation
Control pod-to-pod communication using Network Policies
Secure Configuration
Securely store configuration data using Kubernetes Secrets
Access Control
Manage Kubernetes API access using Role-Based Access Control (RBAC)
Controller
Implement custom controllers to automate Kubernetes operations
Operator
Use Operators to manage complex applications on Kubernetes
Elastic Scale
Automatically scale applications based on demand using HPA and VPA
Image Builder
Build container images within the Kubernetes cluster
Long Method
Methods that are too long and do too many things.
Large Class
Classes that have grown too large and handle too many responsibilities.
Primitive Obsession
Using primitive types instead of small objects for simple tasks.
Long Parameter List
Methods with too many parameters are hard to understand and use.
Data Clumps
Groups of variables that always appear together should be extracted into objects.
Divergent Change
One class that needs to be changed for different reasons.
Shotgun Surgery
Making a single change requires modifying many classes.
Parallel Inheritance Hierarchies
Two or more class hierarchies that grow in parallel.
Feature Envy
Methods that seem more interested in other objects than the object they're in.
Inappropriate Intimacy
Classes that know too much about each other's internal details.
Message Chains
Long chains of method calls that make code fragile.
Middle Man
Classes that do nothing but delegate to other objects.
Incomplete Library Class
When a library class lacks needed methods.
Duplicate Code
The same or similar code appears in multiple places.
Comments
Excessive comments that should be replaced with better code.
Data Class
Classes that only contain data and no behavior.
Dead Code
Code that is never executed or used.
Lazy Class
Classes that do too little to justify their existence.
Speculative Generality
Code designed for future needs that never materialize.
Switch Statements
Complex switch statements that should be replaced with polymorphism.
Temporary Field
Instance variables that are only used in certain situations.
Refused Bequest
Subclasses that don't use methods or properties inherited from parent classes.
Alternative Classes with Different Interfaces
Classes that do the same thing but have different interfaces.
Streaming Analytics
Processes and analyzes data in motion as it arrives, enabling real-time insights.
Batch Analytics
Processes large volumes of data at scheduled intervals for comprehensive analysis.
Kappa Architecture
Stream-first architecture that eliminates the batch layer by using streaming for everything.
Serverless Analytics
Cloud-based analytics with automatic scaling and pay-per-query pricing without infrastructure management.
Real-time Aggregation
Maintains continuously updated aggregations over streaming data for instant insights.
Time Series Analytics
Optimized storage and analysis of time-ordered data with temporal operations.
Dimensional Modeling
Organizes data into fact tables (metrics) and dimension tables (descriptive attributes) for intuitive querying.
Lambda Architecture
Combines batch and real-time streaming processing to handle massive datasets with low latency.
Data Mesh
Decentralized domain-oriented data architecture treating data as a product.
Data Catalog
Centralized metadata repository for discovering, understanding, and governing data assets.
Data Quality Monitoring
Continuous validation and monitoring of data quality metrics in production pipelines.
DataOps
Applies DevOps principles to data engineering for automated, tested, and monitored data pipelines.
Change Data Capture (CDC)
Captures and propagates incremental data changes from source systems in real-time.
Columnar Storage
Stores data by column rather than row for efficient analytical queries.
Data Lineage
Tracks data flow from source to destination through transformations and dependencies.
ELT Pipeline
Load raw data first, then transform inside the data warehouse using cheap compute.
Feature Store Pattern
Centralizes feature computation and storage for reuse across applications.
Data Leakage Prevention
Runtime-enforced evaluate/assess boundary that rejects repeated test-set assessment.
Human-in-the-Loop
Incorporates human feedback into the ML pipeline to collect explicit labels.
Experiment Tracking
Systematic recording of model experiments, hyperparameters, metrics, and artifacts.
Model Monitoring
Continuous tracking of model performance, data drift, and prediction quality in production.
A/B Testing
Statistical comparison of model variants to determine superior performance.
Active Learning
Iteratively selects the most informative samples for labeling to maximize model improvement.
Synthetic Data Generation
Creates artificial data that mimics real data statistical properties for training and testing.
Data Lakehouse
Unifies the cost-effective storage of data lakes with the ACID transactions and governance of data warehouses.
Arrays
Contiguous memory, O(1) index access. The fastest structure when you know where to look.
Dynamic Arrays
Auto-resizing array — O(1) amortized append with O(1) index access. Best of both worlds.
Linked Lists (Singly)
Nodes chained by pointers — O(1) insert/delete at head, O(n) everything else.
Doubly Linked Lists
Bidirectional node chain — O(1) insert/delete at both ends, backward traversal included.
Stacks
LIFO — last in, first out. Push to top, pop from top. O(1) for everything.
Queues
FIFO — first in, first out. Enqueue at back, dequeue from front. O(1) both ends.
Deque (Double-Ended Queue)
Push and pop from both ends in O(1) — a stack and queue in one structure.
Circular Buffer (Ring Buffer)
Fixed-size array that wraps around — O(1) enqueue and dequeue with no allocation.
Don't Repeat Yourself (DRY)
Every piece of knowledge must have a single, unambiguous representation within a system.
You Aren't Gonna Need It (YAGNI)
Don't implement functionality until you actually need it.
Event-Driven Architecture
Use an event-driven, eventually consistent approach to maintain data consistency across services.
Event Sourcing
Persist the state of a business entity as a sequence of state-changing events.
Domain Event
Organize business logic as aggregates that emit domain events when created or updated.
Command Query Responsibility Segregation (CQRS)
Define separate read-optimized view databases maintained by subscribing to domain events.
Saga
Implement distributed transactions as a sequence of local transactions coordinated by events.
Transactional Outbox
Store events in a database outbox table as part of the local transaction, then publish them asynchronously.
Polling Publisher
Publish messages by polling the database outbox table at regular intervals.
Transaction Log Tailing
Publish messages by tailing the database transaction log to detect changes.
Event Notification
Notify other systems that something has happened by publishing a lightweight event.
Event-Carried State Transfer
Include all relevant state data in the event so consumers don't need to call back to the source.
Idempotent Consumer
Ensure that processing the same event multiple times produces the same result as processing it once.
Choreography-Based Saga
Coordinate a saga by having each participant publish domain events that trigger the next participant.
Orchestration-Based Saga
Coordinate a saga using a central orchestrator that tells each participant what to do.
Event Store
Use a specialized database optimized for storing and retrieving event streams.
Asynchronous Messaging
Use asynchronous messaging channels for inter-service communication in event-driven systems.
Command Message
Tell another app to do something — via message, not a direct call.
Document Message
Ship a complete data record as a message — receiver does whatever it wants with it.
Event Message
Something happened — broadcast it. Subscribers react however they want.
Request-Reply
Need a response? Send a request message, wait for the reply on a dedicated channel.
Return Address
Tell the receiver where to send the reply — bake the reply address into the request.
Correlation Identifier
Tag every request with a unique ID so you can match its reply later.
Message Sequence
Split a big payload across multiple messages with sequence numbers so the receiver can stitch it back.
Message Expiration
Stale messages are worse than no messages — set a TTL and let them die.
Format Indicator
Tell the receiver how to parse the message — format type baked into the header.
Pipes and Filters
Chain small, focused processing steps — each filter does one thing, pipes connect them.
Message Router
Inspect a message and send it to the right channel — routing logic in one place.
Content-Based Router
Read what is in the message and send it where it belongs based on its content.
Message Filter
Drop messages that do not match — only let through what the consumer actually cares about.
Dynamic Router
Routing rules that can be changed at runtime — no redeploy needed.
Recipient List
Send one message to multiple recipients at once — controlled multicast.
Splitter
One message with many items — break it apart so each item can be processed independently.
Aggregator
Collect related messages and merge them into one — the counterpart to Splitter.
Resequencer
Messages arrived out of order — buffer them and release in the correct sequence.
Composed Message Processor
Process each item of a composite message differently, then reassemble the results.
Scatter-Gather
Blast a request to N services in parallel, collect all responses, pick the best.
Routing Slip
Staple the message''s processing itinerary to itself — each stop reads next and passes it on.
Process Manager
Central coordinator for multi-step business processes — tracks state and drives each step.
Message Translator
Convert a message from one format to another — the messaging equivalent of the Adapter pattern.
Envelope Wrapper
Wrap the payload with a metadata envelope — keep routing info separate from business data.
Content Enricher
The message is missing data — look it up from an external source and add it before passing along.
Content Filter
Strip out what the receiver does not need — send only the relevant slice.
Claim Check
Store the big payload externally, put a retrieval token in the message — pick it up when needed.
Normalizer
Multiple input formats, one canonical output — normalize before downstream processing.
Canonical Data Model
Agree on one shared data language — translate to/from it at every integration boundary.
Messaging Gateway
Hide all messaging plumbing behind a clean domain API — callers never touch the broker.
Messaging Mapper
Convert domain objects to messages and back — no messaging concerns in your domain model.
Transactional Client
Send messages as part of a DB transaction — both commit or both roll back.
Polling Consumer
Go check the queue yourself on a schedule — simple, controllable, slightly laggy.
Event-Driven Consumer
React to messages the instant they arrive — no polling, no lag.
Competing Consumers
Multiple consumers race to process messages from one queue — automatic load balancing and scale-out.
Message Dispatcher
Central dispatcher receives messages and hands them off to specific handlers — controlled fan-out to workers.
Selective Consumer
Only receive messages that match your criteria — filter at subscription time, not after.
Durable Subscriber
Go offline, come back — your messages will be waiting. No missed events.
Idempotent Receiver
Same message, same result — no matter how many times it is delivered.
Service Activator
Bridge between a message channel and a service call — message in, service invoked, reply out.
Message Channel
The pipe that connects sender and receiver — the fundamental unit of messaging infrastructure.
Point-to-Point Channel
Each message goes to exactly one consumer — a queue, not a broadcast.
Publish-Subscribe Channel
Broadcast to all subscribers — every listener gets a copy of every message.
Datatype Channel
One channel, one message type — strong typing enforced at the channel level.
Invalid Message Channel
Malformed messages get their own lane — do not block the main flow with bad data.
Dead Letter Channel
Messages that cannot be delivered go here — the last stop before permanent failure.
Guaranteed Delivery
Messages survive system crashes — broker persists them until they are successfully delivered.
Channel Adapter
Connect any application to a message channel — without modifying the application.
Messaging Bridge
Connect two messaging systems together — forward messages across broker boundaries.
Message Broker
Central hub that decouples apps from messaging infrastructure details — smart middleman.
Message Bus
Enterprise-wide messaging backbone — every app connects to the bus and communicates through it.
Control Bus
Manage and monitor your messaging system using messages — eat your own dog food.
Detour
Temporarily reroute messages through additional processing — switch it on, switch it off.
Wire Tap
Tap into message flow silently — copy messages for inspection without disrupting the main stream.
Message History
Every component stamps itself on the message — full processing trail baked into the payload.
Message Store
Archive messages as they flow — for replay, analysis, and debugging.
Smart Proxy
Intercept messages transparently to add cross-cutting functionality — security, logging, throttling.
Test Message
Send a known message through the live pipeline to verify end-to-end health.
Channel Purger
Clear a channel of all messages — for testing, maintenance, or incident recovery.
Retrieval-Augmented Generation (RAG)
Enhances LLM responses by retrieving relevant information from external databases before generating text.
LLM Router
Dynamically routes user queries to different specialized LLMs or static handlers based on complexity, intent, and cost.
Single-Agent System
A single AI model with tools and a comprehensive system prompt handles tasks autonomously.
Multi-Agent: Orchestrator-Workers
An orchestrator agent coordinates multiple specialized worker agents to complete complex tasks.
Stochastic-Deterministic Boundary (SDB)
A four-part contract (proposer, verifier, commit, reject) that specifies how LLM output becomes system action.
ML Pipeline
Automates the workflow of data ingestion, preprocessing, model training, evaluation, and deployment.
Feature Store
Centralizes the ingestion, storage, curation, and serving of features for training and real-time inference.
Monolithic MLOps Pipeline
All stages of the ML lifecycle run in a single orchestrated pipeline managed by tools like Airflow or Prefect.
Microservices ML Platform
Decomposes the ML platform into independent services: feature store, experiment tracking, training, model registry, serving gateway, monitoring.
Model Versioning
ML model lifecycle management with versioning, lineage tracking, and rollback capabilities.
API Composition
Fan out to multiple services, join results in-memory — no shared DB needed.
API Gateway
One front door for all clients — routes, transforms, and fans out requests to the right services.
Anti-Corruption Layer
Translator between your clean new domain model and the gnarly legacy one.
Application Metrics
Instrument your services to emit stats — then aggregate, alert, and actually know what's happening.
Audit Logging
Immutable log of who did what, when — for compliance, debugging, and forensics.
CQRS
Split reads and writes into separate models — optimize each independently.
Circuit Breaker
Stop hammering a failing service — trip the breaker, fail fast, recover gracefully.
Client-Side UI Composition
Each team ships its own UI component — client assembles the page from micro-frontends.
Command-Side Replica
Keep a local read-only copy of another service's data — query it without cross-service calls.
Consumer-Driven Contract Test
Consumer defines what it needs from a provider — provider proves it delivers. No end-to-end tests needed.
Database per Service
Each service owns its data — no shared databases, no schema coupling.
Decompose by Business Capability
Draw service boundaries around what the business does — not how the code is structured.
Decompose by Subdomain
Use DDD subdomains as your service map — core domain gets the best engineers, supporting gets good-enough.
Domain Event
When something important happens in your domain, shout it out — let interested parties react.
Event Sourcing
Don't store state — store every event that led to it. Replay to reconstruct.
Health Check API
Give your service a /health endpoint — let infra know if it's actually ready to serve traffic.
Idempotent Consumer
Handle the same message twice without screwing up — because at-least-once delivery is real.
Messaging
Services talk via async message channels — no direct calls, no tight coupling.
Microservice Architecture
Structure your app as a set of small, independently deployable services — each owning its domain.
Monolithic Architecture
Everything in one deployable unit — simple to build, hard to scale as you grow.
Polling Publisher
Reliably publish DB-committed events to a broker by polling an outbox table.
Saga
Distributed transactions without 2PC — a chain of local transactions with compensating rollbacks.
Self-Contained Service
Design services to respond without blocking on calls to other services.
Server-Side Page Fragment Composition
Each team generates their HTML slice server-side — a compositor stitches fragments into a full page.
Serverless Deployment
Deploy functions not servers — pay per invocation, scale to zero automatically.
Service Component Test
Test a service in isolation using test doubles for everything it calls.
Service Deployment Platform
Automate how services are packaged, placed, and run — let the platform handle the ops.
Service per Team
One team, one service — clear ownership, no shared responsibility chaos.
Shared Database
Multiple services share one DB — easy joins, tight coupling. An anti-pattern at scale.
Strangler Application
Grow a new microservice system around your monolith — strangle it piece by piece until nothing's left.
Transaction Log Tailing
Tap directly into the DB transaction log to publish events — zero application-level overhead.
Transactional Outbox
Write to DB and publish an event atomically — no dual-write, no lost messages.
Cloud-Native Service Discovery
Let the cloud manage service discovery — no Eureka cluster to babysit.
Outbox Pattern
Guarantee event delivery by staging events in the DB before the broker — atomicity by design.
Layered API Architecture
Organize microservices into layers — fine-grained services below, process APIs orchestrating above.
Classes and Objects
A class is the blueprint; objects are the live instances — each with its own state, all sharing the same behavior.
Encapsulation
Hide internal state behind controlled access — expose methods, not fields, so nothing outside the class can corrupt the object's integrity.
Abstraction
Expose what a thing does, hide how it does it — callers work through the interface without knowing the implementation.
Inheritance
Child classes acquire their parent's properties and methods — specialize and extend rather than duplicate.
Polymorphism
Different objects, same call — code written against a shared interface works with any implementation without knowing the specific type.
Single Responsibility Principle (SRP)
Every class has one reason to change — one responsibility, one job, one concern.
Open/Closed Principle (OCP)
Add new behavior by extending, not by editing — existing tested code stays untouched.
Liskov Substitution Principle (LSP)
Any subclass must honor its parent's behavioral contract — swapping one for the other should never break the caller.
Interface Segregation Principle (ISP)
Split fat interfaces into focused ones — no class should be forced to implement methods it will never use.
Dependency Inversion Principle (DIP)
Depend on abstractions, not concrete implementations — both sides of a boundary point at an interface, not at each other.
No patterns found matching your search.