AI Agents Cheat Sheet

Table 1: Core Agent Concepts

These are the building blocks every AI agent shares regardless of framework: a control loop that thinks-acts-observes, structured tool invocation, a reasoning engine, perception of inputs, and a calibrated level of autonomy. Grasp these and the framework-specific patterns in later tables become small variations on the same theme.

Table 2: Architecture Patterns

These patterns describe how a single agent system organizes reasoning, decision-making, and control flow. The biggest source of confusion is what happens WHEN: ReAct decides one step at a time, Plan-and-Execute commits to a full plan upfront, Reflection critiques its own output, and Tree-of-Thought explores branches in parallel before committing.

Table 3: Memory Systems

Memory turns stateless LLMs into agents that learn across sessions. This table maps the canonical short-term vs long-term split, the three cognitive long-term types (episodic, semantic, procedural), production runtimes like Mem0, Letta (MemGPT) and Zep/Graphiti, and the working/shared memory layers that coordinate state within and across agents.

Table 4: Multi-Agent Systems

This table covers the common topologies multi-agent systems use to coordinate work — when control is centralized, when it isn't, and how agents share state. The split between hierarchical (a supervisor delegates downward) and network/collaborative (peers interact as equals) is the most-confused distinction, and how state is shared (direct messages vs a shared blackboard) is the second.

Table 5: Communication Protocols

Agents rarely work alone — they reach out to tools and data, hand off work to other agents, and stream results back to users. This table covers the three protocols that now define those boundaries (MCP, A2A, AG-UI) along with the classic messaging patterns (Pub-Sub, Request-Response, Message Queue) that still underpin agent transports.

Table 6: Agent Frameworks

The agent-framework landscape in 2026 is crowded, and each tool below picks a different bet: graph-based stateful runtimes, role-based crews, conversational multi-agent systems, type-safe structured output, model-driven SDKs, or lightweight code-first harnesses. Use this table to match a project's needs (durability, model-agnosticism, multi-agent style) to the framework whose design philosophy fits best.

Table 7: Tool Integration

Function calling tells you that an LLM can ask for a tool — this table covers the runtime plumbing that actually makes tools work. It maps the lifecycle from defining the schema, discovering what's available, executing the call, parsing the result, and scheduling multiple calls in parallel or in sequence, including the efficient code-execution pattern for large MCP server ecosystems.

Table 8: State Management

State management is what lets an AI agent survive crashes, hand off conversations between sessions, and explore alternative trajectories without losing the original run. The patterns below cover the two dominant approaches in production today — LangGraph's checkpointer-based persistence and Temporal's event-sourced durable execution — and the supporting concepts (threads, typed schemas, rollback) that make either approach safe at scale.

Table 9: Execution Patterns

How an agent is invoked controls its throughput, perceived latency, and integration shape. These five patterns — synchronous, asynchronous, streaming, event-driven, and batch — solve different problems and frequently get confused with one another, especially async vs parallel and streaming vs async.

Table 10: Reasoning Techniques

Reasoning techniques shape how an agent thinks through a problem before answering — from solving with no examples (zero-shot) to ensembling many sampled reasoning paths (self-consistency) to looping with the environment (agentic reasoning). The right choice depends on the task's complexity, the cost budget, and whether the agent needs to ground itself in external observations.

Table 11: Planning Strategies

Five strategies an agent uses to turn a goal into action. They differ in when the plan is built, how it is structured, and what the agent does when reality fails to cooperate — from a one-shot decomposition into subtasks, through multi-level hierarchies, to runtime replanning and the upfront Planner-Worker-Solver split that ReWOO introduces.

Table 12: Error Handling

Production agents fail constantly: providers throttle, networks blip, models time out, and downstream tools return garbage. These five patterns are the standard distributed-systems toolkit applied to LLM agents — retry transient errors with backoff and jitter, fall back to alternatives, trip a circuit breaker before a retry storm crashes a recovering provider, degrade gracefully when full output is impossible, and propagate unrecoverable errors up to a supervisor.

Table 13: Evaluation & Testing

Metrics, frameworks, and benchmark suites that production teams use to answer two distinct questions about an agent: did it succeed? and did it succeed for the right reasons? Outcome-style measures (Task Success Rate, SWE-bench, GAIA) sit alongside trajectory-style measures (Trajectory Analysis, Tool Accuracy) and the human-in-the-loop and LLM-as-Judge graders that score everything in between.

Table 14: Observability & Debugging

Without observability, multi-step agent failures are nearly un-debuggable: each LLM call, tool invocation, and sub-agent decision happens behind the model's reasoning, and a flat log won't tell you which step caused the wrong answer. This table covers the layered toolkit teams reach for in production — tracing for causal execution trees, logging and real-time monitoring for what's happening now, dedicated platforms like LangSmith, Langfuse, and Laminar, callback hooks for low-overhead instrumentation, and replay for reproducing intermittent bugs from saved state.

Table 15: Retrieval-Augmented Generation (RAG) for Agents

RAG techniques connect an agent to external knowledge so its answers can be grounded in fresh, domain-specific facts instead of memorized weights. The patterns below stack: query transformation reshapes the input, vector or graph retrieval pulls candidates, reranking sharpens them, and an agentic controller decides when any of this is even worth running.

Table 16: Context Management

Every agent runs on a finite token budget — what you feed the model, what it has said so far, what it retrieved, and what it generates all share the same window. This table covers the techniques that decide what stays, what gets compressed, and what gets cached so an agent can run for hours without the model losing focus or burning your budget on the same tokens twice.

Table 17: Security & Safety

Agentic systems amplify traditional LLM risks because the model can act, hold credentials, and chain tool calls — so a single manipulated prompt or poisoned tool description can escalate into data exfiltration or destructive action. The defenses below come from the OWASP Top 10 for Agentic Applications (2026), OWASP's AI Agent Security Cheat Sheet, and current vendor guardrail toolkits; they work as layered controls, not silver bullets.

Table 18: Cost Optimization

Token bills scale faster than features once an agent moves to production, so cost control is a first-class engineering concern. Agents make 3–10× more LLM calls than simple chatbots, and output tokens cost 3–8× more than input tokens across major providers — making cascading model routing and caching the highest-leverage levers available.

Table 19: Production Patterns

Shipping an agent to production exposes failure modes the demo never showed: retried payments creating duplicate charges, runaway tool loops draining budgets, silent half-completions, and crashed workers losing hours of progress. These five patterns are the safety rails that turn a clever agent into a reliable service — idempotent retries, selective human gates, outcome verification, hard time ceilings, and durable state on shutdown.