Concepts
Core concepts and patterns for building AI agents, with prose explanations and code examples.
How coding agents automate the entire LLM fine-tuning workflow from GPU selection to model deployment using natural language instructions.
Beyond simple retrieve-then-generate: intelligent agents that decide when, what, and how to retrieve, then critique and correct their own retrieval.
How AI agents improve over time without retraining: token-space learning from successful trajectories, Reflexion self-critique, and self-evolving architectures.
Patterns and frameworks for coordinating multiple specialized AI agents including supervisor, peer-to-peer, debate, and mixture of experts.
A filesystem-based approach to tool management that achieves 98% token savings by loading tool definitions on-demand rather than sending all tools on every request.
How agents use code execution to filter retrieved web content before it enters the context window, improving accuracy and reducing token costs.
How agents can execute tool calls inside a sandboxed code environment to reduce round-trip latency and token overhead in multi-step workflows.
How to architect autonomous AI agents that find, validate, and triage security vulnerabilities in real codebases using sandboxed tool access and multi-stage reasoning.
How to design multi-agent research systems using a planner that generates dynamic parallel tasks and an observer that maintains global context across all agents.
How AI agents are becoming first-class participants on the internet — browsing autonomously, transacting on behalf of users, and communicating with other agents through emerging protocols and standards.
The two-tier architecture for one-person engineering teams: an AI orchestrator with business context managing a fleet of specialized coding agents.
How to architect a production deep-research multi-agent system using a planner, parallel task workers, and a context-aware observer—with structured output and progressive content retrieval.
How to use lifecycle hooks to inspect, modify, and gate agent behavior at precise points during execution — from tool calls to session boundaries.
How separating environment learning from task execution lets agents replace O(N) step-by-step reasoning with O(1) program synthesis over a persistent state-machine graph.
How integrating Theory of Mind and BDI-style belief structures into multi-agent LLM architectures enables agents to reason about each other's mental states and coordinate more reliably.
How to model multi-step LLM agent pipelines as noisy processes and apply progressive denoising—uncertainty sensing, compute regulation, and root-cause correction—to build more reliable workflows.
How to protect shared agent memory from poisoning attacks using Bayesian trust models, local-first storage, and adaptive ranking.
How iterative failure analysis and Pareto-frontier selection can automatically grow and prune an agent's skill library without human curation.
How to architect multi-agent systems with a dedicated Safety Oracle that enforces explicit risk policies independent of the decision-making agent.
How to architect multi-agent systems with role-based tool isolation, governed supervisor-worker hierarchies, and composable stateful skill graphs for reliable, auditable task execution.
How meta-reinforcement learning frameworks teach LLM agents to balance trying new strategies against exploiting what already works across multiple interaction episodes.
How coding agents drift away from explicit system-prompt constraints over time, why value conflicts accelerate that drift, and what engineers can do about it.
How autonomous LLM agent populations develop spontaneous role specialization, communication norms, and coordination patterns without centralized orchestration.
How errors propagate through LLM-based multi-agent pipelines, the vulnerability classes that amplify them, and governance patterns engineers can use to contain the damage.
How a supervisor-worker hierarchy combined with stateful skill graphs and human-in-the-loop checkpoints produces agents that are both flexible and trustworthy in production.
How language models systematically evaluate their own outputs as safer and more correct than identical outputs from users—and what this means for agent self-monitoring.
How sensitive information compounds across agent hops in sequential LLM pipelines, and what engineers can do to measure and control it.
How to expose formal PDDL planning operations as LLM tool calls through MCP, giving agents a structured, verifiable planning substrate for complex multi-step tasks.
A practical guide to choosing between hierarchical, adversarial, and collaborative multi-agent LLM topologies, with engineering tradeoffs drawn from diagnostic accuracy benchmarks.
How making retrieval quality assessment an explicit agent action—rather than an implicit assumption—improves multi-hop reasoning and enables process-level reward shaping for RAG agents.
How to intercept and verify agent actions before they execute, reducing harmful outputs without blocking the agent's operational loop.
How to build AI agents that persist their memory, move across machines, and maintain context regardless of where they execute — covering state serialization, remote sandboxing, and human-in-the-loop approval patterns.
How performance degrades within supported context limits, and practical strategies to detect, measure, and mitigate both failure modes.
The discipline of optimizing what enters the context window — a key skill for practitioners building reliable agents alongside prompt engineering.
Reduce inference costs by 90% and time-to-first-token by 80% by reusing computed attention states across requests with identical prefixes.
An examination of Context Language Models, a University of Washington and Meta proposal that exposes an agent's live context as an editable file, and what it changes about compaction, caching, and training.
Measuring agent performance across component accuracy, task completion, trajectory quality, and system-level metrics with benchmarks and LLM-as-judge.
A look at Context-Bench, Letta's benchmark for measuring how well language models perform context engineering tasks including filesystem traversal and dynamic skill loading.
How to apply automated hierarchical clustering and LLM-driven summarization to production agent traces to surface failure modes, usage patterns, and behavioral trends without manual review.
How to instrument, trace, and evaluate AI agents running in production, where non-deterministic behavior and infinite input spaces make traditional APM tools insufficient.
A framework of twelve metrics across four dimensions — consistency, robustness, predictability, and safety — for evaluating how AI agents actually behave in production.
How to design layered evaluation strategies for long-horizon AI agents using single-step interrupts, full-turn assertions, and multi-turn simulations.
How the Communication-Reasoning Gap exposes a critical failure mode in multi-agent LLM systems—and what engineers can do about it.
How to apply a Summarize–Identify–Report pipeline with specialized sub-agents to compress, diagnose, and act on agentic execution traces at scale.
How to design evaluation suites, run benchmarks, and tune trigger descriptions to keep agent skills working correctly as models and workflows evolve.
A practical framework for isolating whether your memory-augmented agent is failing at retrieval or at using what it retrieves — and what to do about it.
How Social Perception-Driven Data Generation creates more realistic and challenging benchmarks for agentic systems by grounding tasks in actual user needs.
How to apply behavioral fingerprinting and statistical decision procedures to catch workflow regressions in AI agents without burning your token budget.
How to frame agent selection as a structured recommendation problem, and what a rigorous benchmark for that task looks like.
How to treat agent selection as a recommendation problem, and what engineers need to know to build systems that route tasks to the right LLM agent automatically.
Reasoning models show much weaker control over their chains of thought than over their final outputs—undermining the assumption that CoT traces reliably reflect what a model is doing.
How to build document-level factuality verification agents for deep research outputs, and why benchmark labels need to be explicitly revisable.
How graph-based environment evolution frameworks let you build agent benchmarks that stay challenging and realistic as the underlying world changes.
How to evaluate entire agentic systems—framework, model, and orchestration together—rather than treating model choice as the only variable that matters.
How agents maintain context, learn from past interactions, and build persistent knowledge across sessions using layered memory architectures.
Reasoning plus Acting — the foundational loop that enables AI agents to think through problems and take targeted action in the world.
The bridge between language models and real-world actions, enabling agents to query APIs, execute code, and interact with external systems.
How formalizing LLM calls as typed semantic transformations with algebraic composition operators produces more predictable, debuggable, and maintainable agentic data workflows.
A practical guide to designing agents that return typed, validated structured data using provider-native and tool-calling strategies.
How to build low-overhead jailbreak and harmful-content detectors by repurposing the internal activations of your existing model instead of running a separate classifier.
A practical guide to the streaming modes available in agent graph frameworks, covering state updates, LLM token streams, tool lifecycle events, and subgraph outputs.
How a dedicated runtime infrastructure layer can observe, reason over, and intervene in agent behavior to optimize latency, token efficiency, reliability, and safety without touching the model or application code.
How to design a batteries-included agent harness that bundles planning, file I/O, sub-agent delegation, and context management into a reusable, composable substrate.
How to build a memory admission layer that uses rule-based feature extraction and LLM utility scoring to decide which observations are worth storing—improving recall precision while cutting latency.
How a unified skill ontology and open repository changes the way agents discover, evaluate, and compose capabilities at scale.
How the LLM Delegate Protocol makes agent identity, trust, and provenance first-class primitives in multi-agent communication.
Google's open protocol enabling AI agents to discover, communicate, and collaborate across organizational boundaries using standardized task exchange.
An official MCP extension enabling tools to return interactive UI components — dashboards, forms, and visualizations — that render directly in conversations.
An open standard from Anthropic that defines how AI agents connect to external tools, data sources, and services through a composable server architecture.
An open industry protocol enabling AI agents to shop across any participating merchant using unified APIs for checkout, identity linking, and order management.
Defense in depth for AI agents: input validation, output filtering, tool sandboxing, guardian agents, and OWASP LLM security risks.