Topic · 23 articles

AI Agents

November 20264

  • Durable Execution for Agents: Surviving Restarts Mid-Task

    Checkpointing, idempotency keys and replay — what Temporal-style durability gives an agent that a retry loop cannot. The determinism rules that make ordinary Python illegal inside a workflow, why uuid4() is the wrong idempotency key, the 51,200-event ceiling that collides with your context budget, and the framework defaults that quietly hand the guarantee back.

    Series · Part 2610 min readAI EngineeringAI AgentsReliability
  • Human-in-the-Loop: Designing the Approval Boundary

    Which actions need a human, how to pause a running agent without losing its state, and why confirming everything trains people to click yes. The approval boundary is a claim about reversibility and blast radius, and the blast radius lives in the arguments, not the tool name. Includes the resume bug every framework has, and the aviation data that explains why your gate stops working in week three.

    Series · Part 259 min readAI EngineeringAI AgentsArchitecture
  • ReAct, Plan-and-Execute, and Reflexion: Planning Loops Compared

    The three planning loops differ on one question: where does the plan live? ReAct holds a plan one step long, replans for free, and gets stuck. Plan-and-Execute commits to a graph up front, which buys parallelism and a cheaper executor and goes stale the moment reality disagrees. Reflexion wraps whole attempts in an outer loop and quietly depends on an oracle you probably do not have. Here is what each costs, with the numbers.

    Series · Part 2410 min readAI EngineeringAI AgentsPlanning
  • Compaction: Keeping Long-Running Agents Coherent

    Compaction is lossy compression and you are choosing the loss function. Anthropic's own probe of a compacted transcript recovered 3 of 3 high-level facts and 0 of 3 specific numbers — which is exactly what summarization is supposed to do, and exactly how an agent forgets the constraint it was given forty turns ago.

    Series · Part 199 min readAI EngineeringAI AgentsContext Engineering

