Build Reliable Autonomous Agents

Autonomous Agents is a skill covering the core patterns for building AI agents that decompose goals, plan, execute tools, and self-correct: the ReAct loop (Thought, Action, Observation, alternating reasoning and acting), the Plan-Execute pattern (a separate planning phase followed by execution, with optional re-planning on failure and human approval before execution), and the Reflection or Evaluator-Optimizer pattern (generate, critique against explicit criteria, refine, repeat, ideally using a separate model as evaluator to avoid self-bias). It covers reference implementations in LangGraph, including its production PostgresSaver checkpointing, human-in-the-loop interrupt_before and interrupt_after, and time-travel debugging via get_state_history, plus a Guardrailed Autonomy wrapper pattern that enforces per-step cost limits, an allowed-actions list, human-approval gates for sensitive actions, and checkpoint/rollback on failure. Central to the skill is a reliability argument: a 95% per-step success rate compounds to 77% by step 5, 60% by step 10, and 36% by step 20, so the skill pushes reducing step count and raising per-step reliability over adding autonomy. It also catalogs recurring production failure modes with fixes - compounding error rates, quadratic API cost growth as context expands, demos that don't survive contact with real users, agents fabricating data when stuck, brittle integrations with real (rate-limited, auth-expiring) external systems, unguarded dangerous actions, and context-window exhaustion - each with a severity rating and a concrete remediation pattern.

Use this skill when architecting or reviewing a multi-step autonomous agent - choosing between ReAct, Plan-Execute, and Reflection loops, adding cost or step guardrails, or diagnosing why an agent that worked in a demo is failing in production. It frames 2025's winning pattern as constrained, domain-specific agents with clear boundaries rather than "autonomous everything," and recommends treating AI outputs as proposals, not truth. It is not the right skill for multi-agent orchestration, tool building, or long-term memory design specifically - the source names dedicated sibling skills for those (multi-agent-orchestration, agent-tool-builder, agent-memory-systems, agent-evaluation, workflow-automation, computer-use-agents) and delegates to them.

A goal string plus a tool set is the typical input to any of the loop patterns; output is either a final answer (ReAct), a step-by-step plan plus execution results (Plan-Execute), or a refined artifact plus a pass/fail critique (Reflection). The guardrail and checkpointing patterns take a config dict (max_cost_usd, max_steps, allowed_actions, require_approval) and a thread_id for durable state, and produce a status result (complete or rejected) plus logged cost and action history.

TASK_PERMISSIONS = {
    "research": ["web_search", "read_file"],
    "coding": ["read_file", "write_file", "run_tests"],
    "admin": ["all"],  # Rarely grant this
}

def create_scoped_agent(task_type):
    allowed = TASK_PERMISSIONS.get(task_type, [])
    tools = [t for t in ALL_TOOLS if t.name in allowed]
    return Agent(tools=tools)

Names LangGraph (1.0, with PostgresSaver checkpointing) as the production framework of choice, AutoGPT for open-ended research and experimentation (needs external guardrails), CrewAI for role-based agent teams, and the Claude Agent SDK for computer-use and tool-execution in the Anthropic ecosystem. Also references structlog and LangSmith for tracing, tenacity for retry and backoff on flaky APIs, and Pydantic for structured, validated outputs.

Engineers building or debugging production autonomous agents who need a reliability-first framework - concrete failure modes (compounding error rates, context-cost blowups, fabricated data, dangerous unguarded actions) each paired with a recommended fix - rather than a tutorial on the happy path.