#tool-use
22 articles
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.
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.
Structured Data Extraction with LLMs
How to turn unstructured documents into typed, validated records using Pydantic AI and instructor — the entity extraction patterns that actually hold in production.
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.
Structured Outputs and Constrained Decoding: Guaranteeing Parseable JSON
How strict mode and grammar-constrained decoding actually guarantee parseable JSON — token masking, FSMs, xGrammar, and the validation layer you still need.
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.
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.
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.
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.
JSON Mode vs Structured Outputs vs Tool Calling: What Actually Differs
Three APIs that all return JSON but with very different guarantees. Understand when each breaks, what they cost, and which to reach for 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.
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.