Field notes · 2026

Defining well-performingagentic systems — one experiment at a time.

Practical essays on designing, evaluating and tuning meta harnesses for LLM agents.

ScaffoldsEvalsPromptsTool policyLoop architecture

Filter

Agent Tool Authorization: Discovery Is Not Permission

Design agent tool authorization around each effect, not a cached tool list. Bound delegated scopes, enforce revocation, and recheck long-running sessions.

8 min read

Agent Cancellation: What Stop Can Actually Promise

Design agent cancellation around durable intent, blocked dispatch, and effect reconciliation. Show what stopped, what completed, and what stays uncertain.

8 min read

Agent Evaluation Uncertainty: When Not to Ship

Measure agent evaluation uncertainty at the task level. Separate repeated trials from evidence, compare releases in pairs, and keep inconclusive verdicts.

8 min read

Agent Memory Poisoning: Guard the Write Path

Prevent agent memory poisoning with write admission, source provenance, correction chains, and quarantine. Keep retrieved claims from becoming authority.

8 min read

Agent Tool Schema Versioning: Catch Silent Breaks

Use agent tool schema versioning to catch silent changes in defaults, units, outputs, and authority. Test migrations and keep rollback tied to effects.

8 min read

Agent Concurrency Control: Stop Stale Workers

Build agent concurrency control with revision checks, leases, and fencing. Reject stale workers at the write boundary and test races before they hit users.

9 min read

Agent Evaluation Graders: Audit the Passing Score

Audit agent evaluation graders before trusting a passing score. Separate state checks from model judgment, calibrate false passes, and version each rubric.

8 min read

Agent Memory Retrieval: A Match Is Not Evidence

Design agent memory retrieval around provenance, freshness, and conflicts. Verify sources before acting, and abstain when recall cannot support a claim.

8 min read

Production Agent Architecture: Four Boundaries That Matter

Build production agent architecture around queues, durable state, scoped executors, and verifiers that distinguish a finished attempt from a verified task.

8 min read

Agent Context Window Management: Keep the Evidence

Agent context window management preserves evidence across compaction. Set budgets, retain references, and rehydrate facts before consequential actions.

9 min read

Agent Evaluation Dataset Design: Test What Can Fail

Build agent evaluation datasets around evidence and failure boundaries. Separate difficulty from noise, prevent leakage, and test shortcuts before release.

8 min read

Agent Recovery Checkpoints: Resume Without Repeating

Build agent recovery checkpoints that preserve intent, reconcile uncertain effects, and revalidate authority before interrupted work resumes after a crash.

8 min read

Agent Guardrails: Red-Team the Boundary, Not the Reply

Test agent guardrails against forbidden effects, not reassuring replies. Build replayable attacks, verify state, and keep legitimate tasks in test suites.

7 min read

AI Agent Cost Optimization: Cut Overhead, Keep Outcomes

AI agent cost optimization cuts repeated context and tool overhead while preserving verified outcomes. Measure savings at the task boundary, not per call.

8 min read

Multi-Agent Failure Modes: Who Owns the Final Write?

Catch multi-agent failure modes at handoffs: reject stale results, resolve state conflicts, and give final writes one owner with a checked recovery path.

7 min read

Agent Tool Call Errors: Know What Failed Before Retrying

Handle agent tool call errors by separating invalid requests, execution failures, and unknown outcomes. Recover safely without repeating external effects.

7 min read

Multi-Agent Orchestration: When Two Agents Beat One

Design multi-agent orchestration with independent tasks, evidence-backed handoffs, and one owner of final effects; weigh gains against coordination cost.

6 min read

Agent Framework Comparison: Evaluate the Harness

An agent framework comparison should evaluate the harness surface: state, tools, control flow, observability, and safe promotion—not feature counts.

8 min read

Agent Regression Gates: Make Failures Release Blockers

Agent regression gates turn known failures into release blockers, so every repaired incident becomes a durable test before the next deployment.

8 min read

Agent Sandboxes and Blast Radius: Design for Recovery

Agent sandboxes limit permissions, isolate side effects, and make recovery explicit so a bad run stops locally instead of becoming an incident.

8 min read

MCP and the Tool-Protocol Wars

MCP is useful when it makes tool boundaries explicit. The real tool-protocol decision is how you preserve authority, schemas, observability, and change control.

8 min read

Human-in-the-Loop Agent Escalation Design

Human-in-the-loop escalation design gives agents clear stop rules, useful handoffs, bounded authority, and a path to learn from review.

8 min read

Cost per Completed Task: The Agent Metric That Matters

Cost per completed task turns agent spend into an operational metric: include retries, human review, failures, and the price of making work right.

8 min read

Memory Architectures for Long-Running Agents

Long-running agents need memory outside the context window. Design working, episodic, semantic, and procedural memory with retrieval and expiry.

8 min read

Idempotency for Agents: Safe Reruns by Design

Agents retry, resume, and get interrupted. Idempotency makes those reruns safe: same intent, one durable outcome, and an audit trail.

8 min read

Agent Retry Policies: Diversify, Don't Repeat

An agent retry with the same prompt and same context produces the same failure. Diversified retry policies turn repeated failures into forward progress.

7 min read

The Verifier Spectrum: From Schema to Ground Truth

Agent verification lives on a spectrum from cheap schema checks to expensive ground-truth comparison. The art is matching the verifier to the risk at each step.

8 min read

Model Swap Drill: What Breaks When You Upgrade Your Agent

A model swap breaks agents in predictable ways: tool-call formats drift, stop conditions change, costs spike. Here's the drill to run before you deploy.

8 min read

Agent Observability: What to Log and What to Ignore

Most agent logs are noise. The signal lives in tool calls, decision boundaries, and failure traces. Here is what to record, what to throw away, and why.

7 min read

Tool Design for Agents: Few, Sharp, Validated

The tool surface is the agent's API to reality. Design LLM agent tools that are hard to misuse: small surfaces, strict schemas, scoped permissions.

8 min read