Tag
Split 1 agent into several and you inherit a new question: who decides what runs next? Handoffs are tool calls underneath, supervisors and swarms differ only in whether control returns to a center, and the coordination overhead runs about 15 times a chat in tokens.
A search tool turns post-cutoff questions from hallucination bait into retrievable facts, and it brings 3 problems with it: choosing sources, paying for pages that become tokens, and reading text that may be aimed at the model rather than the user. This is the wiring guide: the
Same model, same tools, same prompt, 2 different machines: one answers when you type, the other triages your inbox at 6am and escalates what it couldn't handle. The difference is supervision, and removing it changes everything: latency stops mattering, durable state starts, and
A text-to-SQL agent turns 'how many customers churned?' into a real query against a real database. The models are good enough to try this in 2026, but accuracy is mostly a schema problem and safety is entirely a database problem. This is the loop that makes generation reliable,
Classic RAG runs 1 fixed retrieval pass and hopes the chunks are right. Agentic RAG puts a model in charge of the search itself: rewriting queries, grading what came back, and retrying until the evidence covers the question. This is the mechanism behind the loop, the modeled 2
Naming a document is not the same as quoting it. This is the mechanism behind a real inline citation, the specific difference between a citation that is correct and one that is faithful, and why a confidently-wrong citation does more damage than an honest gap. Citations reduce
The tool you pick is not what decides the risk, the autonomy level is. This is a tool-agnostic, 4-level framework for how much a coding agent should actually be allowed to do, from a diff that waits for your approval to a merge and deploy with no human step at all, grounded in
Prompt engineering wrote the instructions. Context engineering decides what an agent actually sees on any given turn: which tools stay in scope, which documents survive the cut, and when a long run needs to compact its own history or spin off a sub-agent instead of dragging
Real production traces are the best eval data you can get, and most teams do not have enough of them yet. Here is the concrete mechanism for generating a synthetic eval set from a handful of real examples, plus the honest failure modes: data that drifts from what real users do,
OCR-then-parse converts a page to text outside the model, so a language model only ever sees what the OCR engine decided to keep. A vision-language model reads the page itself, pixels and text together, which is why it can answer a question about a specific box on the page while
Installing a community MCP server means running someone else's code with your credentials, and nothing resembling an app-store review checks it first. Here is what the research and the official spec actually document about tool poisoning, supply-chain risk, confused-deputy
When an agent calls a tool on a user's behalf, most systems today can only see the agent, not the person. Here is what RFC 8693 token exchange and the newly shipped ID-JAG pattern actually do about that, and why a single shared credential stops working the moment more than one
A long-running agent that crashes at hour 6 either starts over from zero or resumes from its last checkpoint, depending on whether you built it with durable execution. Here is what checkpointing and replay actually do, how Temporal, Inngest, DBOS, and Restate differ, and what it
Realtime voice AI agents split into 2 real architectures: a cascaded pipeline of 3 chained models, or a single native speech-to-speech model. This piece grounds the tradeoff in OpenAI, Google, and Amazon's own documented specifics, not vendor marketing.
An AI agent with real tool access is only as safe as its weakest credential and its execution boundary. This post covers the containment half of agent security: scoping every tool to its own narrow credential instead of one shared key, and running anything that executes code
Browser agents and computer-use agents both drive real interfaces, but they read the page in completely different ways: one asks the browser for a structured list of elements, the other looks at a screenshot and guesses. That difference is why a DOM-aware browser agent is
Long-horizon AI agents don't fail because they run out of context. Andon Labs' Vending-Bench found no correlation between failed runs and how full the context window was. Here is what the verified research says about why agents actually drift on long runs, and the
An LLM judge can pass 80%+ agreement with human raters and still lie to you in specific, documented ways: non-deterministic scores, self-preference bias, leniency, and overfitting to the judge itself. Here is what independently-verified research says about each pitfall, and the
The Model Context Protocol's 2026-07-28 revision is at release candidate now. It makes the core stateless, aligns authorization with OAuth 2.1 and OpenID Connect, and reports about six breaking changes production servers must handle first. Here is what it means if you ship
Computer-use agents, which read the screen and drive mouse and keyboard, went from demo to shipping feature in 2026, and Meta's Muse Spark 1.1 made it a headline capability. Here is what they automate, where they break, and the guardrails that keep them safe.
