#agents
30 articles
Sandboxing AI Agents: Containers, gVisor, and MicroVMs
Sandboxing AI agents with containers, gVisor, Firecracker microVMs, and Wasm: honest boot and overhead numbers, and why egress filtering matters most.
Code Mode: why agents write code instead of calling tools
Why agents that write code against tool APIs beat JSON tool calling: the 150K-to-2K token math, a worked before/after, and when direct calls still win.
Agent Skills: packaging expertise as files, not code
How Agent Skills use progressive disclosure to load expertise on demand — the SKILL.md format, real token math, and when to pick skills over MCP.
How AI coding assistants work
The engineering behind Copilot, Cursor, and Claude Code: repo maps, tree-sitter indexing, edit formats, long-file strategies, and how to evaluate code generation properly.
Computer Use and GUI Agents: Screenshot Loops, Grounding, and Why It Is Hard
How GUI agents see screens, decide actions, and click their way through UIs — the grounding problem, safety architecture, and why computer use agents fail in production.
Text-to-SQL and Structured Data Retrieval
How to build production text-to-SQL systems: schema injection, SQL generation, execution sandboxing, error-retry loops, and NL-to-Cypher for graph databases.
Indirect Prompt Injection: The Attack Hiding in Your Data
How attackers embed instructions inside documents, emails, and tool outputs that your LLM retrieves and obeys — and the defenses that actually reduce the blast radius.
Concurrency in Agent Systems: Parallel Tools, Fan-Out, and Rate Limits
How to run agent tool calls in parallel, design fan-out/join patterns, schedule around provider rate limits, and cancel in-flight work without corrupting state.
Agent Memory Architectures: Episodic, Semantic, Procedural
How production agents store and recall knowledge across sessions — episodic logs, semantic stores, procedural caches, and sane forgetting policies.
Agent Evaluation: Trajectories, Tool Calls, and Multi-Step Correctness
End-to-end task success is not enough for agents. Learn to evaluate at three levels: outcome, trajectory soundness, and per-component correctness — with code.
Agent Evaluation and Why Agents Fail in Production
Why 85% of agent pilots never reach production scale — compounding error rates, LLM-judge bias, and the six evaluation layers that catch what offline tests miss.
Agentic RAG: When Retrieval Becomes a Reasoning Loop
Agentic RAG swaps single-shot retrieval for a decision loop — retrieve, judge, rewrite, repeat. The patterns, failure modes, and when it pays off.
Agentic AI security: MCP tool poisoning, excessive agency, and the new attack surface
Why giving LLMs tool access fundamentally changes the threat model — MCP tool poisoning, excessive agency, and defense patterns for production agents in 2026.
Reasoning models plus tools: agentic workflows and function calling
How o3, o4-mini, and Claude extended thinking combine reasoning with tool calls to make harder agent tasks tractable — and the failure modes they introduce.
Model Context Protocol: The USB-C for AI Agents
How MCP standardizes tool integration for AI agents — the client-server protocol, why OpenAI and Microsoft adopted it, tool schema pitfalls, and security risks you cannot ignore.
Building Reliable Tool-Using Systems: Patterns From Production
Production patterns for reliable LLM tool use: loop budgeting, validation layers, idempotency, fallbacks, and observability that prevent runaway agents.
Context window management for agents: select, compress, isolate
How to keep agents from degrading when the context fills up — retrieval-based selection, compression strategies, multi-agent isolation, and the numbers behind each choice.
Multi-Agent Orchestration: Patterns That Survive Production
Six orchestration topologies for multi-agent systems — from orchestrator-worker to swarm and adaptive planning — with real failure rates and cost math.
The tool-use round trip: agentic loops, stop reasons, and parallel calls
How the model-to-application protocol works: stop reasons, parallel tool_use blocks, context rot, and loop budgeting that keeps production agents alive.
Agent Memory: From Context Window to Persistent Knowledge
How agents remember things across tool calls, sessions, and deployments — in-context working memory, episodic stores, semantic vector DBs, and when each breaks.
Designing Tool Schemas That Models Actually Understand
How to write tool names, descriptions, and parameter schemas that prevent wrong tool selection, hallucinated arguments, and silent agent failures in production.
OWASP LLM Top 10 (2025 Edition): A Practitioner's Walkthrough
A concrete, example-driven tour of all ten OWASP LLM risks for 2025, with real exploit scenarios, mitigations, and production trade-offs for each threat.
ReAct, Reflexion, and Planning Patterns
How ReAct, Reflexion, Plan-and-Execute, and LATS differ as agent planning strategies — with honest benchmarks, failure modes, and a decision framework for production.
Prompt Injection and Jailbreaks: Anatomy of the Number One LLM Threat
How direct, indirect, and multimodal prompt injection attacks work in 2026 — and the five-layer defense architecture that actually reduces them in production.
The Agent Loop: How LLMs Become Actors
The perceive→reason→act→observe cycle that turns a static LLM call into an autonomous process — plus the hard-stop guardrails that keep it from spinning forever.
Tool and function calling: the LLM's hands
How LLMs invoke external tools via structured JSON — the protocol, the round-trip mechanics, schema design basics, and the failure modes that bite in production.
From Prompt Engineering to Context Engineering: What Actually Changed
Why writing clever prompts is the wrong mental model for 2025 LLM systems, and how the context-window-as-RAM framing changes what you build.
Context Engineering: Filling the Window Right
The shift from prompt to context engineering: how to write, select, compress, and isolate what goes in the window — and the silent failure modes that ship to production.
Your First Production Agent
Build a real agent from scratch: the reason-act-observe loop, function calling mechanics, tool design rules, token budgets, and why 95% per-step accuracy collapses over 10 steps.
Guardrails and Security: Production Is an Attack Surface
Prompt injection, jailbreaks, OWASP LLM Top 10, and the layered controls that actually reduce blast radius in production AI systems.