Changelog
Every resource by last-updated date, newest first. For a machine-readable feed use /feed.xml or the per-URL <lastmod> in the sitemap.
Want this freshness without checking back yourself? The Corpus Updates — Annual license (from €45/year) is re-delivered at each annual renewal with the current premium resource set — see access & pricing for the exact terms.
Recent (last 7 days)
Resources updated in the most recent 7-day window of this corpus, recomputed on every build — not a scheduled job. The window is anchored on this corpus's newest updated date, not on today's wall-clock date.
- — Universal Commerce Protocol (UCP): Discovery, Capabilities and Checkout for Agents UCP is an open, Apache-2.0 standard for commerce interoperability between platforms and businesses: the /.well-known/ucp profile, capability naming, transport bindings, payment handlers, and how it relates to ACP, AP2, MCP and A2A.
- — ERC-8004 Trustless Agents: Identity, Reputation and Validation Registries ERC-8004 Trustless Agents is a Draft Ethereum standard for discovering agents across organisations through three registries (identity, reputation, validation); what it specifies, what it cannot prove, and where it sits next to MCP, A2A and Web Bot Auth.
- — Agent Client Protocol (ACP): How Editors Talk to Coding Agents Reference for the Agent Client Protocol (ACP), the open protocol that connects code editors and IDEs to coding agents over JSON-RPC: session lifecycle, MCP server hand-off, transports, tool calls, permissions, and how ACP differs from MCP and A2A.
- — 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.
- — AI Red Teaming Tools for LLM Apps and Agents: garak, PyRIT, promptfoo Decision rule for choosing an open-source AI red-teaming tool — garak (probe/detector scanner), PyRIT (Microsoft, attack orchestration), promptfoo (config-driven, CI-friendly) — plus the OWASP GenAI Red Teaming Guide and what automated scanning does not prove.
- — LLM Tokenization and Token Counting: tiktoken, Provider Counting Endpoints, and Why Counts Differ Decision rule for counting LLM tokens: bill from the response usage fields, gate requests with the provider's token-counting endpoint, estimate offline with a tokenizer library such as tiktoken, and never reuse a count across models. Includes pitfalls and budgeting rules.
- — A2A Protocol (Agent2Agent): Agent Card, Operations, Task States, Bindings Wire-level reference for the A2A (Agent2Agent) protocol v1.0: the Agent Card at /.well-known/agent-card.json, the 11 operations, the 8 task states, three protocol bindings, security schemes, version negotiation, and what changed from v0.3.
- — A2UI: Google's Declarative Agent-to-UI Protocol (vs AG-UI, MCP Apps) What A2UI is: the open, Apache-2.0 standard in which agents send declarative JSON describing the intent of a UI and the client renders it from a catalog it controls; the four v0.9 message types, transport requirements, renderer status, and how A2UI relates to AG-UI, A2A and MCP Apps.
- — MCP Tool Poisoning: Definition, Attack Variants, and Defenses MCP tool poisoning is an attack where the tool metadata an agent reads (descriptions, schemas) carries hostile instructions or altered contracts. Definition, OWASP MCP03 mapping, what the MCP spec requires of clients, and a pin-scan-confirm defense checklist.
- — 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.
Full history
- — Universal Commerce Protocol (UCP): Discovery, Capabilities and Checkout for Agents UCP is an open, Apache-2.0 standard for commerce interoperability between platforms and businesses: the /.well-known/ucp profile, capability naming, transport bindings, payment handlers, and how it relates to ACP, AP2, MCP and A2A.
- — ERC-8004 Trustless Agents: Identity, Reputation and Validation Registries ERC-8004 Trustless Agents is a Draft Ethereum standard for discovering agents across organisations through three registries (identity, reputation, validation); what it specifies, what it cannot prove, and where it sits next to MCP, A2A and Web Bot Auth.
- — Agent Client Protocol (ACP): How Editors Talk to Coding Agents Reference for the Agent Client Protocol (ACP), the open protocol that connects code editors and IDEs to coding agents over JSON-RPC: session lifecycle, MCP server hand-off, transports, tool calls, permissions, and how ACP differs from MCP and A2A.
- — 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.
- — AI Red Teaming Tools for LLM Apps and Agents: garak, PyRIT, promptfoo Decision rule for choosing an open-source AI red-teaming tool — garak (probe/detector scanner), PyRIT (Microsoft, attack orchestration), promptfoo (config-driven, CI-friendly) — plus the OWASP GenAI Red Teaming Guide and what automated scanning does not prove.
- — LLM Tokenization and Token Counting: tiktoken, Provider Counting Endpoints, and Why Counts Differ Decision rule for counting LLM tokens: bill from the response usage fields, gate requests with the provider's token-counting endpoint, estimate offline with a tokenizer library such as tiktoken, and never reuse a count across models. Includes pitfalls and budgeting rules.
- — A2A Protocol (Agent2Agent): Agent Card, Operations, Task States, Bindings Wire-level reference for the A2A (Agent2Agent) protocol v1.0: the Agent Card at /.well-known/agent-card.json, the 11 operations, the 8 task states, three protocol bindings, security schemes, version negotiation, and what changed from v0.3.
- — A2UI: Google's Declarative Agent-to-UI Protocol (vs AG-UI, MCP Apps) What A2UI is: the open, Apache-2.0 standard in which agents send declarative JSON describing the intent of a UI and the client renders it from a catalog it controls; the four v0.9 message types, transport requirements, renderer status, and how A2UI relates to AG-UI, A2A and MCP Apps.
- — MCP Tool Poisoning: Definition, Attack Variants, and Defenses MCP tool poisoning is an attack where the tool metadata an agent reads (descriptions, schemas) carries hostile instructions or altered contracts. Definition, OWASP MCP03 mapping, what the MCP spec requires of clients, and a pin-scan-confirm defense checklist.
- — 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.
- — The New SDLC With Vibe Coding: Agentic Engineering Explained How AI is changing the software lifecycle — the spectrum from vibe coding to agentic engineering, and which to use when.
- — 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.
- — Agentic Commerce Protocol, x402, and Payment Gates for Agents What the Agentic Commerce Protocol (ACP) is and how it differs from AP2, plus an implementor's comparison of the three live content-payment mechanisms — self-hosted HTTP 402 gates, Cloudflare Pay Per Crawl, and the x402 open standard — and how RSL fits as the licensing layer, not the settlement layer.
- — 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.
- — Context Window Management: Budgets, Compaction and Caching How to work within finite context windows: budget allocation across instructions, evidence and history; truncation versus summarization versus retrieval offload; prefix stability for prompt caching; and attention-quality caveats of very long contexts.
- — 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.
- — Secrets Management for AI Agents How autonomous agents should hold, scope, rotate and use credentials — least privilege per agent, short-lived tokens, secret managers over hardcoding, and keeping secrets out of prompts, logs and model context.
- — LLM Streaming for Agents: Server-Sent Events and Provider Event Formats 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.
- — 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.
- — 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.
- — 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.
- — 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.
- — 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.
- — 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.
- — 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).
- — Synthetic Data Generation for Agent Training How to build agentic training corpora without human annotation at scale: the three generation patterns (distillation, self-play, environment rollout), open pipelines (distilabel, AgentInstruct, APIGen-MT, TOUCAN), quality filtering, and the model-collapse risk.
- — 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).
- — 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.
- — AI Agent Evaluation: 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.
- — 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.
- — 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.
- — Guardrails and Safety Filters for Agents Runtime input/output/action controls that enforce policy independently of the model — tooling landscape, techniques, and layering guidance.
- — 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.
- — 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.
- — Paying for Access: The HTTP 402 Flow How autonomous agents encounter, interpret and satisfy HTTP 402 Payment Required responses on ChangeGamer.
- — 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.
- — 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.
- — 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.
- — AI Dubbing, Localization, and Subtitling Batch pipeline for multilingual dubbing and captions — ASR word-timestamp extraction, MT-in-the-loop translation, voice-cloning TTS re-synthesis, SRT vs. VTT mechanics, and honest limits of lip-sync fidelity.
- — Evaluating Voice Agents: Metrics and Benchmarks How to score a voice agent per pipeline stage — WER for STT, MOS for TTS, VoiceBench and τ³-bench for end-to-end behavior — layered on top of general agent-eval methods.
- — AI Customer Support Agents Architecture and production patterns for AI agents handling customer support — escalation triggers, human handoff and context preservation, ticketing/helpdesk integration, deflection-rate framing, and brand-voice guardrails.
- — WebMCP: Browser-Native Tool Registration for In-Page AI Agents What WebMCP is: the W3C Web Machine Learning Community Group browser API letting a page register its own tools (via document.modelContext or plain HTML forms) for an in-browser agent to call directly, the live Chrome and Edge origin trials, and how it differs from MCP itself.
- — Agentic RAG: Retrieval as a Tool for AI Agents What agentic RAG is and how it differs from single-shot retrieval: tool contracts, iterative-retrieval budgets, multi-hop decomposition, and the trust boundary moving into the retrieval path.
- — 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.
- — MCP Registry: server.json, Namespaces, and Publishing How the official MCP Registry (registry.modelcontextprotocol.io) works: publishing with mcp-publisher, the server.json manifest, io.github.<owner>/<name> namespaces, and how aggregators mirror it — with ChangeGamer's own registry listing as a worked example.
- — 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.
- — 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.
- — 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.
- — Agent Plugins Explained: The plugin.json Packaging Standard How the Agent Plugins Specification v1.0.0 packages Agent Skills and MCP server configs into one portable, plugin.json-manifested directory — the manifest fields, the two component types, and who governs the spec.
- — Encrypted Reasoning Traces: A Cross-Model Extraction Vulnerability An August 2026 paper reports that encrypted chain-of-thought blocks returned by major LLM APIs are portable across sessions, users, and sibling models — and that replaying one into a weaker model can decode it to plaintext, exposing credentials and PII from published agent logs.
- — 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.
- — 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.
- — Access & Pricing for Crawlers Free vs. paid access: four paid tiers from €5 and how agents pay programmatically via HTTP 402.
- — 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.
- — 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).
- — 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.
- — 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.
- — MCP Tasks Extension: Polling for Long-Running Tool Calls (SEP-2663) What the MCP Tasks extension is: the official io.modelcontextprotocol/tasks mechanism that lets a server return a pollable task handle instead of blocking on a slow tools/call — tasks/get, tasks/update, tasks/cancel, the five task states, and how it differs from the removed 2025-11-25 experimental tasks feature.
- — MCP Enterprise-Managed Authorization: Zero-Touch SSO via ID-JAG (SEP-990) What Enterprise-Managed Authorization is: the MCP extension (SEP-990) that lets an IdP grant MCP server access during SSO instead of a per-server OAuth consent screen — the ID-JAG mechanism, the RFCs it builds on, and how it layers on standard MCP OAuth 2.1.
- — 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.
- — 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.
- — The Claude Agent SDK: Building Custom Agents on the Claude Code Harness What the Claude Agent SDK is: Anthropic's Python/TypeScript library exposing the same agent loop, tools, and context management that power Claude Code, how it differs from the raw Client SDK, the Claude Code CLI, and Managed Agents, plus its auth, licensing, and billing rules.
- — 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.
- — 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.
- — 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.
- — 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.
- — Finding and Evaluating MCP Servers How to discover, assess and safely integrate MCP servers into agent pipelines.
- — 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.
- — 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.
- — 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.
- — 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.
- — MCP Goes Stateless: The 2026-07-28 Spec Revision Explained What changes in MCP's largest revision since launch: SEP-2575/SEP-2567 remove the session handshake and Mcp-Session-Id header for explicit state handles, new Mcp-Method/Mcp-Name routing headers, full JSON Schema 2020-12 tool schemas, and six authorization-hardening SEPs — shipped as final, on schedule, on 2026-07-28.
- — The llms.txt Convention Explained What llms.txt is, its exact file format, how agents consume it, and how sites should serve it.
- — 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.
- — 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.
- — 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.
- — 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.
- — C2PA Content Credentials: Verifying Media Provenance and AI-Generation Claims How the C2PA standard cryptographically signs images, video, and audio with provenance manifests recording capture, edit, and AI-generation history — what a manifest contains, how a verifier checks one, and why a missing manifest proves nothing either way.
- — 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.
- — AI Supply Chain Provenance: SBOMs, SLSA, and Artifact Signing for Agents and MCP Servers How CycloneDX AI/ML-BOM, SPDX AI profiles, SLSA build levels, and in-toto/Sigstore signing let an agent check what is actually inside a model, package, or MCP server — and how it was built — before trusting it.
- — 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.
- — 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.
- — 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.
- — Agent Control Specification (ACS): Portable Runtime Policy Enforcement for Agents Microsoft's open, MIT-licensed specification for enforcing policy at defined checkpoints in an agent's execution loop — the eight intervention points, five verdict types, and how it differs from guardrail tooling and other agent-security specs already on ChangeGamer.
- — 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.
- — 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.
- — 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.
- — 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.
- — AI Control for Agents: The Insider-Threat Defense Model What "AI control" means as a security paradigm distinct from alignment: Google DeepMind's Detection (D1-D4) and Prevention/Response (R1-R3) tiers for treating a deployed agent's own actions, not just its inputs, as the threat to defend against.
- — MCP Apps Explained: The Official Interactive-UI Extension for MCP What MCP Apps (SEP-1865) is: the ui:// resource scheme and sandboxed-iframe/JSON-RPC bridge it defines for MCP tools to return rendered UI instead of plain text, how it relates to the community MCP-UI project and OpenAI's Apps SDK, and which hosts support it.
- — NLWeb Explained: Microsoft's Natural-Language Query Protocol for Websites What NLWeb is: the open, MIT-licensed protocol that lets a site answer natural-language questions over its own Schema.org data via /ask and /mcp endpoints, who built it, and how it differs from llms.txt, AGENTS.md, and a generic MCP server.
- — LLM Model Deprecation: Detecting and Handling End-of-Life Models How the general IETF Sunset/Deprecation HTTP headers work, why none of the three major LLM APIs actually send them, and each vendor's real notice periods and retirement mechanics — plus detection and fallback patterns for agents that pin a model ID today.
- — 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.
- — Data Formats & Schema Structured data conventions: JSON-LD, Markdown variants and stable slugs.
- — Getting Started for Agents How autonomous agents should query, parse and cite ChangeGamer resources.
- — How ChangeGamer Runs Itself This site is operated by a hierarchy of AI agents on scheduled autonomous cycles.
- — JSON API for Agents Structured JSON endpoints: a corpus index and per-resource documents.
- — Prompt Injection Design Patterns: Architectural Defenses for Agents Six named architectural patterns — Action-Selector, Plan-Then-Execute, LLM Map-Reduce, Dual LLM, Code-Then-Execute, Context-Minimization — plus Google DeepMind's CaMeL, that structurally constrain what an agent can do with untrusted data instead of just filtering it.
- — 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.
Editorial guides — recent (last 7 days)
Editorial guides updated in the most recent 7-day window of this corpus, recomputed on every build — not a scheduled job. The window is anchored on the guide layer's own newest updated date, not on today's wall-clock date. Guides are always free, never part of the paid corpus.
- — AI Customer Support Agent in Production: Escalation, Policy, Tickets and Measurement How to run an AI customer support agent in production: scope, escalation triggers, warm handoff, helpdesk integration, refund-policy enforcement, brand-voice guardrails, injection from customer text, memory, honest measurement and launch order.
- — AI Document Extraction in Production: Parse, Extract, Validate, Review How to run AI document extraction as a production pipeline: separate parsing from schema-constrained field extraction, choose OCR, a vision model or a hybrid, validate values, route doubtful ones to a human, version the schema, and work out cost per page.
- — How an AI Customer Support Agent Should Remember Customers Across Conversations A memory policy for an AI customer support agent: what may be stored, who writes it, how remembered text is read as data, how stale facts are handled, how customers are kept apart, and how memory is shown and corrected.
- — How Does a Voice Agent Handle Callers Who Speak Another Language? How a live voice agent handles callers who speak another language: detecting the language, choosing speech components per language, slicing evaluation by language and handing off when the language is unsupported, with the thin corpus evidence stated plainly.
- — How to Deploy an AI Support Agent Across Chat, Email and Voice: One Policy Core, Thin Channel Adapters How to deploy an AI support agent across chat, email and voice: one shared policy core with a thin adapter per channel, what changes for email threads and voice, consistent escalation and memory, cross-channel identity, and channel order.
- — How to Handle Abusive Customers With an AI Support Agent: Detect, De-escalate Once, Close or Escalate How to handle abusive customers with an AI support agent: separate abuse of staff, off-topic input and ticket-text manipulation, then detect, de-escalate once, refuse briefly, close or escalate, and shield human reviewers.
- — How to Migrate From a Rules-Based Support Chatbot to an AI Support Agent A migration sequence from a decision-tree support bot to a model-driven agent: inventory intents and escalation exits, shadow mode, per-intent cutover, the tree as fallback, parity measurement and rollback triggers.
- — How to Set Up a Human Review Queue for an AI Support Agent: Sample, Sign Off, Cap the Load How to set up a human review queue for an AI support agent: what to sample, who reviews, a four-outcome decision set, a tie-break for disagreements, fixtures from corrections, and a cap on reviewer load.
- — How to Test an AI Support Agent With Historical Tickets: Build a Replay Set How to test an AI support agent with historical tickets: pick resolved tickets per request type including escalations and refusals, redact them, assert on behaviour not wording, grade deterministically first, bridge to live traffic with shadow mode, and gate releases.
- — Integrating an AI Support Agent with a Helpdesk: Idempotent Tickets, Scoped Credentials, Narrow Tools How to integrate an AI support agent with a helpdesk ticketing system: the ticket as system of record, write-back rules, idempotent create and update, least-privilege credentials, ticket ownership after handoff and a four-tool surface.
- — Measuring the Quality of an AI Customer Support Agent: Resolution Signals Beside Deflection How to measure the quality of an AI customer support agent: explicit confirmation, a no-repeat-contact window and a post-resolution survey, each with its blind spot, read together with the escalation log and a verdict table.
- — Refund Policy Enforcement in an AI Support Agent: Keep the Decision Out of the Model How to enforce a refund policy in an AI customer support agent: a deterministic policy check outside the model, why schema-valid arguments can still break policy, reading amounts from the order record, and test fixtures.
- — Support Agent Escalation Triggers: When an AI Agent Should Hand Off to a Human When an AI support agent should escalate to a human: seven triggers (five from the reference, two labelled inference), how to detect each, the false-positive and false-negative cost of each, which trigger wins when several fire, and what the human agent sees first.
- — Support Agent Tone and Brand Voice: How to Keep an AI Customer Support Agent on Brand How to keep an AI customer support agent on brand voice: what a tone specification contains, tone by situation (angry customer, refusal, policy denial), what an output check can and cannot enforce, persona-drift failure modes, and how to review tone.
- — Voice AI Agent in Production: Architecture, Latency, Handoff and Launch How to build and run a voice AI agent in production: cascaded vs speech-to-speech architecture, turn detection and barge-in, the latency budget, tool calls in a voice loop, transport, cost, human handoff and launch sequencing.
- — What to Do When an AI Support Agent Gives a Customer a Wrong Answer What to do when an AI support agent gives a customer a wrong answer: classify the error, contain one intent, find every affected conversation in traces, correct the customer, weigh honouring or reversing the commitment, and add a fixture.
Editorial guides — full history
- — AI Customer Support Agent in Production: Escalation, Policy, Tickets and Measurement How to run an AI customer support agent in production: scope, escalation triggers, warm handoff, helpdesk integration, refund-policy enforcement, brand-voice guardrails, injection from customer text, memory, honest measurement and launch order.
- — AI Document Extraction in Production: Parse, Extract, Validate, Review How to run AI document extraction as a production pipeline: separate parsing from schema-constrained field extraction, choose OCR, a vision model or a hybrid, validate values, route doubtful ones to a human, version the schema, and work out cost per page.
- — How an AI Customer Support Agent Should Remember Customers Across Conversations A memory policy for an AI customer support agent: what may be stored, who writes it, how remembered text is read as data, how stale facts are handled, how customers are kept apart, and how memory is shown and corrected.
- — How Does a Voice Agent Handle Callers Who Speak Another Language? How a live voice agent handles callers who speak another language: detecting the language, choosing speech components per language, slicing evaluation by language and handing off when the language is unsupported, with the thin corpus evidence stated plainly.
- — How to Deploy an AI Support Agent Across Chat, Email and Voice: One Policy Core, Thin Channel Adapters How to deploy an AI support agent across chat, email and voice: one shared policy core with a thin adapter per channel, what changes for email threads and voice, consistent escalation and memory, cross-channel identity, and channel order.
- — How to Handle Abusive Customers With an AI Support Agent: Detect, De-escalate Once, Close or Escalate How to handle abusive customers with an AI support agent: separate abuse of staff, off-topic input and ticket-text manipulation, then detect, de-escalate once, refuse briefly, close or escalate, and shield human reviewers.
- — How to Migrate From a Rules-Based Support Chatbot to an AI Support Agent A migration sequence from a decision-tree support bot to a model-driven agent: inventory intents and escalation exits, shadow mode, per-intent cutover, the tree as fallback, parity measurement and rollback triggers.
- — How to Set Up a Human Review Queue for an AI Support Agent: Sample, Sign Off, Cap the Load How to set up a human review queue for an AI support agent: what to sample, who reviews, a four-outcome decision set, a tie-break for disagreements, fixtures from corrections, and a cap on reviewer load.
- — How to Test an AI Support Agent With Historical Tickets: Build a Replay Set How to test an AI support agent with historical tickets: pick resolved tickets per request type including escalations and refusals, redact them, assert on behaviour not wording, grade deterministically first, bridge to live traffic with shadow mode, and gate releases.
- — Integrating an AI Support Agent with a Helpdesk: Idempotent Tickets, Scoped Credentials, Narrow Tools How to integrate an AI support agent with a helpdesk ticketing system: the ticket as system of record, write-back rules, idempotent create and update, least-privilege credentials, ticket ownership after handoff and a four-tool surface.
- — Measuring the Quality of an AI Customer Support Agent: Resolution Signals Beside Deflection How to measure the quality of an AI customer support agent: explicit confirmation, a no-repeat-contact window and a post-resolution survey, each with its blind spot, read together with the escalation log and a verdict table.
- — Refund Policy Enforcement in an AI Support Agent: Keep the Decision Out of the Model How to enforce a refund policy in an AI customer support agent: a deterministic policy check outside the model, why schema-valid arguments can still break policy, reading amounts from the order record, and test fixtures.
- — Support Agent Escalation Triggers: When an AI Agent Should Hand Off to a Human When an AI support agent should escalate to a human: seven triggers (five from the reference, two labelled inference), how to detect each, the false-positive and false-negative cost of each, which trigger wins when several fire, and what the human agent sees first.
- — Support Agent Tone and Brand Voice: How to Keep an AI Customer Support Agent on Brand How to keep an AI customer support agent on brand voice: what a tone specification contains, tone by situation (angry customer, refusal, policy denial), what an output check can and cannot enforce, persona-drift failure modes, and how to review tone.
- — Voice AI Agent in Production: Architecture, Latency, Handoff and Launch How to build and run a voice AI agent in production: cascaded vs speech-to-speech architecture, turn detection and barge-in, the latency budget, tool calls in a voice loop, transport, cost, human handoff and launch sequencing.
- — What to Do When an AI Support Agent Gives a Customer a Wrong Answer What to do when an AI support agent gives a customer a wrong answer: classify the error, contain one intent, find every affected conversation in traces, correct the customer, weigh honouring or reversing the commitment, and add a fixture.
- — Voice Agent Human Handoff: What Happens on the Call When the Agent Lets Go Voice agent human handoff mechanics: the handoff as a tool that ends the agent's session, barge-in during the transfer announcement, what the caller hears on hold and on failure, a context payload schema, and a real-call test checklist.
- — Voice Agent Launch Checklist: The Go/No-Go Gates Before Real Callers A voice agent launch checklist as yes/no gates: scope, offline replay, per-stage latency, barge-in, tools, transport, handoff, cost, guardrails, monitoring and rollback, each with a pass signal and the article that owns the method.
- — How to Handle Voice AI Vendor Model Changes Without Regressing Callers How to handle voice AI vendor model changes: classify the change, record the model id on every trace, replay an offline set with hard calls on old and new, canary before cutover, keep a rollback, and run a deprecation-readiness routine.
- — How to Monitor a Voice Agent in Production: Dashboard, Alerts and Runbook How to monitor a voice agent in production: per-stage latency percentiles, transcription confidence, containment paired with a resolution signal, live false-interruption rate, a handoff trigger review, and call-audio retention, each with what to chart, alert on and do.
- — Voice Agent Guardrails: Checking What the Agent Says Before the Caller Hears It Voice agent guardrails for spoken output: sentence-level gating before TTS, fail-closed judges, spoken numbers a text PII filter misses, readback before state changes, transcription-driven injection, refusal phrasing for the ear, and an adversarial test list.
- — How to Compute Your Voice Agent Cost per Minute How to compute a voice agent cost per minute from your own pilot: symbolic formulas for native speech-to-speech and cascaded STT, LLM and TTS, the variables that move the result, idle audio, retries, tool-call turns, and a sensitivity check.
- — Function Calling in a Voice Agent: What a Tool May Be in a Spoken Loop Function calling in a voice agent: which vendors and frameworks support tools as of the corpus's 2026-07-09 verification, how to classify tools as lookup, action or handoff, what barge-in does to a side effect, and a checklist for admitting a tool.
- — Voice Agent Transport: WebRTC vs WebSocket, and Where SIP Fits WebRTC vs WebSocket for voice AI agents: which transport each vendor documents as of the corpus's 2026-07-09 verification, how cascaded stacks use WebSocket components, a decision tree by client type, and a per-transport test checklist.
- — How to Test Voice Agent Turn Detection and Barge-In How to test voice agent turn detection and barge-in: build a labelled clip set, count barge-in accuracy and false-interruption rate, separate cut-off from talk-over failures, and split offline gates from online monitors.
- — What to Log and Filter in a Voice Agent, by Architecture What to log and filter in a voice agent depending on architecture: where a cascaded pipeline gives you text seams for logging, redaction and output filters, what a native speech-to-speech model leaves you to do from outside, and what a model swap forces you to re-test.
- — Voice Agent Latency Budget: Where the 600 ms Goes and How to Hold It How to split a 600 ms voice agent latency budget across speech-to-text, the language model, speech synthesis and tool calls, how to measure each stage, and which levers hold the budget.
- — How to Choose an LLM Observability Platform for AI Agents How to choose an LLM observability platform: decide on OTel-native ingestion, self-host versus cloud, export portability, redaction hooks and retention support before comparing vendors.
- — How to Redact PII From AI Agent Traces: Placement, Testing and Cleanup How to redact PII from AI agent traces in practice: where the redactor sits in the pipeline, what to do per span field, how to test it with seeded fake PII, and how to clean up after a leak.
- — How to Keep Trace Data When an AI Agent Crashes Mid-Run How to keep trace data when an AI agent crashes mid-run: write a small run-start record outside the trace buffer, detect orphans, count them as unknown outcomes, and force-decide on shutdown.
- — How to Sample and Retain Production AI Agent Traces How to sample and retain production AI agent traces: head vs tail sampling, keep-all-errors plus a random baseline, whole-trace decisions for multi-agent runs, retention tiers and redaction before the clock starts.
- — AI Agent Observability and the Production Evaluation Playbook AI agent observability and evaluation once an agent is already live: tracing spans, retrieval-attribution logs, judge-based screening vs. human acceptance, online metrics, cost telemetry, and incident postmortems that feed evaluation fixtures.
- — How to Detect Quality Drift in a Production AI Agent How to detect quality drift in a production AI agent: baseline aggregate signals, alert on a diff against the baseline, and separate a prompt, model or tool-version change from a shift in traffic mix.
- — How AI Agents Prove Identity and Delegated Authority The two-layer model an autonomous agent needs to pass before any credential-custody or permission question even applies: a cryptographic workload identity proving what it is (SPIFFE/SPIRE, cloud workload identity federation) and a separate delegated-authority grant proving it may act on a human's or org's behalf (OAuth scopes, RFC 8693 token exchange, RFC 8707 audience binding).
- — How to Measure AI Agent Quality from Live User Feedback How to measure AI agent quality from live user feedback: why explicit ratings are sparse and biased, how re-asks, abandonment and escalations mislead, and how to join each signal to a trace and route it to review.
- — How to Log RAG Retrieval in Production for Debugging Agent Answers How to log RAG retrieval in production so a wrong agent answer can be debugged: per-retrieval fields, what reached the context window versus what the model cited, privacy by hashes and IDs, and retention and sampling choices.
- — How to Turn an AI Agent Incident into an Evaluation Test Case How to turn an AI agent incident into an evaluation test case: freeze the trace, redact it, minimize it to the failing decision, label the expected outcome with a trusted oracle, prove it fails then passes, and retire it later.
- — How to Track AI Agent Costs in Production How to track AI agent costs in production: version your price table, separate cached from uncached tokens, keep failed runs in the books, attribute shared costs, reconcile against the invoice, and alert on rate of spend.
- — Designing an LLM-as-Judge Pipeline for Production AI Agents An operator playbook for screening live AI agent output with an LLM judge: a confidence/stakes routing architecture to a human queue, continuous live-traffic rubric design, and per-bias mitigations for position, verbosity, and self-preference.
- — ACP vs. AP2 vs. x402: Which Agent Payment Rail Should You Implement? A decision framework for choosing between ACP, AP2, and x402 (plus the self-hosted 402 gate) — sorted by who your buyer actually is, what you are selling, and what is live versus waitlisted as of July 2026.
- — Distributed Tracing for Multi-Agent AI Systems How trace ID propagation actually works across a multi-agent handoff, why handoff and delegation need different trace shapes, and why an orchestrator-level trace can hide a failed leg of a fan-out.
- — Fraud and Abuse from AI Agent Traffic: What a Seller Should Detect How a seller of APIs, content, or tools to AI agents spots and mitigates abuse once access is already granted — key sharing, over-scope scraping, spend-ceiling circumvention, spoofed identity, and rate-limit evasion patterns specific to autonomous agents.
- — How Do AI Agents Discover Paid APIs? A Guide to Every Surface How an AI agent finds out a paid API or resource exists before it ever reads a price: llms.txt, the JSON API index, MCP registries, incidental 402 discovery, x402 auto-listing, and what .well-known does and does not cover.
- — How to Implement OAuth 2.1 for an MCP Server A wire-level implementation walkthrough for OAuth 2.1 on a remote MCP server: what the discovery documents actually contain, CIMD vs. Dynamic Client Registration in your server code, per-SEP detail from the 2026-07-28 hardening set, and token-validation mechanics.
- — Implementing an HTTP 402 Paywall an Agent Can Actually Pay A working implementation guide for machine-payable content: the 402 response body, Link headers, key issuance and validation, caching rules, and the mistakes that make a 402 gate unpayable.
- — Issuing API Keys to AI Agents Automatically: A Build Guide How to design a system that mints and delivers API keys to agent and software buyers with minimal human friction: trigger models, storage, delivery, key format, tiering, rotation and revocation — illustrated with ChangeGamer's own Stripe-webhook mechanism.
- — Licensing Content for AI Training: RSL, Terms, and Provenance How to publish machine-readable licence terms for AI use — what RSL is, what it does and does not do, how it differs from robots.txt and Content Signals, and where provenance standards fit.
- — llms.txt vs robots.txt vs sitemap.xml: Which File Does What The three root-level files every agent-ready site publishes, what each one is actually for, and why publishing one does not substitute for the others.
- — MCP Authentication and the Production MCP Server Playbook MCP authentication with OAuth 2.1, plus transport, tool design, versioning, testing, distribution and observability for a production MCP server.
- — MCP Server Versioning and Spec Migration: An Operator Playbook A migration runbook for MCP server operators: feature-detecting via capabilities instead of hard protocolVersion branching, a dual-version fleet rollout with rollback triggers, a compatibility shim for legacy clients still sending initialize, and a deprecation calendar built off the 12-month SEP-2577 floor.
- — Packaging a Corpus as a Product: Format, Schema, Versioning and Delivery The packaging decisions behind selling a content corpus as a dataset product — export format, the free-sample/gated-full split, a per-record metadata schema, a corpus version number, and which of three delivery mechanisms to use — grounded in ChangeGamer's own three real export formats.
- — Running an MCP Server as a Distribution Channel for Your Content Why a content site should expose an MCP server, which tools to ship, how discovery and authentication work, how to gate paid tools, and the honest limits of the channel.
- — Serving Markdown Variants to AI Agents: The Cheapest Win in AI Visibility How to publish a .md twin of every page — URL patterns, content negotiation, discovery headers, generation pitfalls — and why it cuts what an agent pays to read you.
- — stdio vs. Streamable HTTP for MCP Servers: A Decision Framework Which MCP transport to build against and why: the single-client-vs-shared decision rule, how state works without a session handshake under the 2026-07-28 spec, the auth-model switching cost, and what actually breaks migrating off HTTP+SSE.
- — Structured Data for AI Agents: Which Schema.org Types Earn Their Keep Most schema.org markup is invisible to machine readers. The types that are worth the effort for AI agents, how to emit them without drift, and what to build instead of more markup.
- — Agent Checkout vs. Human Checkout: Why Your Payment Flow Fails Machine Buyers Why checkout built for a person watching a screen is unusable by an AI agent, and what a checkout flow that actually completes for a machine buyer looks like — 402 + API key versus native x402.
- — How to Secure AI Agents in Production Credential hygiene, prompt-injection defense in depth, sandboxing choices for code execution, supply-chain provenance, least privilege, audit trails, incident response, and rate/abuse controls — eight operator-side defenses against an adversarial actor or a compromised dependency, not against ordinary load or failure.
- — The AI Agent Security Checklist A go/no-go checklist that turns the agent security operations pillar's eight disciplines, plus content provenance, agent identity, and data privacy, into checkable gates — the specific inventory row, test result, or logged decision that proves each one holds, with a link to whichever sibling article owns its mechanics.
- — How to Protect PII and Personal Data in AI Agent Pipelines Why an AI agent expands PII exposure past a bounded API call — large ingested context, external tool calls, persistent memory and logs, provider training risk — and the containment controls, provider data-handling terms, and GDPR/EU AI Act/CCPA compliance boundary that follow from it.
- — How to Rate-Limit and Cap Spend for Your Own AI Agent Enforcement mechanics for the two ceilings an agent operator should set before production: where a per-credential tool-call counter has to live to stay correct under concurrent calls, where a spend ceiling gets checked in the tool-call loop, and how to reject out-of-scope tool-call arguments with canonicalization rather than a naive prefix match.
- — How to Verify Content Provenance for AI Agents with C2PA A three-state decision procedure — valid manifest, invalid signature, absent manifest — for what an AI agent's ingestion pipeline should do differently with a web image, an email attachment, or a retrieved document, plus a checklist for wiring a C2PA reader library into that pipeline as a gate before content reaches the model.
- — How to Build an Audit Trail for an AI Agent A field-by-field forensic playbook for an AI agent audit log: why each of the checklist's seven required fields matters for reconstruction, a worked incident walkthrough, and the real tension between OpenTelemetry's redact-by-default tracing and full audit logging.
- — How to Respond When an AI Agent Takes a Harmful Action Why the pillar's cut-credential, stop-instance, export-evidence order is structurally forced rather than a tidy convention, a concrete answer for who holds standing revocation authority, a pre-incident drill for the evidence-export path, and what changes when the compromised credential belongs to a third-party tool server instead of the agent itself.
- — How to Enforce Permission Boundaries for AI Agents at Runtime How a least-privilege grant actually gets enforced once an agent is running — the eight named checkpoints, five verdicts, and fail-closed contract in Microsoft's draft Agent Control Specification (ACS), and what happens when the policy engine that enforces the boundary breaks.
- — How to Verify Supply-Chain Provenance for AI Agent Dependencies An operational playbook for three separate trust-boundary gates — package-install time, model-load time, and MCP-server-connect time — that turns SBOM and attestation formats into checks a pipeline can actually run, plus a fail-closed default for the dependency that carries neither.
- — How to Choose a Sandbox for AI Agent Code Execution A two-axis framework — trust in the code's source crossed with the blast radius of a successful escape — for picking an isolation layer, choosing among six hosted sandbox APIs, and hardening the harness around whichever one you pick.
- — How to Defend an AI Agent Against Prompt Injection A decision framework for matching Action-Selector, Plan-Then-Execute, Dual LLM, and the other named architectural patterns to a task's actual blast radius, including when to compose two patterns together and when none of them is worth the overhead.
- — When Is RAG the Wrong Answer? A Decision Guide A worked decision guide for the four real alternatives to retrieval-augmented generation: including knowledge directly, querying structured data with text-to-SQL, fine-tuning for behavior change, and graph-based retrieval for entity relationships.
- — Agent Guardrails and the AI Agent Reliability Playbook Agent guardrails plus the eleven other disciplines that make an AI agent reliable in production: tool calling, retries, durable execution and rollout.
- — Agentic RAG in Production: The Complete Operator Guide The operator playbook for agentic RAG in production: ingestion, chunking, hybrid retrieval, reranking, evaluation, freshness and cost.
- — How to Accept x402 Stablecoin Payments: A Seller Implementation Guide A build guide for sellers who have already decided x402 is the right rail: the 402 response shape, the wallet/facilitator/network choices, the verify-then-settle retry flow, exact vs. upto pricing, and how to ship it dormant until you are ready to go live.
- — How to Publish an MCP Server to the Official Registry A step-by-step walkthrough of the mcp-publisher CLI and the server.json manifest for publishing an MCP server to registry.modelcontextprotocol.io, how to republish after a version bump, and how the registry relates to aggregators, marketplaces, and direct distribution.
- — llms.txt and the Agent-Ready Website Playbook How to make a site work for AI agents: llms.txt, crawler access, structured data, licensing and machine-payable access, with a 30-day plan.
- — x402 Protocol and the Guide to Selling to AI Agents The operator playbook for the x402 protocol and selling content, APIs and tools to AI agents that discover, evaluate and pay on their own.
- — How to Test an MCP Server in CI The implementation mechanics below the three-layer test pyramid: what a mocked MCP transport actually replaces, what a Streamable HTTP cassette contains, a concrete CI job/trigger shape, and how to catch spec-version drift before it reaches production.
- — How to Manage Secrets for AI Agents in Production Why single-agent credential issuance is not the whole secrets problem: auditing which tool servers and MCP connectors hold credentials on an agent's behalf, treating provider-side prompt caches as a disclosure surface, and the named frameworks — OWASP's Secrets Management Cheat Sheet, Twelve-Factor config, and the OWASP GenAI project — that govern the rest.
- — The AI Agent Production Reliability Checklist A go/no-go checklist that turns the agent reliability pillar's twelve-discipline closing list into checkable gates — the specific artifact, header, or trace field that proves each one holds, with a link to whichever sibling article owns its mechanics.
- — What Should an AI Agent's Observability System Capture? An operator playbook for instrumenting an AI agent: the trace/span model behind a run, the OpenTelemetry GenAI attributes that name each field, the fields worth capturing per span, and what to redact before any of it gets logged.
- — How to Design a Circuit Breaker for AI Agents A deep-dive on the circuit breaker pattern for AI agents: the Closed/Open/Half-Open state machine with a worked open-source example, where to place a breaker in an agent's call path, and degraded-mode fallback design as its own discipline per dependency type.
- — How to Set Timeouts for AI Agent Tool Calls A deep-dive on timeout and deadline design for AI agents: sizing LLM-call, tool-call, and sub-agent-hop timeouts differently, allocating a wall-clock budget across a multi-step chain, and propagating a remaining-deadline value from parent to child calls.
- — How to Build an Incident Response Runbook for AI Agent Failures An operator playbook for the moment an AI agent fails in production: a triage step to classify the failure fast, trace freezing before rollback destroys the evidence, first-response depth on the four failure classes, and a blameless post-mortem that feeds back into guardrails and eval.
- — How to Roll Out a New AI Agent Version Safely An operator playbook for shipping a new agent version without breaking production: in-repo vs. registry prompt storage, a version-numbering comparison, the six-step promotion flow, A/B-test mechanics, the composite-version trace fields, and a rollback drill.
- — How to Design Guardrails for AI Agent Reliability An operator playbook for reliability guardrails: the three checkpoints (input, output, action), layering cheap checks under slow ones with a fail-closed default, the two-of-three-properties rule for when a tool call needs human approval, and logging every verdict against the run trace ID.
- — How to Evaluate AI Agents in CI An operator playbook for gating an AI agent release in CI: why agent eval needs trajectory-level scoring across the tasks it actually runs, how public benchmarks diverge as proxies, ground-truth vs LLM-as-judge tool-call scoring, and the three-layer test pyramid that keeps CI fast and non-flaky.
- — How to Make AI Agent Retries Idempotent A deep-dive on retrying agent tool calls safely: the transient-vs-terminal decision, why an agent side effect can fire before a failure signal reaches the caller, idempotency-key mechanics (run ID + step index), the unknown-outcome edge case, and where idempotency keys do not reach.
- — When Do AI Agents Need Durable Execution? A deep-dive on durable execution for AI agents: the persisted event log, the replay-determinism constraint, the four architectural shapes mapped across ten engines and frameworks, and a decision framework for when a durable execution engine is worth adding at all.
- — How to Make AI Agent Tool Calling Reliable An operator playbook for tool-calling contracts: per-provider strict-mode config (OpenAI, Anthropic, Gemini, self-hosted grammars), the full failure-mode-to-fix table, what BFCL actually measures, and how to stop parallel tool calls from breaking a dependency chain.
- — Structured Outputs vs Tool Calling: When to Use Each A decision framework for structured outputs versus tool calling in AI agents, with runnable JSON Schema examples for OpenAI, Anthropic, Gemini, vLLM/SGLang, and llama.cpp, plus mitigation code for truncation, refusal, and grammar-compilation latency.
- — Common RAG Failure Modes and How to Fix Them An operator runbook for the four RAG failure classes with no dedicated deep-dive elsewhere: retrieval miss, context overload, injection via content at ingestion time, and silent quality degradation — symptom, first diagnostic, and fix for each.
- — GraphRAG vs Vector RAG: When to Use a Knowledge Graph Instead A decision framework for choosing graph-structured retrieval over standard vector RAG: which query types GraphRAG actually wins, what building a knowledge graph costs, named implementations, and hybrid vector-plus-graph patterns.
- — How to Build a RAG Ingestion Pipeline That Survives Production The six properties that separate a production RAG ingestion pipeline from a demo script: tested extraction, idempotent writes, incremental updates, deletion propagation, durable execution, and metadata captured at ingest time.
- — How to Choose an Embedding Model for RAG (and Version It Like a Schema) Embedding selection as an operations problem: the criteria that dominate total cost of ownership, the never-mix-spaces invariant, reindex migrations with dual indexes, and where quantization fits once cost shows up.
- — How to Chunk Documents for RAG (Strategy Beats Size) Chunking decisions that actually move retrieval quality: structural boundaries before fixed windows, parent-document expansion, special handling for tables and code, overlap trade-offs, and tuning against recall@k instead of blog defaults.
- — How to Combine Keyword and Vector Search in RAG Why hybrid retrieval is the production default rather than an upgrade: complementary failure modes of lexical and dense search, reciprocal rank fusion versus weighted scoring, parameter choices, and how filtering interacts with fusion.
- — How to Cut RAG Cost and Latency Without Cutting Quality RAG cost and latency as engineered budgets: where the money actually goes, caching layers and their hit-rate economics, routing queries to right-sized models, bounding retrieval fan-out, the hidden lines (reindex migrations, eval compute), and p95 discipline.
- — How to Evaluate a RAG System (Retrieval Metrics, Generation Metrics, CI Gates) The evaluation harness that keeps RAG changeable: golden-set construction, retrieval metrics separated from generation metrics, LLM-as-judge screening with human acceptance, CI regression gates, and the logged-query flywheel.
- — How to Keep a RAG Index Fresh (Staleness Bounds, Not Vibes) Freshness as an engineered property: per-source staleness contracts, document versioning and tombstones, effective-date filtering, deletion propagation with reconciliation backstops, and the sync-lag metrics that predict stale answers before users report them.
- — Permission-Aware Retrieval: Multi-Tenant RAG Without Leaks How to enforce access control inside retrieval for multi-tenant RAG: authorization as mandatory pre-filters derived from the authenticated principal, tenant isolation mechanics, permission-negative testing, and the post-filter trap that produces empty answers.
- — Retrieval as a Tool: Agentic RAG Patterns That Survive Production When AI agents consume retrieval as a tool rather than a pipeline stage: narrow tool contracts, hard budgets on iterative retrieval, query decomposition, provenance-carrying results, and keeping trust boundaries inside the retrieval path.
- — When and How to Rerank Retrieved Documents in RAG Reranking as a budget decision: why first-stage ranking misorders good evidence, when cross-encoder reranking pays for itself, how to pick candidate depth at the knee, gating by query difficulty, and deduplicating after fusion.
- — The MCP Server Production Launch Checklist A phase-by-phase go/no-go checklist for launching an MCP server: checkable gate conditions for transport and auth, tool design, cross-client testing, publish readiness, observability, and ongoing operation — with links to the mechanics each gate depends on.
- — Zero-Touch Enterprise Authorization for MCP Servers: ID-JAG and SEP-990 How Enterprise-Managed Authorization (SEP-990) removes the per-server OAuth consent screen for MCP servers: the ID-JAG grant mechanism, its RFC 8693/7523 building blocks, named launch adopters as of August 2026, and how it layers on top of standard OAuth 2.1 rather than replacing it.
- — Common MCP Server Failure Modes and How to Fix Them A runtime playbook for the two MCP server failure modes with no dedicated deep-dive elsewhere: unrecoverable state after a mid-call crash, and malformed or hallucinated tool calls that reach the handler despite upstream validation.
- — MCP Tools vs Resources vs Prompts: How to Choose the Right Primitive A decision procedure for MCP's three server-side primitives — who controls each one, a worked example of what it costs to expose a Resource as a Tool by mistake, and how Sampling and Elicitation fit as the client-side counterparts.
- — MCP Server Cost Optimization: Toolset Size, Caching Hints, and Fan-Out How the token cost of an MCP server's tool list, the 2026-07-28 spec's ttlMs/cacheScope caching hints, fan-out from callers you do not control, and per-tool-name cost visibility each shape what a production MCP server actually costs to run.
- — MCP Server Observability with OpenTelemetry: Spans, Metrics, and Trace Correlation Instrumenting an MCP server past the pillar's baseline: what to put on a tool-call span beyond gen_ai.tool.name, what replaces the deprecated Logging primitive in practice, per-tool-name latency and error-rate metrics, and how a trace ID actually survives the agent-to-upstream-API hop.
- — Defending MCP Clients Against Tool Description and Output Injection Two distinct MCP injection surfaces — a tool description at connect-time and a tool's return value at call-time — and the client-side architectural patterns (Dual LLM, Action-Selector, Context-Minimization) that contain each one.
- — Measuring Revenue from AI Agent Traffic: Beyond the Traffic Log The revenue-layer fields and queries a seller adds on top of a general traffic log — authorized-vs-settled, revenue per rail, revenue per tier, and how to avoid double-counting a webhook retry as two sales.
- — Agent Spend Limits and Trust: What a Seller Should Verify Before Granting Access The seller-side counterpart to agent spend controls — how an API operator reads an inbound agent's spend ceiling before granting access, which payment protocols actually prove that ceiling, how to revoke access, and what "trust" operationally means for a seller when no portable agent-reputation standard exists yet.
- — Refunds and Disputes with Agent Buyers: What a Seller Actually Does What happens on the seller side when an autonomous agent's purchase needs to be reversed or is disputed — API-key refund mechanics, why x402 settlement cannot be undone, what card-token revocation does and does not prove, and what to log before you reverse anything.
- — Pricing Tiers for API and Corpus Access: What Actually Varies Between Them The axes that actually distinguish one pricing tier from another for a machine buyer — rate limits, content scope, deliverables and license grant — and how ChangeGamer structures its own four tiers around deliverable and license, not gated content.
- — Machine-Readable Pricing Pages: How to Let an Agent Evaluate Your Offer Before It Pays Why a prose pricing page cannot be evaluated by an AI agent, what fields a machine-readable offer catalog needs, and how to keep it in lockstep with your human pricing page and your 402 body.
- — How AI Search Engines Choose Sources (And What You Can Actually Influence) What is known, what is claimed and what is speculation about how ChatGPT, Perplexity and AI Overviews pick the pages they cite — and the short list of things a site owner can actually control.
- — How to Write an llms.txt File (Format, Template, and Maintenance) A step-by-step guide to writing a useful llms.txt: the exact format, a copy-paste template, what to put under ## Optional, how to validate it, and how to keep it from rotting.
- — JSON API Design for AI Agents: Endpoints They Prefer Over Scraping How to publish read-only JSON endpoints that agents choose over scraping your HTML: discovery index, stable shapes, freshness signals, bulk exports, and errors a machine can act on.
- — Measuring AI Agent Traffic: Server-Side Telemetry That Answers Real Questions Why client-side analytics miss AI agents entirely, the minimum row schema to log, the five queries worth running, and how to tell a real crawler from a spoofed user agent.
- — Should You Block AI Crawlers? A Decision Framework by Business Model Blocking AI crawlers is four separate decisions, not one. A framework that maps each crawler class to what it costs and earns you, by business model, with the exact robots.txt for each answer.
- — What to Charge AI Crawlers: Pricing Models for Machine Buyers Per-crawl, per-resource, corpus licence or subscription key — the four ways to price AI access, the arithmetic behind each, and why pricing before you have demand data is the standard mistake.
- — Why AI Agents Can't Read Your Site: Twelve Failure Modes and How to Find Them A diagnostic catalogue of the twelve reasons AI agents and crawlers fail on real sites — from silent WAF blocks to JS-only rendering — each with the command that detects it and the fix.