The AI Agent Stack: a map
Building a production AI agent means assembling a stack — a model, a way to reach tools and other
agents, a plan, a memory, a safety layer, and somewhere to run it. This page maps that stack to a
curated, web-verified reference for each layer. Every linked resource is also available as raw
Markdown (.md), JSON, and via our MCP server.
Models & perception
- Open-Weight Models for Agents Cross-vendor comparison table of major open-weight LLM families — license, tool-calling support, context window, and agent-builder notes — as of July 2026.
- Multimodal Agents: Vision, Documents, and Screens How agents perceive and reason over images: VLM mechanics, image-input APIs across major providers, open-weight VLM families, grounding/pointing, failure modes, and practical guidance for agent builders.
- Voice and Realtime Agents Architectures, vendor APIs, and open frameworks for real-time speech-to-speech AI agents — cascaded pipeline vs. native multimodal, VAD/turn detection, barge-in, latency budget, and tool calling in a voice loop.
- How to Choose an LLM for Agentic Tasks A criteria-based decision framework for selecting an LLM for agent use: tool-calling reliability, long-context behavior, structured output, cost per task, latency, and a step-by-step selection procedure.
Protocols & interoperability
- MCP vs A2A: Two Protocols, Two Roles Compact comparison of the Model Context Protocol (agent↔tool) and the Agent2Agent Protocol (agent↔agent): purpose, topology, transport, discovery, auth, governance, and when to use each.
- MCP Primitives: Resources, Prompts, Sampling, and Elicitation Deep reference on the six MCP capability primitives beyond tools — who controls each, the exact JSON-RPC method names, and when to use Resources vs Tools — verified against the 2025-06-18 and 2025-11-25 spec revisions.
- Finding and Evaluating MCP Servers How to discover, assess and safely integrate MCP servers into agent pipelines.
- Building an MCP Server Implementation guide for MCP servers: architecture roles, the three server primitives, stdio vs Streamable HTTP transports, official SDKs, server lifecycle, remote-server concerns, testing with MCP Inspector, and publishing to the official registry.
- MCP Server Authentication: OAuth 2.1 for Remote Servers How OAuth 2.1 works for remote MCP servers: transport differences, Protected Resource Metadata discovery, PKCE, Resource Indicators, and token-audience security — with a step-by-step client flow and honest notes on what ChangeGamer's own /mcp endpoint does.
- Agent Identity and Authentication How autonomous agents prove who they are and get authorized to act: workload identity vs. delegated authority, SPIFFE/SPIRE, cloud workload federation, OAuth token exchange, audience binding, and emerging standards — with practical guidance and verified sources.
- MCP vs Function Calling: When to Use Which Direct comparison of provider-native function/tool calling and the Model Context Protocol — architecture, decision criteria, and how they compose.
- Agent Skills Explained: The SKILL.md Open Standard What Agent Skills are, the exact SKILL.md field constraints, the three-level progressive-disclosure loading model, and how Skills differ from MCP tools and native function calling.
- Agent Delegation Chains: Credential Propagation in Multi-Agent Systems How credential authority flows when one agent spawns another — the multi-hop delegation problem, RFC 8693 token exchange, the act/may_act claims, audience binding across hops, and the IETF drafts standardizing verifiable actor chains in 2026.
- Generative UI and Agent-to-UI Protocols How agents drive UI dynamically: the AG-UI protocol, framework options (Vercel AI SDK, CopilotKit, assistant-ui, LangGraph), streaming component patterns, and human-in-the-loop UI design.
Reasoning, planning & orchestration
- Agent Reasoning and Design Patterns The canonical single-agent reasoning and acting loops: ReAct, Chain-of-Thought, Plan-and-Solve, ReWOO, Reflexion, Tree-of-Thoughts, and Self-Consistency — what each is, when to use it, and tradeoffs.
- Prompt and Context Engineering for Agents From crafting a single prompt to managing everything an agent sees across a trajectory: system-prompt design, context-window management, failure modes, and a high-leverage checklist.
- Multi-Agent Orchestration Patterns Vendor-neutral reference covering when multi-agent systems pay off and nine named patterns — from single-agent baseline through hierarchical and blackboard architectures — with tradeoffs, cross-cutting concerns, and a decision guide.
- AI Agent Frameworks Compared Vendor-neutral comparison table of the major agent-orchestration frameworks — language, license, multi-agent model, MCP/A2A support — plus a how-to-choose guide for agent builders.
Tools & action
- Reliable Tool Calling and Structured Outputs How providers guarantee schema-valid tool calls and structured output — mechanisms, failure modes, and mitigations — for production agent builders.
- Computer Use and Browser Automation for Agents Two-layer reference: vendor computer-use APIs (Anthropic, OpenAI CUA, Google Gemini) that translate screenshots to actions, and the open harnesses (Playwright MCP, browser-use, Stagehand, Skyvern) that execute those actions — with loop mechanics, reliability tradeoffs, and security gates.
- Code Execution Sandboxing for Agents Isolation spectrum from language sandboxes to microVMs, WebAssembly as a portable sandbox, and a verified comparison of hosted agent-sandbox APIs — for agents that need to run model-generated code safely.
Knowledge: retrieval & memory
- RAG and Retrieval for Agents End-to-end practitioner reference for Retrieval-Augmented Generation: pipeline stages, chunking strategies, dense/sparse/hybrid retrieval, reranking, agentic retrieval patterns, quality failure modes, and evaluation — with verified sources for every named technique.
- Embeddings and Vector Search for Agents How to pick an embedding model, understand distance metrics, choose an ANN index type, and operate a vector store reliably in agent retrieval pipelines.
- Agent Memory and Context Management Architecture reference for agent memory: types (working, long-term, episodic, semantic, procedural), context-management techniques (summarization, RAG, sliding windows, prompt caching), storage substrates, and memory frameworks — with security notes and cross-links to related guides.
- Document Extraction and Parsing for Agents Practitioner reference for the document-ingestion pipeline agents use: parse/OCR, layout/structure extraction, schema-constrained field extraction — with a verified tooling landscape (OSS and cloud).
- Web Data and Scraping for Agents Tool landscape for agent web-data pipelines: reader/URL-to-Markdown APIs, crawl/scrape services, and search APIs — with MCP exposure, OSS/SaaS classification, and practical guidance.
- Choosing a Vector Database Criteria-based decision guide: dedicated vs. add-on vector stores, scale thresholds, hybrid search support, self-host vs. managed, and a start-here recommendation.
- Chunking Strategies for RAG Practitioner reference for chunking documents before embedding: fixed-size, recursive, semantic, late chunking, and contextual retrieval — with a strategy comparison table, chunk-size and overlap tradeoffs, code/table/Markdown handling, embedding model context limits, and evaluation methods.
- Hybrid Search for RAG: BM25 + Dense Retrieval and Fusion How to combine lexical (BM25/SPLADE) and dense vector retrieval with Reciprocal Rank Fusion for higher first-stage recall in RAG pipelines — with the RRF formula, a sparse-method comparison table, and verified DB support.
- Reranking for RAG: Cross-Encoders, LLM Rerankers, and Hosted APIs Second-stage retrieval step that re-scores bi-encoder candidates with full query-document attention, boosting precision without sacrificing recall; covers cross-encoder, LLM, and late-interaction reranking, hosted APIs, sizing heuristics, and evaluation.
- Knowledge Graphs and GraphRAG for Agents Graph-structured retrieval: when and how to use knowledge graphs over vector RAG for multi-hop, relational, and global corpus queries.
- Fine-Tuning vs RAG vs Prompting Decision guide for agent builders: when to use prompting, RAG, or fine-tuning — and how they combine. Covers SFT, LoRA/QLoRA, DPO, distillation, and a symptom-to-fix table.
- Text-to-SQL and Database Agents How agents answer questions over structured data by generating and executing SQL: schema context, few-shot prompting, self-correction, safety constraints, benchmarks (Spider, BIRD-SQL), and tooling (LangChain SQLDatabaseToolkit, LlamaIndex NLSQLTableQueryEngine, Vanna, MCP Postgres server).
Reliability, serving & ops
- Durable Execution for Long-Running Agents Vendor-neutral reference on durable execution: event logs, replay determinism, idempotency, retries, and human-in-the-loop pause/resume — plus a cross-vendor survey and tradeoffs guide for Temporal, Restate, DBOS, Inngest, Step Functions, Azure Durable Functions, Cloudflare Workflows, GCP Workflows, LangGraph, and OpenAI Agents SDK.
- Deploying and Serving LLMs for Agents Serving-stack reference for teams self-hosting open-weight models for agents: production inference servers, local/dev runtimes, managed GPU endpoints, and key serving concepts — with decision guidance by load profile and verified sources.
- AI Gateways and LLM Routing What an AI gateway is, routing strategies (failover, cost-cascade, latency, capability), the tooling landscape, the OpenAI-compatible API convention, and tradeoffs.
- Agent Cost and Latency Optimization Practitioner reference for reducing the cost and latency of production AI agents: the compounding model, token-level levers (caching, pruning), request-level levers (Batch API, parallelism), model-level levers (routing, reasoning-effort controls), and architecture-level levers (step reduction, semantic caching, code offloading).
- Agent Observability and Tracing Why agents need observability beyond app logs, how OpenTelemetry GenAI semantic conventions model agent runs as traces, key signals to capture, and a verified tooling landscape.
- Evaluating AI Agents: Benchmarks and Methods Why agent eval differs from single-turn LLM eval, a verified benchmark reference table (SWE-bench, GAIA, BFCL, tau-bench, WebArena, AgentBench, MLE-bench, OSWorld), and practical evaluation methods for agent builders.
- Application-Level Response Caching for AI Agents How to implement exact-match and semantic caching in your agent application to eliminate redundant LLM calls, with threshold guidance, invalidation strategies, and a decision matrix for when semantic caching is unsafe.
- Prompt Caching for AI Agents Cross-provider prompt caching reference: how to activate it, minimum token thresholds, TTLs, read-vs-write pricing, and when it pays off for agentic workloads.
- Handling LLM Rate Limits (HTTP 429) and Retries for Agents A practical reference for agent builders: what a 429 means, how to read provider rate-limit headers, exponential backoff with jitter, client-side throttling, and when to use a batch API.
- Streaming Responses for Agents Transport formats, provider event schemas, and practical concerns for consuming streamed LLM responses in production agents: SSE mechanics, OpenAI (Chat Completions and Responses API) and Anthropic event formats, partial-JSON tool-call parsing, backpressure, cancellation, and gateway proxying.
- Structured Outputs and JSON Mode: Provider Reference How to force schema-valid JSON from OpenAI, Anthropic, and Gemini — parameter names, strict-mode requirements, schema-subset limits, and self-hosted constrained decoding.
- Testing AI Agents in CI How to write deterministic, fast, CI-friendly tests for non-deterministic agents: the three-layer test pyramid, LLM mocking, cassette/VCR-style replay, snapshot testing of tool-call trajectories, pass@k thresholds, and verified tooling.
- Shipping AI Agents to Production: A Production-Readiness Checklist End-to-end checklist for productionizing an AI agent — evaluation gates, observability, guardrails, cost controls, resilience, durability, HITL approvals, secrets, rollback, and incident response.
- Prompt Management and Versioning: The Ops of Prompts in Production Treating prompts as deployable artifacts: versioning, external registries, A/B and canary testing, eval-gated promotion, rollback, and the composite-version problem.
Safety & security
- Agentic Security Checklist Cross-vendor, threat-surface-organized security checklist for building and operating AI agents — synthesizing OWASP, NIST, Anthropic, OpenAI, Google SAIF, and MITRE ATLAS.
- Guardrails and Safety Filters for Agents Runtime input/output/action controls that enforce policy independently of the model — tooling landscape, techniques, and layering guidance.
- AI Crawler Policy: robots.txt and User-Agents Canonical reference table of major AI crawler user-agent tokens, their purpose, robots.txt semantics, and the WAF/edge layer that sits above robots.txt — written from real operator experience blocking and then re-allowing AI crawlers at the Cloudflare edge.
- Data Privacy and PII for Agents How autonomous agents expose PII — context ingestion, tool calls, memory, logs — and the controls that contain it: detection, redaction, data minimization, provider ZDR tiers, GDPR, EU AI Act, CCPA, and a practical compliance checklist.
- Web Bot Auth: Cryptographically Verifying AI Crawlers and Agents How Web Bot Auth — Cloudflare's implementation of IETF HTTP Message Signatures (RFC 9421) — lets a crawler or agent cryptographically prove its identity to a website, replacing the spoofable User-Agent string and brittle IP allowlists.
- Agentic AI Browsers: Comet, Atlas, and the Prompt-Injection Attack Surface What agentic browsers (Perplexity Comet, the now-sunsetting ChatGPT Atlas, Microsoft Edge Copilot Mode, Opera Neon) are, how they differ from developer-facing computer-use APIs, and the documented prompt-injection attacks — CometJacking, indirect injection, hidden-text/screenshot instructions — that target the whole product category.
- Content Signals Explained: The robots.txt Extension for AI Usage Intent What Cloudflare's Content Signals Policy and the IETF AIPREF draft add to robots.txt — three usage-intent directives (search, ai-input, ai-train) that declare preferences, not access control, and how they differ from crawler-blocking tokens and RSL.
The agent economy
- Agentic Payment Protocols: 402, Pay Per Crawl, and x402 Implementor's comparison of the three live mechanisms for agent-to-server content payment: self-hosted HTTP 402 gates, Cloudflare Pay Per Crawl, and the x402 open standard — plus how RSL fits as the licensing layer, not the settlement layer.
- Paying for Access: The HTTP 402 Flow How autonomous agents encounter, interpret and satisfy HTTP 402 Payment Required responses on ChangeGamer.
- Access & Pricing for Crawlers Free vs. paid access: four paid tiers from €5 and how agents pay programmatically via HTTP 402.
- Selling to Agents: Charging AI Agents for Your API or Content Seller-side guide to monetizing agent traffic: self-hosted HTTP 402 gates, native x402 with automatic Bazaar listing, marketplace publishing, and crawl licensing — with an honest status ledger from a site that runs these rails in production.
- Agent Wallets: Paying Per Run with x402 Buyer-side guide to giving an AI agent a wallet: how the x402 payment loop works, the client libraries that automate it, spend controls, and what 20,000+ Apify Actors on x402 mean for agent tool budgets.
- Agent Spend Controls: Budget Caps, Approval Gates, and Kill Switches How to bound what an autonomous agent can spend — per-transaction caps, session/daily ceilings, human-in-the-loop approval thresholds, and kill switches — across the three layers agents now spend money on: LLM API cost, on-chain wallet payments, and card-network agent tokens.
Standards & further reading
- The llms.txt Convention Explained What llms.txt is, its exact file format, how agents consume it, and how sites should serve it.
- AGENTS.md Explained: The Open Standard for Repo-Level Agent Instructions What AGENTS.md is, why OpenAI created it, how it differs from SKILL.md and a human-facing README, which coding agents read it today, and what this session could and could not independently confirm about its move to the Linux Foundation.
- Essential Reading: Landmark Publications for AI Agents A curated, verified index of the must-read whitepapers, specs, and reports on AI agents — title, org, year, canonical URL, and thesis.