All 99 articles, sorted alphabetically
pydantic-ai 2.65 Changes How Model Refusals Trigger Automatic Fallback
pydantic-ai v2.65.0, released on 3 November 2026, makes ModelFallback move on when a model refuses and stops Temporal retrying model errors that cannot succeed. A local before-and-after test, the error classes involved and what to change.
Read article →Catch Tool Selection Regressions Before Editing Agent Tool Descriptions
A one-line edit to a tool description can move questions to the wrong tool, including questions about other tools. A fixed case set, per-case diffs instead of one accuracy number, and measured runs on two small local models show what a selection regression test catches.
Read article →Agent Retry Policies: When to Retry a Tool, Replan the Task or Give Up
Transient, deterministic and semantic tool errors need different answers: retry with backoff and an idempotency key, change the arguments, or stop and hand over. Status code meaning, write safety, run-wide budgets and what the model should see.
Read article →Reliability Math for Multi-Step Agents: How Per-Step Failures Compound
A 20-step agent run where each step works 95 percent of the time finishes cleanly about a third of the time. The product rule, what retries really buy, why detector recall and shared causes cap them, checkpoints, voting, cost, and pass@k versus pass^k.
Read article →Detecting Stuck Agent Loops: Repeated Tool Calls, State Fingerprints, Progress Signals and Step Budgets
Why framework turn limits catch agent loops late and expensively, the shapes stuck runs take, how to fingerprint calls and results to detect repeats and oscillations, how a progress signal catches paraphrase loops, and what to do when a detector fires.
Read article →Why Agent Loops Run Away and How Step Budgets Stop Them
Why tool-calling agents loop until something kills them, the quadratic token cost of every extra step, and how step budgets and loop detectors stop it.
Read article →Retrying Agent Tool Calls Without Executing the Same Action Twice
Why agent retries and re-plans repeat refunds and emails, how idempotency keys deduplicate them, and how to choose the key, the scope and the retention.
Read article →Agent Context Compaction: What to Keep When the Window Fills Up
What to drop, summarise or pin when a long-running agent fills its context window, with the cost arithmetic and the failure modes of each strategy.
Read article →Supervisor or Swarm: When Multi-Agent Systems Actually Beat One Agent
When splitting an agent into a supervisor and specialists, or a swarm of peers, beats one agent: the arithmetic of tool count, handoffs, tokens and latency.
Read article →Tool Selection at Scale: Why Hundreds of Tools Break Agents and How to Route
Why agents pick the wrong tool once the catalog reaches hundreds, what every definition costs per call, and how retrieval and grouping route each request.
Read article →Agent Memory That Does Not Rot: Write Policies, Decay and Conflicts
Why long-term agent memory goes stale, wrong or poisoned, and how write gates, reconciliation, decay and provenance keep it accurate over months.
Read article →Human Approval Gates That Keep Agents Safe Without Becoming the Bottleneck
Why gating every agent tool call fails twice: reviewers fatigue and queues grow. How to size, tier and time out approval gates with the actual arithmetic.
Read article →Evaluating Agent Trajectories: Why pass@k Hides Unreliable Agents
Why pass@k flatters agents that fail users, how pass^k and trajectory grading measure reliability, and how many tasks and trials an honest eval needs.
Read article →Evaluating a Conversational Agent With a Simulated User: Goal Scripts, Stop Rules, Simulator Drift and Blaming the Right Side
How to evaluate a multi-turn agent with a simulated user: what goes into a goal script and persona, judging the end state instead of the transcript, stop rules, pass^k for consistency, why a cooperative simulator hides real bugs, and how to tell an agent failure from a simulator failure.
Read article →Change Budgets for Agent Writes: Capping What an Agent May Change per Window, Staged Expansion and Automatic Halt
A deterministic limit on how much an agent may change in a time window, separate from per-call authorization: counting change by blast radius, staged expansion as trust grows, an automatic halt when the budget is spent, and how this differs from rate limiting and spend caps.
Read article →Making an Existing CLI Work for Coding Agents: Detection, Compact Output, Explicit Truncation, JSON Errors and Cost Warnings
What changes when coding agents become the main users of a command-line tool, using the DuckDB 2.0 agent mode as a worked case: how the tool detects an agent, why a truncated result must say so, errors an agent can parse, warnings before expensive work, and how to measure whether any of it helps.
Read article →Rules First, Agent for the Residual: Adding an Agent to a Deterministic Pipeline Without Giving Up What Already Works
How to add an agent only for the cases an existing rules pipeline cannot decide: a deterministic router, a validator the agent cannot override, a confidence threshold measured on labelled cases, a human queue, and a path for promoting repeated agent decisions back into rules.
Read article →Scoring Agent Tool Calls Offline: Argument Normalisation, Equivalence Rules, Order-Free Parallel Calls and Credit for Abstaining
An offline scorer for agent tool calls that neither punishes harmless differences nor forgives real mistakes: per-argument normalisation owned by the tool, defaults, unordered parallel calls, alternative valid plans, abstention cases and when to switch to comparing final state.
Read article →Letting an Agent Query an Existing Database: Read-Only Roles, Row-Level Security, Settings an Agent Can Override and a Curated View Layer
A capability boundary for agent-generated SQL against a database that already serves an application: privileges instead of prompts, row-level security that the agent cannot switch, statement limits it cannot SET away, curated views, and a runnable SQLite gate.
Read article →Online Evaluation of a Production Agent: Stratified Sampling, a Judge Budget and Telling a Traffic-Mix Shift From a Real Quality Drop
How to score a sample of live agent runs every week without being fooled by traffic mix: segment the traffic, spend a fixed judge budget by stratum, put a Wilson interval on every segment, reweight to a reference mix, and alert per segment instead of on one aggregate number.
Read article →Testing a Service Once an Agent Calls It: Consumer Contracts at the Tool Boundary, Recorded Model Replays, Effect Invariants and What Stays Out of CI
How to test a service whose new caller is an agent: treat the tool definition as a consumer-driven contract, replay recorded model responses so the runtime is tested deterministically, check effect invariants with generated call sequences, and keep live model runs in a separate statistical suite.
Read article →OpenAI Agents SDK for Python 0.24.0: Deferred Approvals That Survive a Resume, Compaction That Waits for Them, MCP Annotations on Tools and Sibling Failures That Keep Finished Outputs
openai-agents-python 0.24.0 (15 October 2026), read from its commits: a session corruption after approval resumes, compaction that now waits for pending approvals, tool outputs preserved when a sibling fails, MCP annotations on converted tools, and a run-wide formatter for tool exceptions.
Read article →Observation-Only Hooks Around Model Requests: What Codex Reports Before and After Each Attempt, Why Observers Cannot Veto, and Sync Versus Async Ordering With Tool Dispatch
Codex added observation-only PreModelRequest and PostModelRequest hooks on 18 October 2026. What they carry, why observers cannot veto or alter a request, how sync and async hooks order against tool dispatch, and how to build per-attempt metrics on them.
Read article →Durable Execution for Agent Workflows: Replay Determinism, Model Calls as Activities, Versioning Prompts and Resuming a Run That Waited a Week
How durable-execution engines resume an agent workflow by replaying its history: why workflow code must be deterministic, why every model and tool call belongs in an activity, how to change prompts and code while runs are in flight, and when a plain checkpointed loop is enough.
Read article →Parallel Tool Calls in Agent Loops: Dependency Classification, Partial Failure Semantics and Cancelling Siblings
When a model emits several tool calls in one turn, the runtime decides what runs concurrently and what the model sees when one of them fails. How to classify calls as independent, ordered or conflicting, how to answer every call id, and how cancellation should propagate.
Read article →Agent-Proposed Plans Inside an Existing Saga Orchestrator: Step Catalogues, Pivot Approvals and Who Owns Compensation
How an existing saga orchestrator should admit plans proposed by an AI agent: the agent selects steps from a catalogue, the orchestrator validates the plan, owns every compensation and the pivot step, and asks a human before anything irreversible runs.
Read article →Sizing Tool Results for Agent Context: Budgets, Handles and Summaries Instead of Raw Dumps
A tool-result contract for agents: why raw tool output is the biggest context cost, how to enforce budgets in the tool runtime, return deterministic summaries with artifact handles, compact old results, and test that nothing is silently truncated.
Read article →Agents as Command Senders in CQRS and Event-Sourced Systems: Read Models as Context, Aggregates as the Gate
How an existing CQRS and event-sourced system should admit an AI agent: the agent reads a versioned read model, proposes commands, and the aggregate stays the deterministic gate for invariants, idempotency and approvals.
Read article →Agent Evaluation at Scale
From spot checks to continuous monitoring: trace capture and replay, LLM judges with calibration, drift detection, reliable eval datasets, CI/CD metri…
Read article →Agent-to-Human Handoff Patterns, in depth: triggers, ownership, the context packet, routing and handing back
How to transfer a live conversation from an AI agent to a human without dead air, double replies or re-asking: handoff triggers, an ownership state ma…
Read article →Agent Memory Layers Compared
Working, episodic, semantic — what to persist where. Three tiers of agent memory, from the live context window to long-term facts, and why each tier m…
Read article →Agent Memory Systems, in depth: who controls memory, the service contract, scoping, concurrency and running it in production
The engineering of an agent memory system: agent-directed memory tools versus harness-directed hooks, a memory service API with versions and idempoten…
Read article →Multi-Agent Debate Architecture, in depth: rounds, roles, aggregation, stopping rules and when debate is worth its cost
How multi-agent debate works and how to build it: independent first answers, critique rounds, devil's advocate and judge roles, majority versus j…
Read article →Agent Skill Anti-Patterns: Scope Creep, False Positives, and Prompt Bloat
What actually goes wrong with agent skills in practice: descriptions broad enough to cause false-positive matches, a single skill trying to do too muc…
Read article →Agent Skills Architecture: Decoupling What an Agent Does from How It Runs
Deep-dive on the agent skill pattern: a portable, inert instruction file that decouples an agent's behavior from its runtime, why that decoupling…
Read article →Skill Discovery and Retrieval: How an Agent Runtime Picks the Right Skill
Deep-dive on how an agent runtime matches an incoming request against a catalog of skill description fields: embedding similarity vs. LLM-as-router vs…
Read article →Versioning and Composing Agent Skills Without Breaking the Other 49
Deep-dive on treating agent skills as independently-versioned artifacts: what counts as a breaking change to a skill's trigger conditions or outp…
Read article →Skills vs. Tools vs. Fine-Tuning: Where Each Actually Belongs
A decision framework for choosing between a skill (in-context instructions), a tool (a callable function with a schema), and fine-tuning (a weight-lev…
Read article →Capability Fallback Chains: What an Agent Does When Its Best Tool Isn't Available
Designing explicit fallback chains for agents when a primary tool, model, or skill is unavailable -- specialist tool to generic tool to human -- why s…
Read article →Observability and Tracing for Agentic Systems
Distributed tracing across a multi-step, multi-model agent pipeline: a span per LLM call and per tool call, parent-child relationships across a plan-e…
Read article →Permission Boundaries for Autonomous Agents: Capability Scoping, Not Just Auth
The difference between authenticating an agent and scoping what a specific agent run is allowed to do right now: least-privilege per-task credentials …
Read article →The Skill Registry Pattern for Multi-Agent Fleets
Deep-dive on sharing a common skill catalog across a fleet of agents: central registry versus per-agent local copies, how an agent advertises which sk…
Read article →Testing Agent Skills Before They Reach Production: A Validation Framework
A validation framework for agent skill files specifically: golden-example test sets, regression testing on skill edits, catching the false-positive pr…
Read article →Choosing Your Agentic Stack: A Decision Framework
A practical framework for picking an orchestration framework, memory/vector store, observability tooling, and context/RAG library together as a cohere…
Read article →Context and RAG Tooling for Agents
Comparing LlamaIndex, LangChain, and Haystack as libraries for building an agent's retrieval and context-assembly layer -- what each is actually …
Read article →Memory and Vector Store Options for Agentic Systems
Comparing pgvector, managed vector databases, and self-hosted open-source vector databases for agent memory -- operational trade-offs, and the specifi…
Read article →Observability Tooling for Agents
Comparing purpose-built LLM/agent observability platforms against a custom OpenTelemetry-based tracer -- what each captures, and when off-the-shelf to…
Read article →The Agentic Orchestration Stack Compared
Comparing LangGraph, CrewAI, AutoGen, and Google's ADK by core design philosophy -- explicit state graph vs. role-based crew vs. conversational m…
Read article →Agent checkpointing, in depth: step boundaries, write ordering, idempotent resume, human interrupts and forking
Agent checkpointing in depth: what a checkpoint holds, committing at step boundaries, a storage schema, idempotent side effects, human interrupts, tim…
Read article →Context compaction for long-running agents
Deep-dive on context compaction: keeping a long agent session inside the context window by summarizing settled history rather than truncating it. Cove…
Read article →Context engineering architecture
Deep-dive on context engineering for agents: per-turn token budgets, history windowing and commitment-preserving compaction, tool-result hygiene and a…
Read article →Agent cost optimization -- controlling the token bill
Deep-dive on agent cost optimization: why agents are token-hungry (loops, growing context), the cost drivers, model routing, context management, promp…
Read article →Agent Evaluator Architecture, in depth: the grading contract, state checks before judges, pass^k, and evaluating the evaluator
How to build the component that decides whether an agent run succeeded: the evaluator's input and output contract, grading final environment stat…
Read article →Agent Frameworks, in depth: the six parts every framework implements, a 40-line runtime that shows them, and how to decide what to adopt
What an agent framework actually does: the control loop, model adapter, tool layer, state and checkpoints, orchestration and observability, shown in a…
Read article →Agent guardrails
Deep-dive on agent guardrails: input/output/action/budget control points, deterministic vs LLM-based checks, fail modes (block/warn/escalate), defense…
Read article →Human-in-the-loop -- humans and agents collaborating
Deep-dive on human-in-the-loop agents: approval gates, escalation, review/correction, and confidence-based involvement, interaction patterns (sync/asy…
Read article →Agent memory architecture, in depth: the memory lifecycle of scoring, reconciliation, consolidation, forgetting and safety
Agent memory as a lifecycle rather than a store: the memory record schema, retrieval scoring with relevance, recency and importance, per-kind decay, r…
Read article →Memory Pattern, in depth: short-term thread state and long-term memory as two persistence problems in one agent loop
The agent memory pattern built from first principles: why thread state and long-term memory need different contracts, where each hooks into the agent …
Read article →Multi-Agent Pattern, in depth: when to split one agent into several, topologies, typed contracts and the token arithmetic
An engineer's guide to the multi-agent pattern: what it is, why context isolation is the real benefit, what you lose in shared context, the evide…
Read article →Multi-Agent Orchestration Architecture in Depth
Multi-agent orchestration architecture in depth: choosing a topology, a capability registry with tiered routing, typed handoffs by reference, an owned…
Read article →Agent orchestrator architecture, in depth: task graphs, the scheduler loop, budgets, validation, cancellation and interrupts
How to build the coordinator at the centre of an agent system: a task graph with explicit node states, bounded dynamic planning, a scheduler loop with…
Read article →Agent output verification architecture
Deep-dive on verifying agent outputs before acting: structure, grounding, and policy layers; deterministic rules vs LLM-as-judge; the pass/repair/reje…
Read article →Agent planner architecture
Deep-dive on agent planner architecture: the reflection loop with state store, memory, guardrails, and observability.
Read article →Agent planner v2 architecture, in depth: plan-or-act gating, two-tier plans, budget ledgers, local repair and eval-gated rollout
How to upgrade an LLM agent planner from a single-shot flat plan to a v2 design: a gate that decides whether to plan at all, strategic milestones with…
Read article →Agent Planning Architecture in Depth: choosing between ReAct, plan-and-execute, DAG planners and tree search
Agent planning as search: four strategy families with a cost model, a shared runtime with budgets and verifiers, a worked comparison on one task, a st…
Read article →Agents in Production, in depth: outcome SLOs, versioned behaviour bundles, runtime budgets, release gates, an incident catalogue and the on-call runbook
How to operate LLM agents in production: SLOs defined on outcomes, one versioned and hashed bundle for prompts, models, tools and policies, step, toke…
Read article →ReAct Agent Pattern: The Thought, Action, Observation Loop
How the ReAct agent pattern interleaves reasoning and acting: the thought, action, observation loop, tool grounding, ReAct vs plan-and-execute, loop l…
Read article →Agent Reflection Architecture, in depth: grounded critique, the revise loop controller, stop rules and when reflection makes answers worse
How to build within-episode reflection into an agent: what reflection is and is not, where a trustworthy critique signal comes from, a structured crit…
Read article →Agent request router architecture
Deep-dive on request routing for agent systems: a cheap classifier that scores intent and difficulty, a routing policy that dispatches to a cheap mode…
Read article →Agent tool sandboxing -- containing what agents can do
Deep-dive on agent tool sandboxing: the untrusted-agent threat (LLM-driven, prompt-injectable), sandboxing tool execution, isolation levels (process/c…
Read article →Agent semantic cache architecture
Deep-dive on semantic caching for LLM agents: embedding-based nearest-neighbor lookup, the similarity threshold as the precision/hit-rate dial, scope …
Read article →Speculative tool execution for agents
Deep-dive on speculative tool execution in LLM agents: predicting the next tool call, running read-only tools eagerly in a sandbox, committing on a ma…
Read article →Agent state machine architecture
Deep-dive on modeling an LLM agent as an explicit finite state machine: named states (intake, plan, act, observe, verify, respond, escalate, error) wi…
Read article →Agent task decomposition
Deep-dive on agent task decomposition: a decomposer that plans subtasks and dependencies, a scheduler that releases the ready set and exploits paralle…
Read article →Agent tool-call recovery architecture
Deep-dive on making agent tool calls robust: an error taxonomy (transient / invalid-input / permanent), idempotency keys for safe replay, exponential …
Read article →Agent tool schema versioning architecture
Deep-dive on versioning agent tool schemas: why a schema is a prompt not an API contract, immutable versioned registries, compatibility classification…
Read article →Tool selection architecture
Deep-dive on dynamic tool selection (tool retrieval) for agents whose catalog has grown to hundreds or thousands of tools, where listing them all in t…
Read article →Agent tool use architecture, in depth: registry, policy gate, parallel dispatch and result shaping
How an agent runtime turns model tool calls into safe, bounded actions: the registry, choosing which tools to expose, validation and a policy gate, pa…
Read article →Tools Pattern, in depth: the six shapes a tool can take, a framework-neutral tool layer, middleware composition, jobs, agents and humans behind the same interface, and how to expose it all over MCP
A framework-neutral guide to the tools pattern for agents: the contract between model and runtime, six tool shapes (query, command, job, handle, agent…
Read article →Typed Decisions in Agent Pipelines: Routing, Moderation and Extraction with a Schema-Constrained Decision Model such as Jev
Implementing an agent's tool selection, moderation of inputs, tool results and outputs, and argument extraction as typed Choice, Score and Noul q…
Read article →Durable Agent Workflows with State, Retries, and Replay
How durable execution makes long-running agents survive crashes, deploys and multi-day human waits: deterministic orchestration versus activities, wha…
Read article →Human Approval Gates in Autonomous Agent Systems
How to build approval gates an agent cannot talk its way past: enforcement in the tool executor, approvals bound to a digest of the exact action, revi…
Read article →LangGraph for Agent Orchestration, in depth: state and reducers, routing with Command and Send, checkpoints, interrupts and failure modes
How LangGraph actually executes an agent: typed state with reducers, super-steps, conditional edges, Command and Send for routing and fan-out, thread-…
Read article →Memory Architectures for Long-Running AI Agents
How to give an agent that works for hours or days a task memory it can trust: a ledger, a decision log, a fact store with provenance and supersession,…
Read article →Multi-Agent Collaboration & Negotiation: Orchestrating Collective Intelligence
Multi-agent collaboration and negotiation in depth: the Contract Net Protocol, second-price auctions, alternating-offer bargaining, joint commitments,…
Read article →Multi-Agent Communication Protocols: The Language of Collaboration, in depth: envelopes, speech acts, interaction protocols and delivery guarantees
How agents should talk: the transport, envelope and interaction layers, FIPA-style performatives, request and contract-net state machines, idempotent …
Read article →Multi-Agent Systems: What Happens When a 'Developer' LLM Talks to a 'Reviewer' LLM?
Individual AI agents, equipped with planning capabilities and tool-use (as discussed in previous articles), are remarkably powerful.
Read article →ReAct Pattern Explained, in depth: building the Thought-Action-Observation loop from scratch, parsing, native tool calling, guards and failure modes
A hands-on guide to the ReAct agent pattern: what the original paper tested and found, a worked trace, a from-scratch text-protocol implementation wit…
Read article →ReAct Pattern Revisited, in depth: native and parallel tool calls, reasoning models, the token economics of the loop and when a workflow should replace it
ReAct four years on: what survived from the text Thought-Action-Observation format, how native and parallel tool calls and reasoning models change the…
Read article →Sandboxing Code-Executing Agents with Policy Boundaries
How to turn a sandbox for agent-written code into an enforceable policy: derive a per-task policy outside the model, compile it into container flags, …
Read article →Deploying Agentic Systems
System design for running autonomous agents in production: sandboxing execution, why minutes-long agent runs break normal request-response autoscaling…
Read article →Cost and Latency Budgets for LLM Products
A system design framework for budgeting cost and latency across an LLM product before building it: decomposing end-to-end latency and cost-per-request…
Read article →LLM Gateway Architecture
System design for the infrastructure layer between applications and LLM providers: request routing by cost/latency/capability, rate-limit pooling acro…
Read article →Designing a RAG Pipeline at Scale
System design for a production RAG pipeline: ingestion and chunking trade-offs, embedding generation and batching, the index write path, retrieval and…
Read article →Vector Search Infrastructure
System design for vector search at scale: index-type trade-offs (HNSW vs IVF vs flat), sharding an index across nodes, recall versus latency versus me…
Read article →The Rise of 'Thinking' Models: How Chain-of-Thought (CoT) Is Turning LLMs into Logic Engines
Large Language Models (LLMs) have captivated the world with their ability to generate fluent, coherent, and often creative text.
Read article →Tool Calling Best Practices, in depth: designing the tool surface a model sees, from granularity and names to schemas, error messages, return payloads and evals
How to design tools that language models call correctly: choosing tool granularity, naming and namespacing, writing descriptions, constraining input s…
Read article →Tool-Calling Reliability: Timeouts, Idempotency, and Compensation
How to make an agent's tool calls safe when they time out: treat the unknown outcome as a first-class result, propagate deadlines from the turn b…
Read article →Tool Use Failure Modes, in depth: a taxonomy you can detect in traces, measure in evals and fix at the right layer
A practical taxonomy of how LLM agents fail at tool use: skipped calls, wrong tools, invented and ungrounded arguments, bad sequencing, misread result…
Read article →