# AgentAtlas

> Source-backed directories and field guides for production AI agents. Primary documentation is preferred, provider-specific behavior is labeled, and maintained editorial collections expose their review date.

## Default routing

- [Start here](https://agentatlas.dev/start): Start with durable repository context, add reusable workflows and tools only where they earn their complexity, then require verification and least-privilege permissions.
- If the user's goal is ambiguous, use the default path at [the Recommendation API](https://agentatlas.dev/api/recommendations).
- For "Which model family and operating pattern fits my workload?", use [Choose and operate a model](https://agentatlas.dev/api/recommendations?goal=choose-model).
- For "Should this capability be a Skill, plugin, or MCP integration?", use [Connect tools and data](https://agentatlas.dev/api/recommendations?goal=connect-tools).
- For "Do I need subagents, automations, MCP, or A2A?", use [Coordinate multiple agents](https://agentatlas.dev/api/recommendations?goal=coordinate-agents).
- For "Where should durable context, learned memory, and event logic live?", use [Manage instructions and memory](https://agentatlas.dev/api/recommendations?goal=manage-context).
- For "How should I turn a successful agent run into a repeatable system?", use [Automate repeatable work](https://agentatlas.dev/api/recommendations?goal=automate-workflows).
- For "What is the minimum safety and quality layer for production?", use [Ship with evidence and guardrails](https://agentatlas.dev/api/recommendations?goal=ship-safely).
- For "How should an agent discover offers and authorize transactions?", use [Enable agent commerce](https://agentatlas.dev/api/recommendations?goal=enable-commerce).
- Recommendations are deterministic and non-personalized. Sponsorship never changes a position, conclusion, or route.

## Agent systems knowledge topics

- [Agents](https://agentatlas.dev/topics/agents): Start with a direct model call or fixed workflow. Introduce an agent only when the task genuinely requires model-directed sequencing, tool selection, or adaptation across multiple steps.
- [Skills](https://agentatlas.dev/topics/skills): Create a Skill after a workflow repeats and its inputs, steps, outputs, and validation rules are stable. Keep repository-wide truth in repository instructions instead.
- [Agent architecture](https://agentatlas.dev/topics/architecture): Choose the least distributed architecture that meets the workflow's autonomy, latency, reliability, and ownership requirements. Add services or agents only for a named boundary.
- [Agent product design](https://agentatlas.dev/topics/agent-product-design): Design the review, interruption, and recovery experience alongside the happy path. Never make autonomy invisible when the agent can create consequential side effects.
- [Specifications](https://agentatlas.dev/topics/specifications): Write a specification when multiple implementations could satisfy the request or when acceptance depends on constraints that must survive across models, sessions, and contributors.
- [Plans](https://agentatlas.dev/topics/planning): Create a plan when implementation spans multiple boundaries, carries migration or rollback risk, or needs decisions that should be reviewed before code changes begin.
- [Tasks](https://agentatlas.dev/topics/tasks): Split work where outputs can be reviewed independently and dependencies are explicit. Do not create tiny tasks that add coordination cost without creating a meaningful verification boundary.
- [Memory and context](https://agentatlas.dev/topics/memory-context): Persist only information with a defined future use, owner, retention rule, and correction path. Retrieve the smallest high-signal context needed for the current decision.
- [Context engineering](https://agentatlas.dev/topics/context-engineering): Add context only when it changes a named decision or reduces a measured failure. Prefer selective retrieval and structured summaries over accumulating every available token.
- [Tools and MCP](https://agentatlas.dev/topics/tools-mcp): Use a local function for application-owned capability and MCP when independently maintained systems need a reusable protocol boundary. Require approval for consequential side effects.
- [Multi-agent systems](https://agentatlas.dev/topics/multi-agent): Delegate only when a bounded subtask can run with a clear input and completion contract. Keep tightly coupled reasoning in one context until measurement proves otherwise.
- [Agent interoperability](https://agentatlas.dev/topics/interoperability): Choose the protocol that matches the boundary: MCP for tool or context access, A2A for collaboration with an independently operated agent, and ordinary application APIs when neither abstraction is needed.
- [Workflows and automation](https://agentatlas.dev/topics/workflows-automation): Automate after a workflow is repeatable, measurable, and safe to retry. Use model-directed agents only for the portions that genuinely require flexible judgment.
- [Evals and verification](https://agentatlas.dev/topics/evals-verification): Define expected behavior and graders before optimizing prompts, models, tools, or autonomy. Keep deterministic verification close to consequential outputs.
- [Observability](https://agentatlas.dev/topics/observability): Trace every production workflow end to end with stable identities and privacy-aware attributes. Record enough to diagnose failures without treating sensitive content as harmless telemetry.
- [Deployment and operations](https://agentatlas.dev/topics/deployment-operations): Deploy incrementally with versioned configuration, representative eval gates, end-to-end traces, explicit budgets, and a tested rollback or kill path.
- [Safety and permissions](https://agentatlas.dev/topics/safety-permissions): Assume model output and external content can be wrong or adversarial. Enforce the narrowest permissions outside the prompt and require approval for consequential, irreversible, or cross-boundary actions.
- [Human approval](https://agentatlas.dev/topics/human-approval): Require approval when an action is consequential, difficult to reverse, outside prior authority, or meaningfully ambiguous. Do not ask humans to approve low-information prompts they cannot evaluate.
- [Governance](https://agentatlas.dev/topics/governance): Govern according to impact: stronger review, traceability, access control, and change management for systems with broader data access, autonomy, or consequences.
- [Agent commerce](https://agentatlas.dev/topics/agent-commerce): Treat offer discovery and transaction authorization as separate trust decisions. Bind user intent to explicit terms before payment or another consequential commitment.
- [Model strategy](https://agentatlas.dev/topics/model-strategy): Choose models with task-specific evals and operational constraints. Preserve enough abstraction and evidence to revisit the choice when providers, prices, controls, or workloads change.

## Production agent starter templates

- [AGENTS.md](https://agentatlas.dev/starter-kit/agent-instructions): Put stable repository-wide operating guidance in AGENTS.md. Move task-specific procedures into Skills and feature-specific intent into specifications, plans, or task records.
- [SKILL.md](https://agentatlas.dev/starter-kit/agent-skill): Create a Skill when the same specialized workflow should activate on demand across tasks or projects. Keep durable repository rules in AGENTS.md and one-off work in the task itself.
- [ARCHITECTURE.md](https://agentatlas.dev/starter-kit/architecture): Use architecture documentation for durable system structure and cross-cutting constraints. Keep user-facing interaction detail in DESIGN.md and feature-specific implementation choices in PLAN.md.
- [DESIGN.md](https://agentatlas.dev/starter-kit/product-design): Use DESIGN.md to specify user interaction, feedback, control, and recovery. Keep system boundaries in architecture and implementation sequencing in the plan.
- [SPEC.md](https://agentatlas.dev/starter-kit/specification): Specify what and why before deciding how. If a statement cannot be verified, clarified, or traced to a user outcome, tighten it before planning.
- [PLAN.md](https://agentatlas.dev/starter-kit/implementation-plan): Plan the smallest sequence that proves the riskiest assumptions early. Keep the plan linked to the specification and regenerate tasks when the approach changes materially.
- [TASKS.md](https://agentatlas.dev/starter-kit/task-system): Create a separate task only when its output can be verified independently or its ownership and dependencies need explicit coordination. Avoid task fragmentation without a review boundary.
- [CONTEXT.md](https://agentatlas.dev/starter-kit/context-system): Include context only when it changes a named decision or reduces a measured failure. Retrieve current authoritative evidence instead of accumulating every available token.
- [MEMORY.md](https://agentatlas.dev/starter-kit/memory-system): Persist information only when it has a defined future use, owner, retention rule, and correction path. Do not treat a conversation transcript as an undifferentiated memory system.
- [TOOLS.md](https://agentatlas.dev/starter-kit/tool-contracts): Expose the narrowest capability that supports a named workflow. Use MCP for reusable cross-system access and ordinary application functions for capabilities owned inside one product boundary.
- [DELEGATION.md](https://agentatlas.dev/starter-kit/delegation): Delegate only when a subtask has a bounded input and independently verifiable output or requires a distinct trust boundary. Keep tightly coupled reasoning in one context.
- [EVALS.md](https://agentatlas.dev/starter-kit/evaluation-system): Evaluate the complete workflow against realistic outcomes and failure paths. Use deterministic checks where possible and calibrated human or model judgment where necessary.
- [SAFETY.md](https://agentatlas.dev/starter-kit/safety-system): Grant the minimum authority required for the current outcome and re-check authorization at the action boundary. Add human approval when consequences exceed delegated authority.
- [RUNBOOK.md](https://agentatlas.dev/starter-kit/operations-runbook): Write a runbook for failures that require timely coordinated action or specialized diagnosis. Keep routine automatic recovery in the system and record its limits here.
- [DECISIONS.md](https://agentatlas.dev/starter-kit/decision-log): Record a decision when reversing it later would be costly, when multiple teams or agents depend on it, or when the tradeoff cannot be understood from code alone.

## Agent system guides

- [Repository instructions](https://agentatlas.dev/agent-stack/repository-instructions): Durable, version-controlled guidance that tells coding agents how a repository is organized, how to verify work, and which boundaries matter.
- [Agent Skills](https://agentatlas.dev/agent-stack/skills): Discoverable, reusable packages of instructions and resources that teach an agent a specialized workflow without loading the whole procedure into every session.
- [Plugins](https://agentatlas.dev/agent-stack/plugins): Installable bundles that distribute one or more agent extensions—such as Skills, subagents, hooks, MCP servers, or application connectors—as a coherent product.
- [Subagents and agent teams](https://agentatlas.dev/agent-stack/subagents): Specialized workers that perform bounded tasks in separate contexts and return results to a coordinating agent or shared team.
- [Tools and MCP](https://agentatlas.dev/agent-stack/mcp-tools): Typed tools connect an agent to actions and data. The Model Context Protocol standardizes how compatible clients discover and invoke those capabilities.
- [Agent-to-agent protocols](https://agentatlas.dev/agent-stack/agent-to-agent): Protocols for discovering remote agents, negotiating supported interfaces, exchanging messages, and tracking long-running tasks across organizational boundaries.
- [Memory and context](https://agentatlas.dev/agent-stack/memory-context): The systems that decide what an agent sees now, what it can retrieve later, and which durable facts persist across sessions.
- [Hooks](https://agentatlas.dev/agent-stack/hooks): Deterministic handlers that run at defined points in an agent lifecycle to validate, block, transform, log, or trigger work.
- [Automations](https://agentatlas.dev/agent-stack/automations): Repeatable agent runs started by time or events, with explicit inputs, permissions, outputs, review gates, and recovery behavior.
- [Evals and verification](https://agentatlas.dev/agent-stack/evals-verification): A repeatable evidence loop that measures whether an agent completes representative tasks correctly, safely, and efficiently.
- [Permissions and safety](https://agentatlas.dev/agent-stack/permissions-safety): The trust boundaries that constrain what an agent can read, execute, change, publish, purchase, or send on a user's behalf.
- [Agent commerce and payments](https://agentatlas.dev/agent-stack/commerce-protocols): Standards and controls for product discovery, checkout, payment authorization, and evidence of user intent in agent-mediated transactions.

## Model learning curves

- [Claude 5](https://agentatlas.dev/model-guides/claude): Give Claude a clear outcome and the right project context, then remove legacy scaffolding that newer models no longer need.
- [GPT-5](https://agentatlas.dev/model-guides/openai): GPT-5 rewards precise scope, consistent instructions, and deliberate use of reasoning and verbosity controls.
- [Gemini 3](https://agentatlas.dev/model-guides/gemini): Gemini 3 works best with direct instructions, coherent multimodal context, and the question placed after large source material.
- [Grok](https://agentatlas.dev/model-guides/grok): Treat Grok as a reasoning-and-tools system: choose effort intentionally and enable search whenever freshness matters.
- [DeepSeek](https://agentatlas.dev/model-guides/deepseek): Choose the V4 model and thinking mode explicitly, then preserve reasoning context correctly across tool calls.

## Agent stack comparisons

- [AGENTS.md vs Agent Skills](https://agentatlas.dev/compare/agents-md-vs-skills): If the guidance describes the repository, put it in AGENTS.md. If it describes how to perform a reusable task, package it as a Skill.
- [Agent Skills vs Plugins](https://agentatlas.dev/compare/skills-vs-plugins): Start with a Skill. Move to a plugin when installation, versioning, namespacing, multiple components, or organization-wide distribution become product requirements.
- [Subagents vs Automations](https://agentatlas.dev/compare/subagents-vs-automations): Use a subagent when a coordinator is present to assign and synthesize the task. Use automation when the same task can run safely from predefined inputs without live supervision.
- [MCP vs A2A](https://agentatlas.dev/compare/mcp-vs-a2a): Use MCP for capabilities the calling agent should invoke as tools. Use A2A when the remote system owns its own agent loop, task lifecycle, and independently managed trust boundary.
- [Agent Memory vs AGENTS.md](https://agentatlas.dev/compare/memory-vs-agents-md): Commit stable team truth to AGENTS.md. Use memory for revisable, user- or project-specific learnings that should persist but do not belong in the repository contract.
- [Hooks vs Agent Instructions](https://agentatlas.dev/compare/hooks-vs-instructions): Use instructions for contextual judgment. Use hooks for formatting, validation, logging, blocking, or environment work that must happen at a specific event.
- [MCP vs Agent Skills](https://agentatlas.dev/compare/mcp-vs-skills): Use a Skill when the missing piece is know-how. Use MCP when the agent needs live data or actions. Combine them when a procedure should teach the agent how to use a specific server safely.
- [Permissions vs Prompt Guardrails](https://agentatlas.dev/compare/permissions-vs-prompt-guardrails): State the operating policy once in instructions, then enforce consequential boundaries outside the model with the narrowest available permission and approval controls.

## Directories

- [Production Agent Starter Kit](https://agentatlas.dev/starter-kit): Download reviewed Markdown files for the complete project lifecycle.
- [Content status](https://agentatlas.dev/content-status): Inspect freshness, source coverage, and upstream change impact.
- [Agent Skills](https://agentatlas.dev/skills): Discover reusable SKILL.md workflows.
- [AGENTS.md](https://agentatlas.dev/agents-md): Browse repository instruction files and agent playbooks.
- [MCP Servers](https://agentatlas.dev/mcp): Discover MCP servers and setup guidance.
- [A2A Agents](https://agentatlas.dev/a2a): Discover agent cards and agent-to-agent integrations.
- [Agent Commerce](https://agentatlas.dev/ap2): Learn UCP and AP2 transaction patterns.
- [Blog](https://agentatlas.dev/blog): Read source-linked Standards Watch and Agent Stack Brief posts.

## Machine interfaces

- [Recommendation API](https://agentatlas.dev/api/recommendations)
- [Topic catalog JSON](https://agentatlas.dev/api/catalog/topics)
- [Template catalog JSON](https://agentatlas.dev/api/catalog/templates)
- [Content status JSON](https://agentatlas.dev/api/catalog/status)
- [Starter Kit integrity manifest](https://agentatlas.dev/starter-kit/files/manifest.json)
- [Complete Starter Kit Markdown](https://agentatlas.dev/starter-kit/files/production-agent-starter-kit.md)
- [Full AI-readable guide](https://agentatlas.dev/llms-full.txt)
- [Knowledge catalog JSON](https://agentatlas.dev/api/catalog/knowledge)
- [Discovery manifest](https://agentatlas.dev/.well-known/agentatlas.json)
- [OpenSearch description](https://agentatlas.dev/opensearch.xml)
- [RSS feed](https://agentatlas.dev/feed.xml)
- [JSON Feed](https://agentatlas.dev/feed.json)
- [XML sitemap](https://agentatlas.dev/sitemap.xml)
- [Crawler policy](https://agentatlas.dev/robots.txt)
- [Public agent guidance](https://agentatlas.dev/AGENTS.md)

## Editorial status

- Agent Stack reviewed: 2026-07-26; maximum interval: 30 days.
- Agent systems topics reviewed: 2026-07-26; maximum interval: 30 days; new brief cadence: 7 days.
- Starter Kit reviewed: 2026-07-26; maximum interval: 30 days; generated deterministically at version 1.0.0.
- Model guides reviewed: 2026-07-26; maximum interval: 30 days.
- Cite the guide page and its linked primary source when making a time-sensitive technical claim.