September 202614

  • RAG or Tool Calling? Stop Retrieving What You Could Query

    Vector search over data you could have queried with SQL is the most common architecture smell in agent systems. It is slower, less accurate, more expensive to maintain, and it fails in a way that is hard to detect. Here is the decision rule.

    Series · Part 169 min readAI EngineeringRAGAI Agents
  • Budgeting the Context Window: A Token Accounting Method

    Split the window into fixed, retrieved and conversational budgets, put real numbers against each, and enforce them. The arithmetic is simple and almost nobody does it — which is why so many agents degrade at turn fifteen for reasons the team cannot name.

    Series · Part 158 min readAI EngineeringAI AgentsContext Engineering
  • Context Engineering: The Discipline That Replaced Prompt Engineering

    Once an agent has tools, memory and retrieval, the job stops being how you word the instruction and becomes what occupies the window on every turn. That is a different skill, with different failure modes, and it is the one production work actually demands.

    Series · Part 149 min readAI EngineeringAI AgentsContext Engineering
  • Role-Based Multi-Agent Frameworks: What They Get Right, and the AutoGen Lesson

    Assigning agents roles and letting them converse is a genuinely useful abstraction for some problems and a determinism disaster for others. Meanwhile the most-cited framework in the category went into maintenance mode this year, which is its own lesson about what to depend on.

    Series · Part 119 min readAI EngineeringAI AgentsMulti-Agent
  • OpenAI Agents SDK vs LangGraph vs Google ADK: Choosing by Constraint

    Feature tables do not help, because all three do the same core thing. What separates them is four constraints — where state lives, where it deploys, what you can see when it breaks, and what your team already knows. Pick on those and the choice makes itself.

    Series · Part 1010 min readAI EngineeringAI AgentsFrameworks
  • 'NoneType' object is not subscriptable: The cloudpickle Bug That Eats Agent Deploys

    A postmortem. The deploy succeeds, the agent goes live, and every query returns nothing — or a type error from deep inside a framework you did not write. The cause is a serialisation boundary nobody told you existed, and the fix is two lines.

    Series · Part 99 min readAI EngineeringAI AgentsDebugging
  • Deploying to Vertex AI Agent Engine: The Guide the Docs Skip

    Agent Engine will host your agent without you writing a server, managing sessions, or provisioning anything. Getting there means understanding four things the documentation mentions in passing and that account for most failed first deploys.

    Series · Part 811 min readAI EngineeringAI AgentsVertex AI
  • Google ADK Tutorial: From Zero to a Deployed Agent

    The Agent Development Kit quickstart gets you a working agent in twenty lines. It also leaves out every decision that matters once the project is real — session state, tool ergonomics, and the deployment boundary that decides whether your agent runs at all.

    Series · Part 710 min readAI EngineeringAI AgentsGoogle ADK
  • When Not to Build an Agent (A Decision Tree)

    A large share of agent projects should have been a workflow, a retrieval endpoint, or a scheduled job. The tell is usually visible in week one and ignored until month three. Here is how to check before you commit a quarter to it.

    Series · Part 67 min readAI EngineeringAI AgentsArchitecture
  • System Prompt Architecture: Role, Rules, Tools, and Escape Hatches

    An agent's system prompt is not a paragraph of encouragement. It is the only place you get to specify behaviour that holds across every turn, every tool result, and every input a user throws at it. Four blocks, in a fixed order, and one of them is the block nobody writes.

    Series · Part 58 min readAI EngineeringAI AgentsPrompt Engineering
  • Structured Output: JSON Mode, Tool Calling, or Grammar Constraints?

    Three mechanisms will force a model to return a schema, and teams pick between them by habit rather than by fit. They differ in guarantee strength, in latency, and in one under-discussed way: the strictest option can quietly make the content worse even as the format gets perfect.

    Series · Part 49 min readAI EngineeringAI AgentsStructured Output
  • Never Raise: Error Handling Patterns for Agent Tools

    In ordinary code an exception is a signal to a developer. In an agent, an uncaught exception kills the turn and throws away everything the model has figured out. The tool contract that makes agents recover instead of collapse is one rule long — and it changes how you write every tool.

    Series · Part 38 min readAI EngineeringAI AgentsReliability
  • Tool Schemas Models Actually Call: The Description Is the Prompt

    Most agent failures that look like reasoning failures are tool-selection failures. The model picked the wrong function, or invented arguments, or did not realise a tool applied. Almost all of it is fixable in the schema — and the schema is prompt engineering, not API plumbing.

    Series · Part 28 min readAI EngineeringAI AgentsTool Use
  • Write the Agent Loop Yourself: 80 Lines, No Framework

    Every agent framework you will ever use is a wrapper around one while loop. Build that loop by hand once — with real tool dispatch, a stop condition, and a turn budget — and the frameworks stop being magic. This is the version you can debug at 2am.

    Series · Part 19 min readAI EngineeringAI AgentsTutorial

August 20265

  • AI Agent Memory Architectures: Short-Term, Long-Term, and Checkpointing — What Interviews Actually Test

    Every agent demo dies the same death in production: it forgets. Context windows overflow, sessions end, processes crash. Designing agent memory — working context, episodic recall, durable checkpoints — is now a standard AI system design interview topic. Here is the architecture, layer by layer.

    10 min readAI EngineeringAI AgentsLangGraph
  • MCP vs A2A: The Two Protocols in Every 2026 Agent Stack, Explained

    Model Context Protocol connects one agent to its tools. Agent2Agent connects agents to each other. Interviewers increasingly expect you to know which layer each one owns, what breaks without them, and how they compose in a real architecture. Here is the comparison nobody has written clearly.

    9 min readAI EngineeringAI AgentsMCP
  • Google's Agent2Agent (A2A) Protocol, Explained: How AI Agents Talk to Each Other

    MCP standardized how a single agent talks to tools and data. A2A standardizes how separate agents — possibly built on completely different frameworks — discover each other and delegate work. Here is what the protocol actually contains and why interviewers are starting to ask about it.

    8 min readAI EngineeringAI AgentsAgent2Agent
  • LangGraph Tutorial: Building Stateful, Multi-Step AI Agent Workflows (Free)

    Plain LangChain chains run in a straight line. Real agents loop, branch, and retry. LangGraph models an agent as an explicit graph with shared state — here is how the core pieces fit together, with a minimal worked example.

    9 min readAI EngineeringLangGraphTutorial
  • LangChain Tutorial: Building Your First AI Agent (Free, Step-by-Step)

    LangChain gets a reputation for being over-abstracted, but the core ideas — chains, tools, memory, retrieval — are straightforward once you see them without the framework jargon. This is a free, from-scratch walkthrough of all four.

    9 min readAI EngineeringLangChainTutorial