{
 "version": 5,
 "note": "Working taxonomy for Gradient Ascent. A tier is a level ordered by who controls the flow; a track applies at every tier; a thread cuts across tiers; relations are typed edges between pages. Slugs are page ids and must stay stable once published. Every page defaults to status 'planned' until its file says otherwise, so the map always shows the whole territory, written or not.",
 "statuses": [
  "planned",
  "stub",
  "sourced",
  "measured"
 ],
 "domains": [
  "general",
  "engineering"
 ],
 "lanes": {
  "use": "No code. Where this technique already lives in products a reader has, and how to work it well.",
  "build": "Runnable example, trace, failure modes, eval."
 },
 "relation_types": {
  "requires": "Read the target first. Must stay acyclic.",
  "upgrades_to": "Climb to the target when this level fails for the stated reason.",
  "combines_with": "Commonly used together.",
  "alternative_to": "Solves the same problem a different way; the page pair carries a comparison table."
 },
 "tiers": [
  {
   "id": "no-model",
   "order": 0,
   "title": "Conventional software",
   "control": "Your software applies rules, lookups, or established algorithms.",
   "pages": [
    {
     "slug": "order-zero",
     "title": "When not to use a model",
     "covers": [
      "rules and regex",
      "search",
      "forms",
      "classical ML",
      "the cost of a wrong answer"
     ],
     "summary": "How to tell when ordinary code, search or a form is enough.",
     "status": "sourced"
    }
   ],
   "short": "Rules, search, and automation",
   "who": "Your software applies rules, lookups, or established algorithms.",
   "description": "Use ordinary code, search, forms, or a task-specific statistical model when they solve the problem. No generative model is required; classical machine learning can belong here too."
  },
  {
   "id": "one-call",
   "order": 1,
   "title": "Direct prompting",
   "control": "You choose the request; the model generates a response.",
   "pages": [
    {
     "slug": "chat",
     "title": "Chat",
     "covers": [
      "completion in the editor"
     ],
     "summary": "Asking a model a question in a chat app.",
     "status": "sourced"
    },
    {
     "slug": "prompt-engineering",
     "title": "Prompt engineering",
     "summary": "Writing instructions that get consistent results.",
     "status": "sourced"
    },
    {
     "slug": "structured-output",
     "title": "Structured output",
     "summary": "Getting answers in a fixed format such as JSON.",
     "status": "sourced"
    },
    {
     "slug": "inference-time-reasoning",
     "title": "Reasoning at answer time",
     "covers": [
      "extended thinking",
      "self-consistency",
      "best-of-N"
     ],
     "summary": "Letting the model think for longer before it answers.",
     "status": "sourced"
    },
    {
     "slug": "multimodal",
     "title": "Images, audio and video",
     "covers": [
      "images and documents in",
      "image, audio and video out"
     ],
     "summary": "Giving the model images, audio, video and documents, and getting them back.",
     "status": "sourced"
    }
   ],
   "short": "Ask for a response",
   "who": "You choose the request; the model generates a response.",
   "description": "Give the model instructions and receive a response. A conversation repeats this interaction, with a person directing each turn. Prompting, structured output, reasoning, and multimodal inputs can all fit this pattern."
  },
  {
   "id": "context",
   "order": 2,
   "title": "Added context",
   "control": "You or your software select the information supplied to the model.",
   "pages": [
    {
     "slug": "context-engineering",
     "title": "Context engineering",
     "summary": "Deciding what goes into the request, and caching the parts that repeat.",
     "status": "sourced"
    },
    {
     "slug": "embeddings-search",
     "title": "Embeddings and search",
     "summary": "Finding text by meaning instead of by keyword.",
     "status": "sourced"
    },
    {
     "slug": "rag",
     "title": "Retrieval-augmented generation (RAG)",
     "summary": "Searching your documents and giving the results to the model.",
     "status": "measured"
    },
    {
     "slug": "knowledge-graphs",
     "title": "Knowledge graphs and GraphRAG",
     "graph_engineering": "information",
     "covers": [
      "entities and relations",
      "multi-hop questions",
      "provenance"
     ],
     "summary": "Storing facts as entities and relations, for questions that span several documents.",
     "status": "sourced"
    },
    {
     "slug": "memory",
     "title": "Memory",
     "summary": "Keeping information from one conversation to the next.",
     "status": "sourced"
    }
   ],
   "short": "Supply relevant information",
   "who": "You or your software select the information supplied to the model.",
   "description": "Add relevant documents, retrieved passages, or stored information to the current request. This supplies context beyond the model’s training without retraining it. Missing, stale, or misleading material can still produce a poor answer."
  },
  {
   "id": "workflows",
   "order": 3,
   "title": "Workflows",
   "control": "Software defines the steps and allowed branches; model outputs can select among them.",
   "pages": [
    {
     "slug": "prompt-chaining",
     "title": "Prompt chaining",
     "summary": "Splitting a task into steps, each with its own prompt.",
     "status": "sourced"
    },
    {
     "slug": "routing",
     "title": "Routing",
     "summary": "Sorting inputs and sending each one to the right prompt.",
     "status": "sourced"
    },
    {
     "slug": "parallelization",
     "title": "Parallel calls",
     "covers": [
      "sectioning",
      "voting"
     ],
     "summary": "Running several prompts at once and combining the results.",
     "status": "sourced"
    },
    {
     "slug": "evaluator-optimizer",
     "title": "Write and check",
     "summary": "One prompt writes, another checks, and the loop repeats until the check passes.",
     "status": "sourced"
    },
    {
     "slug": "workflow-graphs",
     "title": "Workflow graphs",
     "graph_engineering": "work",
     "covers": [
      "nodes as steps",
      "edges as transitions",
      "shared state",
      "checkpoints"
     ],
     "summary": "Describing a workflow as steps and the connections between them.",
     "status": "sourced"
    },
    {
     "slug": "human-in-the-loop",
     "title": "Human approval",
     "summary": "Pausing for a person to approve or correct.",
     "status": "sourced"
    }
   ],
   "short": "Software organizes the steps",
   "who": "Software defines the steps and allowed branches; model outputs can select among them.",
   "description": "Connect model calls through predefined steps, branches, checks, and retries. A model can classify an input or evaluate a result to route the workflow; software still defines the available paths."
  },
  {
   "id": "tools",
   "order": 4,
   "title": "Tool use",
   "control": "The model requests an action; software checks and executes it.",
   "pages": [
    {
     "slug": "function-calling",
     "title": "Function calling",
     "summary": "Letting the model call functions that you define.",
     "status": "sourced"
    },
    {
     "slug": "code-execution",
     "title": "Code execution",
     "summary": "Letting the model write code and run it in a sandbox.",
     "status": "sourced"
    },
    {
     "slug": "mcp",
     "title": "Model Context Protocol",
     "covers": [
      "authorization for a remote tool server"
     ],
     "summary": "A standard way to connect models to tools and data.",
     "status": "sourced"
    },
    {
     "slug": "computer-use",
     "title": "Computer and browser use",
     "summary": "Letting the model operate a screen, a mouse and a keyboard.",
     "status": "sourced"
    }
   ],
   "short": "The model requests an action",
   "who": "The model requests an action; software checks and executes it.",
   "description": "The model can request a search, calculation, code execution, or an action in another application. Software enforces permissions, performs the action, and returns the result. Tool use alone does not create an ongoing agent loop."
  },
  {
   "id": "agents",
   "order": 5,
   "title": "Agent loops",
   "control": "The model chooses the next step within limits enforced by software.",
   "pages": [
    {
     "slug": "single-agent",
     "title": "Single agent",
     "covers": [
      "ReAct",
      "plan-and-execute"
     ],
     "summary": "A model that plans, acts and checks its own work in a loop.",
     "status": "sourced"
    },
    {
     "slug": "agent-harness",
     "title": "The agent harness",
     "summary": "Everything around the model in an agent: the loop, tools, context handling, permissions, caps and sandbox.",
     "status": "sourced"
    },
    {
     "slug": "agentic-rag",
     "title": "Agentic RAG and deep research",
     "summary": "An agent that runs its own searches until it has an answer.",
     "status": "measured"
    },
    {
     "slug": "coding-agents",
     "title": "Coding agents",
     "summary": "Agents that read, write, run and test code.",
     "status": "sourced"
    },
    {
     "slug": "skills",
     "title": "Skills",
     "summary": "Reusable instructions that an agent loads when it needs them.",
     "status": "sourced"
    },
    {
     "slug": "voice-agents",
     "title": "Voice agents",
     "summary": "Agents you talk to in real time.",
     "status": "sourced"
    }
   ],
   "short": "Observe, decide, act, repeat",
   "who": "The model chooses the next step within limits enforced by software.",
   "description": "The model uses the goal and observed results to choose an action, revise its approach, or finish. Software executes tools and enforces permissions, approvals, and stopping limits. A run can stop because it is complete, blocked, or out of budget."
  },
  {
   "id": "teams",
   "order": 6,
   "title": "Teams of Agents",
   "control": "Several agents coordinate, delegate, or review work; they can use the same underlying model.",
   "pages": [
    {
     "slug": "orchestrator-workers",
     "title": "Lead agent and workers",
     "summary": "A lead agent splits the task and hands parts to other agents.",
     "status": "sourced"
    },
    {
     "slug": "agent-graphs",
     "title": "Agent graphs",
     "graph_engineering": "work",
     "covers": [
      "nodes as agents",
      "handoffs",
      "shared state",
      "supervision",
      "agent-to-agent protocols"
     ],
     "summary": "Describing a team of agents and how work passes between them.",
     "status": "sourced"
    },
    {
     "slug": "debate-review",
     "title": "Review and debate",
     "summary": "Agents that check, or argue with, each other's work.",
     "status": "sourced"
    }
   ],
   "short": "Agents coordinate work",
   "who": "Several agents coordinate, delegate, or review work; they can use the same underlying model.",
   "description": "Agents divide, coordinate, or review work across separate contexts. A coordinator can combine their findings, and the agents may use the same model or different models. Coordination adds overhead, and separate reviewers can still make correlated mistakes."
  },
  {
   "id": "always-on",
   "order": 7,
   "title": "Always-on agents",
   "control": "Software triggers and resumes runs; agents decide what to do within their standing instructions.",
   "pages": [
    {
     "slug": "long-horizon",
     "title": "Long-running tasks",
     "covers": [
      "compaction",
      "checkpoints",
      "schedules"
     ],
     "summary": "Tasks that run for hours or days.",
     "status": "sourced"
    },
    {
     "slug": "agent-teammates",
     "title": "Always-on assistants",
     "covers": [
      "a computer of its own",
      "bot roster and a chief of staff",
      "routines taught by demonstration",
      "approvals and escalation",
      "credential vault",
      "supervisor agent on outbound actions"
     ],
     "examples_as_of": "2026-09-18",
     "examples": [
      "Grok Bot (SpaceXAI, beta 2026-08-11)",
      "Muse (Meta, 2026-09-08)",
      "Claude Cowork",
      "ChatGPT Work",
      "Gemini Spark",
      "OpenClaw (self-hosted)"
     ],
     "note": "The capstone page: nearly every lower level composes here (model, computer, storage, tools, memory, routines).",
     "summary": "Agents that resume work across sessions, schedules, and events.",
     "status": "sourced"
    },
    {
     "slug": "organizations-swarms",
     "title": "Organizations of agents",
     "summary": "Large groups of agents with roles and shared goals.",
     "status": "sourced"
    },
    {
     "slug": "embodied",
     "title": "Robots and machines",
     "summary": "Models that control robots and other machines.",
     "status": "sourced"
    }
   ],
   "short": "Resume across sessions and events",
   "who": "Software triggers and resumes runs; agents decide what to do within their standing instructions.",
   "description": "Saved state, schedules, and events let an agent start or resume work without a fresh chat message each time. The model need not run continuously, and a dedicated computer or agent team is optional. Permissions, human approvals, monitoring, and stop controls still apply."
  }
 ],
 "stages": [
  {
   "id": "skip",
   "title": "Skip the model",
   "levels": [
    0
   ],
   "kinds": "Rules, search, forms",
   "line": "Some jobs need no model at all. If you can write the rule down, use the rule."
  },
  {
   "id": "ask",
   "title": "Ask",
   "levels": [
    1,
    2
   ],
   "kinds": "Chat apps, and assistants that read your files",
   "line": "You ask a question. It answers, using what you give it."
  },
  {
   "id": "task",
   "title": "Hand over a task",
   "levels": [
    3,
    4
   ],
   "kinds": "Automations, and copilots inside your tools",
   "line": "You run the process. It does the steps, and can use the tools you allow."
  },
  {
   "id": "outcome",
   "title": "Delegate an outcome",
   "levels": [
    5
   ],
   "kinds": "Agents",
   "line": "You say what done looks like. It works out the steps and tells you when it has finished."
  },
  {
   "id": "function",
   "title": "Staff a function",
   "levels": [
    6,
    7
   ],
   "kinds": "Agent teams and always-on assistants",
   "line": "You set the goals and the limits. They divide the work, keep going, and ask when they need approval."
  }
 ],
 "tracks": [
  {
   "id": "evals",
   "title": "Evals",
   "why": "Every level claims to beat the one below it. This is how the claim is tested.",
   "summary": "Measuring whether a change made the results better.",
   "status": "sourced",
   "pages": [
    {
     "slug": "eval-frameworks",
     "title": "Evaluation frameworks",
     "covers": [
      "trajectory evaluation"
     ],
     "summary": "The tools that run test sets and graders for you, and what to check before trusting their numbers.",
     "status": "sourced"
    }
   ]
  },
  {
   "id": "adaptation",
   "title": "Changing the model",
   "covers": [
    "fine-tuning",
    "LoRA",
    "distillation",
    "reinforcement fine-tuning",
    "synthetic data",
    "automated prompt optimization"
   ],
   "why": "Orthogonal to the ladder: any level can run on a specialized model.",
   "summary": "Fine-tuning, distillation, synthetic data and automated prompt tuning.",
   "status": "sourced",
   "pages": [
    {
     "slug": "fine-tuning",
     "title": "Fine-tuning and adapters",
     "summary": "Training a model further on your own examples, in full or with small adapters such as LoRA.",
     "status": "sourced"
    },
    {
     "slug": "distillation",
     "title": "Distillation",
     "summary": "Training a smaller model to reproduce what a larger one does on your task.",
     "status": "sourced"
    },
    {
     "slug": "synthetic-data",
     "title": "Synthetic data",
     "summary": "Using a model to write training or test examples, and checking them before they are used.",
     "status": "sourced"
    },
    {
     "slug": "prompt-optimization",
     "title": "Prompt optimization",
     "summary": "Letting a program search for better prompts against a test set.",
     "status": "sourced"
    }
   ]
  },
  {
   "id": "safety",
   "title": "Safety, privacy and governance",
   "covers": [
    "prompt injection",
    "permissions",
    "sandboxing",
    "guardrails",
    "local vs cloud data handling",
    "consent",
    "audit trails"
   ],
   "summary": "Prompt injection, permissions, data handling and audit.",
   "status": "sourced",
   "pages": [
    {
     "slug": "guardrails",
     "title": "Guardrails",
     "summary": "Checks on what goes into a model and what comes out, and the limits of those checks.",
     "status": "sourced"
    },
    {
     "slug": "red-teaming",
     "title": "Red teaming",
     "summary": "Attacking your own system on purpose, before someone else does, and turning what you find into tests.",
     "status": "sourced"
    }
   ]
  },
  {
   "id": "ops",
   "title": "Operations",
   "covers": [
    "cost",
    "latency",
    "local vs cloud",
    "observability",
    "model selection"
   ],
   "summary": "Cost, speed, monitoring and running models on your own hardware.",
   "status": "sourced",
   "pages": [
    {
     "slug": "observability",
     "title": "Observability",
     "summary": "Recording what each run did, so a bad result can be traced to the step that caused it.",
     "status": "sourced"
    },
    {
     "slug": "ai-gateways",
     "title": "AI gateways",
     "summary": "One entry point in front of several model providers, for keys, routing, limits, fallback and logs.",
     "status": "sourced"
    },
    {
     "slug": "cost-optimization",
     "title": "Cost optimization",
     "summary": "Spending fewer tokens and less time for the same result: caching, batching, smaller models, shorter context.",
     "status": "sourced"
    },
    {
     "slug": "local-inference",
     "title": "Running models locally",
     "covers": [
      "speculative decoding"
     ],
     "summary": "Running open-weight models on your own hardware: what fits, quantization, and what you give up.",
     "status": "sourced"
    }
   ]
  },
  {
   "id": "operator-craft",
   "title": "Working with a model",
   "why": "The human half of the manual: the skill of working with a model rises with every order.",
   "pages": [
    {
     "slug": "briefing",
     "title": "Briefing: saying what you want",
     "summary": "Saying what you want clearly enough that the model does not have to guess.",
     "status": "sourced"
    },
    {
     "slug": "reviewing",
     "title": "Reviewing work you did not do",
     "summary": "Checking work you did not do yourself before it goes anywhere.",
     "status": "sourced"
    },
    {
     "slug": "delegating",
     "title": "Deciding what to hand over",
     "summary": "Deciding which parts of a task to hand to a model and which to keep.",
     "status": "sourced"
    },
    {
     "slug": "trust",
     "title": "Calibrating trust",
     "summary": "Learning, from results over time, how much to rely on a model without checking.",
     "status": "sourced"
    }
   ],
   "summary": "How to brief a model, review its work and decide what to hand over.",
   "status": "sourced"
  }
 ],
 "threads": [
  {
   "id": "graph-engineering",
   "title": "Graph engineering",
   "line": "Knowledge graphs connect information; agent graphs connect work.",
   "pages": [
    "knowledge-graphs",
    "workflow-graphs",
    "agent-graphs"
   ],
   "summary": "Two uses of graphs that are often confused: graphs that connect information, and graphs that connect work.",
   "status": "sourced"
  },
  {
   "id": "who-approves-what",
   "title": "Who approves what",
   "line": "A person never leaves; what they hold changes from the answer, to the action, to the rules the actions run under.",
   "pages": [
    "delegating",
    "human-in-the-loop",
    "function-calling",
    "agent-harness",
    "agent-teammates",
    "trust"
   ],
   "summary": "The same question asked at every level: which part of this does a person still decide? The answer moves from reading each result to setting the limits a run happens inside.",
   "status": "sourced"
  },
  {
   "id": "checking-the-work",
   "title": "Checking the work",
   "line": "Every level has a way to be wrong that the level below could not be, and a check that costs less than the mistake.",
   "pages": [
    "structured-output",
    "evaluator-optimizer",
    "debate-review",
    "evals",
    "observability"
   ],
   "summary": "How you tell whether it worked, from a person reading one answer to a scored set and a recorded trace. The check changes shape at every level; the question does not.",
   "status": "sourced"
  },
  {
   "id": "what-the-model-sees",
   "title": "What the model sees",
   "line": "A model knows what it was trained on and what is in this request; everything else is a choice somebody made.",
   "pages": [
    "prompt-engineering",
    "context-engineering",
    "rag",
    "memory",
    "skills",
    "long-horizon"
   ],
   "summary": "One question followed across the site: what is in front of the model this turn, and who decided to put it there. The answers run from a written instruction to a note a session leaves for the next one.",
   "status": "sourced"
  }
 ],
 "recipes": [
  {
   "slug": "document-qa",
   "title": "Answer questions about a set of documents",
   "running_task": true,
   "status": "sourced",
   "domain": "general",
   "uses": [
    "rag",
    "structured-output",
    "evals"
   ],
   "summary": "Uses RAG, structured output and an eval set. Level 2 is enough because a single search answers most questions."
  },
  {
   "slug": "inbox-triage",
   "title": "Sort an inbox",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "routing",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Sorts mail into fixed categories and produces structured output. A person approves anything that gets sent. The categories are known in advance, so an agent is not needed."
  },
  {
   "slug": "research-brief",
   "title": "Write a research brief with citations",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "agentic-rag",
    "evaluator-optimizer"
   ],
   "summary": "Uses agentic RAG to find sources and a fixed check on every claim against the section it cites. It needs level 5 for the searching; the checking is level 3."
  },
  {
   "slug": "repo-assistant",
   "title": "Coding assistant on your own repo",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "coding-agents",
    "skills",
    "safety"
   ],
   "summary": "A coding agent that reads, edits, runs and tests code in your repository, using skills for repeated tasks and a safety review before anything ships."
  },
  {
   "slug": "document-extraction",
   "title": "Turn photos and PDFs into records",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "multimodal",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Reads the image or PDF, fills a fixed schema, and saves the record once a person confirms it."
  },
  {
   "slug": "voice-notes",
   "title": "Voice notes into structured entries",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "multimodal",
    "prompt-chaining",
    "evals"
   ],
   "summary": "Transcribes a voice note, splits it into steps, and turns each step into a structured entry that an eval set checks for accuracy."
  },
  {
   "slug": "support-desk",
   "title": "Support desk",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "routing",
    "rag",
    "function-calling",
    "human-in-the-loop"
   ],
   "summary": "Routes an incoming ticket, searches the documentation for an answer, calls a tool when an action is needed, and hands off to a person when it is unsure."
  },
  {
   "slug": "nightly-monitor",
   "title": "Nightly source monitor",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "routing",
    "structured-output",
    "evals",
    "ops"
   ],
   "summary": "Runs on a timer, diffs a set of public pages in code, and asks a model one question about each change. Level 3: the schedule and the checkpoint are infrastructure, not agency."
  },
  {
   "slug": "data-analysis",
   "title": "Data analysis by conversation",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "code-execution",
    "single-agent"
   ],
   "summary": "A single agent writes and runs code against a dataset, one question at a time, to answer questions a fixed query could not anticipate."
  },
  {
   "slug": "content-pipeline",
   "title": "Drafting with a reviewer",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "evaluator-optimizer",
    "prompt-chaining"
   ],
   "summary": "One prompt drafts a piece of writing and another checks it against a rubric, repeating until the draft passes."
  },
  {
   "slug": "assistant-team",
   "title": "A team of personal assistants",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "agent-teammates",
    "agent-graphs",
    "memory",
    "safety"
   ],
   "summary": "Several always-on agents split personal tasks among themselves, sharing memory and staying inside the same safety rules."
  },
  {
   "slug": "maintenance-log",
   "title": "Plain-language maintenance log",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "function-calling",
    "structured-output",
    "knowledge-graphs"
   ],
   "summary": "Turns a plain-language description of work done into a structured log entry, saved with a tool call and linked to the equipment it concerns through a small knowledge graph."
  },
  {
   "slug": "household-paperwork",
   "title": "Keep the household paperwork straight",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "order-zero"
   ],
   "summary": "Organize renewal dates, file names, category totals, and reminders with ordinary code. No model is needed; extracting information from scanned bills is a separate task."
  },
  {
   "slug": "meeting-notes",
   "title": "Turn a meeting transcript into decisions and owners",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "prompt-engineering",
    "structured-output"
   ],
   "summary": "Turn a transcript into decisions, owners, and open questions in one model call. Someone who attended reviews the draft before it is shared."
  },
  {
   "slug": "invoice-matching",
   "title": "Match invoices to purchase orders",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "order-zero",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Extract invoice fields, then use code to match purchase orders and compare amounts. Differences go to a person; the model never decides whether the totals reconcile."
  },
  {
   "slug": "contract-review",
   "title": "Check an agreement against your own checklist",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "parallelization",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Check an agreement against a fixed checklist, with cited clauses for each finding. Merge the findings for a person to review."
  },
  {
   "slug": "incident-runbook",
   "title": "Turn an incident write-up into a runbook",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "prompt-chaining",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Turn an incident write-up into a timeline and repeatable steps. Check owners and success criteria, then ask the incident lead to approve it."
  },
  {
   "slug": "storyboard-from-a-script",
   "title": "Turn a script into a shot list",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "prompt-chaining",
    "structured-output"
   ],
   "summary": "Split a script into scenes and shots, then check that every line is covered and every shot has a source. A person reviews the plan; drawing frames is a separate task."
  },
  {
   "slug": "trip-planning",
   "title": "Plan a trip and hold the bookings",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "single-agent",
    "function-calling",
    "human-in-the-loop"
   ],
   "summary": "Checking what is available, what is open and what connects takes a different number of steps every time, which is what level 5 is for. Read-only lookups run unattended; anything that spends money stops for a person, with the price and the cancellation terms in front of them."
  },
  {
   "slug": "rubric-grading",
   "title": "Grade against a rubric, with a second reader",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "debate-review",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Two independent reviewers apply the same rubric. Disagreements go to the teacher rather than being averaged away."
  },
  {
   "slug": "literature-watch",
   "title": "Watch a topic for new work and summarize what turns up",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "order-zero",
    "prompt-engineering",
    "structured-output",
    "ops",
    "evals"
   ],
   "summary": "Code detects new records from fixed sources. One model call summarizes each new title and abstract; code attaches the original citation. It does not follow references or choose new searches."
  },
  {
   "slug": "weekly-status-report",
   "title": "Assemble a weekly status report from several systems",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "order-zero",
    "prompt-engineering",
    "ops",
    "evals"
   ],
   "summary": "Code assembles the weekly figures; one model call drafts the report. Checks flag unsupported numbers and missing required facts, then a person reviews and sends it."
  },
  {
   "slug": "project-tracker-upkeep",
   "title": "Keep a tracker document current from several sources",
   "status": "sourced",
   "domain": "general",
   "uses": [
    "order-zero",
    "structured-output",
    "human-in-the-loop",
    "ops"
   ],
   "summary": "Keep a shared tracker current through source comparisons and a review queue. Model proposals and changes to human-written fields need approval; missing evidence is flagged."
  },
  {
   "slug": "limits-without-a-model",
   "title": "Check measurements against limits, and chart what drifts",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "order-zero"
   ],
   "summary": "Use code to calculate limits, yield, process capability, and trends across lots and fixtures. The pass/fail decision stays deterministic; no model is involved."
  },
  {
   "slug": "characterize-a-design",
   "title": "Sweep a design over its corners and report the margins",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "order-zero"
   ],
   "summary": "Sweep prototype boards across line, load, and temperature. Code calculates margins, uncertainty, and guardbanded verdicts; no model is needed."
  },
  {
   "slug": "measurement-writeup",
   "title": "Turn a measurement session into a report somebody can review",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "order-zero",
    "prompt-engineering"
   ],
   "summary": "Turn computed measurements and notebook notes into a report. Code owns the figures, the model writes the prose, and a person checks the finished draft."
  },
  {
   "slug": "ask-the-datasheet",
   "title": "Answer questions from a datasheet, a test spec and a change notice",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "rag",
    "structured-output"
   ],
   "summary": "Retrieval over the documents an engineer already has, answered with citations that can be checked. The case that matters is a change notice contradicting the datasheet on one number, where the right answer depends on the board revision. Level 2 is enough because one search finds the passage."
  },
  {
   "slug": "accuracy-specs-from-the-manual",
   "title": "Pull an instrument's accuracy table out of its manual",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "order-zero",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Extract specification rows from a manual, validate their structure, and calculate uncertainty in code. A person verifies ranges, intervals, and conditions against the source."
  },
  {
   "slug": "test-failure-triage",
   "title": "Sort failing units and operator notes into causes",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "routing",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "Failing measurements and free-text operator notes are sorted into the causes the failure analysis guide already lists, then routed. A person confirms before anything is scrapped or reworked. The categories are known in advance, so this is classification into fixed classes and not an agent."
  },
  {
   "slug": "design-review-checklist",
   "title": "Check a board against the design rules document",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "evaluator-optimizer",
    "structured-output"
   ],
   "summary": "A bill of materials and a netlist summary are checked rule by rule against the written design rules. One pass drafts findings, a second checks each finding against the rule text it cites and drops the ones that cite nothing. Level 3, because code decides every step and the rules do not change between boards. This is the rule check that happens before a review meeting, not the design review report itself: for the report, and the characterization data behind it, see the two recipes this page links in its first paragraph."
  },
  {
   "slug": "requirements-to-test-plan",
   "title": "Turn a requirements list into a test plan",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "prompt-chaining",
    "structured-output",
    "human-in-the-loop"
   ],
   "summary": "A fixed chain: read the requirements, propose a test for each, build the traceability table, then check that every requirement has a test and every test names a requirement. A person approves before any of it is adopted. The order of the steps is known in advance, which is what keeps this at level 3."
  },
  {
   "slug": "instrument-script-from-the-manual",
   "title": "Draft an instrument control script from its programming manual",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "rag",
    "evaluator-optimizer",
    "code-execution"
   ],
   "summary": "The model drafts commands from the manual for that instrument; code checks every one against the documented command set, runs the script on the simulated instrument, and feeds the errors back for another pass. A person bench-checks before it drives real hardware, and every set point goes through a code-side envelope."
  },
  {
   "slug": "test-data-by-conversation",
   "title": "Ask questions of a production test log",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "code-execution",
    "function-calling"
   ],
   "summary": "Starts where the dashboard stopped: limits, yield and Cpk are already charted and did not answer the question. The model writes analysis code that runs in a sandbox over the CSV, and a person reads the code as well as the answer. Includes the trap of a column in millivolts under a header that says volts."
  },
  {
   "slug": "bring-up-debug-assistant",
   "title": "Work a bring-up problem at the bench",
   "status": "sourced",
   "domain": "engineering",
   "uses": [
    "single-agent",
    "function-calling",
    "human-in-the-loop",
    "safety"
   ],
   "summary": "An agent with read-only tools, instrument queries, the test log and the datasheet, works a low output down to a cause and proposes the next measurement. Queries run unattended; anything that sets a voltage, a current limit or an output goes through the envelope and a person. Level 5 because each measurement depends on the last."
  }
 ],
 "relations": [
  {
   "from": "prompt-engineering",
   "type": "requires",
   "to": "chat",
   "note": "A chat message supplies the instructions and context; prompt engineering makes those instructions clearer and easier to check."
  },
  {
   "from": "structured-output",
   "type": "requires",
   "to": "prompt-engineering",
   "note": "A schema controls the reply's shape, but the prompt still needs to define what each field means and what to do when information is missing."
  },
  {
   "from": "inference-time-reasoning",
   "type": "requires",
   "to": "prompt-engineering",
   "note": "Extra reasoning works on the task you specify, so clear goals and constraints are needed before spending more computation on an answer."
  },
  {
   "from": "multimodal",
   "type": "requires",
   "to": "chat",
   "note": "Multimodal interaction extends the chat request with images, audio, or video while keeping the same instruction-and-response structure."
  },
  {
   "from": "context-engineering",
   "type": "requires",
   "to": "prompt-engineering",
   "note": "Context engineering expands prompt design to choosing which documents, history, and tool results the model receives on each call."
  },
  {
   "from": "rag",
   "type": "requires",
   "to": "embeddings-search",
   "note": "Retrieval supplies relevant passages for the answer. Embeddings search explains a common way to find them, although RAG can also use keyword or hybrid search."
  },
  {
   "from": "rag",
   "type": "requires",
   "to": "context-engineering",
   "note": "Retrieved passages must be selected, fitted into the request, and separated from instructions so the model can use them as evidence."
  },
  {
   "from": "knowledge-graphs",
   "type": "requires",
   "to": "rag",
   "note": "Graph-based retrieval extends document retrieval with entities and relationships, allowing evidence to be joined across sources."
  },
  {
   "from": "memory",
   "type": "requires",
   "to": "context-engineering",
   "note": "Stored information helps only when the system selects and inserts the relevant memories into the model's current context."
  },
  {
   "from": "prompt-chaining",
   "type": "requires",
   "to": "structured-output",
   "note": "A chain passes one step's result to another. Structured outputs give those handoffs predictable fields that code can validate."
  },
  {
   "from": "routing",
   "type": "requires",
   "to": "structured-output",
   "note": "The routing decision needs a recognizable destination or label so application code can send the request down the intended branch."
  },
  {
   "from": "parallelization",
   "type": "requires",
   "to": "prompt-chaining",
   "note": "Parallel work reuses the idea of staged calls, but runs independent steps together before collecting their results."
  },
  {
   "from": "evaluator-optimizer",
   "type": "requires",
   "to": "prompt-chaining",
   "note": "The draft, evaluation, and revision are separate calls connected by explicit handoffs and a stopping rule."
  },
  {
   "from": "workflow-graphs",
   "type": "requires",
   "to": "prompt-chaining",
   "note": "A workflow graph turns a sequence of calls into named steps with explicit transitions and shared state."
  },
  {
   "from": "workflow-graphs",
   "type": "requires",
   "to": "routing",
   "note": "Branches in a workflow need routing rules to choose which step receives the current state next."
  },
  {
   "from": "function-calling",
   "type": "requires",
   "to": "structured-output",
   "note": "A tool call carries a tool name and schema-shaped arguments that the application validates before execution."
  },
  {
   "from": "code-execution",
   "type": "requires",
   "to": "function-calling",
   "note": "Code execution is exposed as a tool: the model proposes code, and an external runtime executes it and returns results."
  },
  {
   "from": "mcp",
   "type": "requires",
   "to": "function-calling",
   "note": "MCP provides a standard way to discover and connect tools; function calling explains how the model requests a tool operation."
  },
  {
   "from": "computer-use",
   "type": "requires",
   "to": "function-calling",
   "note": "Clicks, typing, and other interface actions are tool requests executed by the surrounding application."
  },
  {
   "from": "computer-use",
   "type": "requires",
   "to": "multimodal",
   "note": "Screenshot-based computer use interprets visual state before proposing actions; accessibility-tree approaches can also use structured text."
  },
  {
   "from": "single-agent",
   "type": "requires",
   "to": "function-calling",
   "note": "An agent repeatedly requests tools, reads their results, and chooses the next action or a stopping point."
  },
  {
   "from": "agentic-rag",
   "type": "requires",
   "to": "rag",
   "note": "Agentic RAG keeps retrieval and evidence-grounded answering, while letting the model choose follow-up searches."
  },
  {
   "from": "agentic-rag",
   "type": "requires",
   "to": "single-agent",
   "note": "The agent loop makes it possible to inspect retrieved evidence, revise a query, and decide whether enough information has been found."
  },
  {
   "from": "coding-agents",
   "type": "requires",
   "to": "single-agent",
   "note": "A coding agent uses the tool-and-feedback loop to inspect files, make changes, and decide what to check next."
  },
  {
   "from": "coding-agents",
   "type": "requires",
   "to": "code-execution",
   "note": "Running tests or programs provides feedback about a code change that reading the proposed code alone cannot supply."
  },
  {
   "from": "skills",
   "type": "requires",
   "to": "single-agent",
   "note": "Skills give an agent reusable instructions and resources to load for a particular task within its existing execution loop."
  },
  {
   "from": "voice-agents",
   "type": "requires",
   "to": "single-agent",
   "note": "A task-oriented voice agent needs an action loop behind the conversation to use tools and track unfinished work."
  },
  {
   "from": "voice-agents",
   "type": "requires",
   "to": "multimodal",
   "note": "Voice interaction adds audio input and output, with timing and interruption handling around the conversation."
  },
  {
   "from": "orchestrator-workers",
   "type": "requires",
   "to": "single-agent",
   "note": "Each worker uses an agent loop on an assigned task, while the lead agent assigns work and integrates results."
  },
  {
   "from": "agent-graphs",
   "type": "requires",
   "to": "workflow-graphs",
   "note": "Agent graphs use explicit nodes, transitions, and shared state to control how agent runs hand work to one another."
  },
  {
   "from": "agent-graphs",
   "type": "requires",
   "to": "orchestrator-workers",
   "note": "Coordinating multiple agents requires clear responsibilities and result handoffs; the graph makes those handoffs explicit."
  },
  {
   "from": "debate-review",
   "type": "requires",
   "to": "evaluator-optimizer",
   "note": "Debate and review extend the draft-check-revise pattern with multiple perspectives on the same result."
  },
  {
   "from": "debate-review",
   "type": "requires",
   "to": "orchestrator-workers",
   "note": "Separate agents take author or reviewer roles, and their findings must be collected and resolved into a result."
  },
  {
   "from": "long-horizon",
   "type": "requires",
   "to": "single-agent",
   "note": "Long-running work extends an agent loop with checkpoints and recovery so it can resume after a session ends."
  },
  {
   "from": "long-horizon",
   "type": "requires",
   "to": "memory",
   "note": "Progress, decisions, and pending work must survive outside the current context window to support reliable resumption."
  },
  {
   "from": "agent-teammates",
   "type": "requires",
   "to": "long-horizon",
   "note": "A standing assistant must preserve work and commitments across repeated sessions rather than finish everything in one run."
  },
  {
   "from": "agent-teammates",
   "type": "requires",
   "to": "skills",
   "note": "Reusable skills let a standing assistant perform recurring responsibilities with consistent procedures."
  },
  {
   "from": "agent-teammates",
   "type": "requires",
   "to": "computer-use",
   "note": "Computer use explains how a standing assistant can act in existing applications when a direct tool integration is unavailable."
  },
  {
   "from": "agent-teammates",
   "type": "combines_with",
   "to": "safety",
   "note": "A standing assistant needs scoped access and clear action boundaries because its permissions persist across repeated tasks."
  },
  {
   "from": "agent-teammates",
   "type": "combines_with",
   "to": "human-in-the-loop",
   "note": "Approval checkpoints let a person review consequential actions and resolve uncertainty during an assistant's ongoing work."
  },
  {
   "from": "organizations-swarms",
   "type": "requires",
   "to": "agent-graphs",
   "note": "Explicit handoffs and shared state provide a foundation for coordinating a changing collection of agent roles."
  },
  {
   "from": "organizations-swarms",
   "type": "requires",
   "to": "long-horizon",
   "note": "A persistent team must retain assignments, progress, and unresolved issues across separate runs."
  },
  {
   "from": "embodied",
   "type": "requires",
   "to": "single-agent",
   "note": "An embodied agent repeatedly observes its environment, proposes an action, and uses new observations to choose what comes next."
  },
  {
   "from": "embodied",
   "type": "requires",
   "to": "multimodal",
   "note": "Physical interaction depends on interpreting sensor inputs such as camera images alongside task instructions."
  },
  {
   "from": "rag",
   "type": "upgrades_to",
   "to": "knowledge-graphs",
   "when": "The answer needs facts joined across documents, or you must show where each fact came from.",
   "note": "A graph adds explicit entities and relationships to retrieval, so an answer can follow connections between facts in different sources."
  },
  {
   "from": "rag",
   "type": "upgrades_to",
   "to": "agentic-rag",
   "when": "One retrieval is not enough and the next query depends on what the last one found.",
   "note": "An agent inspects search results and chooses follow-up queries instead of answering after a predetermined retrieval step."
  },
  {
   "from": "prompt-chaining",
   "type": "upgrades_to",
   "to": "single-agent",
   "when": "The steps cannot be written down in advance.",
   "note": "The model chooses the next tool or step from feedback instead of following a sequence fixed by your code."
  },
  {
   "from": "parallelization",
   "type": "upgrades_to",
   "to": "orchestrator-workers",
   "when": "The subtasks cannot be known until the task is read.",
   "note": "A lead agent decomposes the request and assigns workers dynamically, rather than running a predefined batch of independent calls."
  },
  {
   "from": "evaluator-optimizer",
   "type": "upgrades_to",
   "to": "debate-review",
   "when": "One reviewer shares the author's blind spots.",
   "note": "Multiple reviewers contribute different critiques, which can expose errors missed by a single evaluation-and-revision loop."
  },
  {
   "from": "workflow-graphs",
   "type": "upgrades_to",
   "to": "agent-graphs",
   "when": "A node needs its own loop and tools, not one call.",
   "note": "A graph node can run an agent's own tool-and-feedback loop before passing its result to the next node."
  },
  {
   "from": "function-calling",
   "type": "upgrades_to",
   "to": "single-agent",
   "when": "The next action depends on what the last one returned, so the model has to choose again and decide when to stop.",
   "note": "The application feeds tool results back into another model turn, creating a loop in which the model chooses successive actions."
  },
  {
   "from": "code-execution",
   "type": "upgrades_to",
   "to": "coding-agents",
   "when": "The code has to be run, read and rewritten until it works, with the model deciding when it is done.",
   "note": "The model uses execution feedback to inspect and revise files over multiple steps, rather than stopping after one code run."
  },
  {
   "from": "computer-use",
   "type": "upgrades_to",
   "to": "single-agent",
   "when": "One action is not enough: the task needs a sequence of reads and actions, which is what every real computer-use run does.",
   "note": "Interface actions become steps in a loop: observe the updated screen, choose another action, and stop when the task is complete."
  },
  {
   "from": "single-agent",
   "type": "upgrades_to",
   "to": "long-horizon",
   "when": "The work outlives one context window or one sitting.",
   "note": "Checkpoints and persistent task state allow the agent to resume unfinished work across context windows and sessions."
  },
  {
   "from": "skills",
   "type": "combines_with",
   "to": "memory",
   "note": "Skills store reusable procedures; memory supplies task history or preferences that help apply those procedures to the current situation."
  },
  {
   "from": "human-in-the-loop",
   "type": "combines_with",
   "to": "workflow-graphs",
   "note": "A workflow can include explicit pause, review, and resume steps so a person's decision becomes part of the execution path."
  },
  {
   "from": "human-in-the-loop",
   "type": "combines_with",
   "to": "function-calling",
   "note": "Tool calls provide a concrete approval boundary: show the proposed operation and arguments before allowing execution."
  },
  {
   "from": "evaluator-optimizer",
   "type": "combines_with",
   "to": "evals",
   "note": "Evaluation criteria guide revision, while held-out evaluations check whether the revision loop improves results beyond its own feedback."
  },
  {
   "from": "computer-use",
   "type": "combines_with",
   "to": "safety",
   "note": "Interface actions can change real accounts and files, so permissions and checks must limit what the automation may do."
  },
  {
   "from": "long-horizon",
   "type": "combines_with",
   "to": "ops",
   "note": "Persistent work needs scheduling, recovery, monitoring, and resource limits to keep running predictably across sessions."
  },
  {
   "from": "rag",
   "type": "alternative_to",
   "to": "context-engineering",
   "question": "Retrieve, or put it all in the window?",
   "note": "Retrieve a relevant subset when the source collection is too large or changes often; include the full relevant material when it fits and the task benefits from seeing it together."
  },
  {
   "from": "adaptation",
   "type": "alternative_to",
   "to": "prompt-engineering",
   "question": "Train it in, or say it every time?",
   "note": "Prompting supplies instructions at request time; adaptation changes learned behavior. Compare maintenance effort and measured quality before choosing training."
  },
  {
   "from": "workflow-graphs",
   "type": "alternative_to",
   "to": "single-agent",
   "question": "Draw the path, or let the model find it?",
   "note": "A fixed graph suits known steps and explicit control; an agent loop suits tasks whose next action depends on discoveries during execution."
  },
  {
   "from": "mcp",
   "type": "alternative_to",
   "to": "function-calling",
   "question": "A protocol server, or tools defined inline?",
   "note": "Inline tool definitions can suit one application; MCP standardizes tool discovery and access across clients. MCP tools can still be invoked through function calling."
  },
  {
   "from": "chat",
   "type": "requires",
   "to": "order-zero",
   "note": "Before adding a model, check whether rules, search, or a fixed template already solve the task more predictably. This is a design decision, not a runtime dependency."
  },
  {
   "from": "order-zero",
   "type": "upgrades_to",
   "to": "chat",
   "when": "The input is language you cannot write rules for, and a wrong answer is cheap to catch.",
   "note": "A language model handles varied natural-language input that is difficult to cover with fixed rules, with output checks appropriate to the task."
  },
  {
   "from": "briefing",
   "type": "combines_with",
   "to": "prompt-engineering",
   "note": "A brief supplies the goal, context, constraints, and acceptance criteria that the prompt communicates to the model."
  },
  {
   "from": "reviewing",
   "type": "combines_with",
   "to": "human-in-the-loop",
   "note": "Human checkpoints are useful when the reviewer knows what evidence to inspect and what would justify accepting or rejecting the result."
  },
  {
   "from": "delegating",
   "type": "combines_with",
   "to": "single-agent",
   "note": "Delegation defines the outcome, authority, and stopping conditions within which the agent may choose its own steps."
  },
  {
   "from": "trust",
   "type": "combines_with",
   "to": "evals",
   "note": "Representative evaluations provide evidence for deciding which tasks to delegate and how much review they still need."
  },
  {
   "from": "chat",
   "type": "upgrades_to",
   "to": "rag",
   "when": "The answer needs facts the model was never trained on, not just what it already knows.",
   "note": "Retrieval supplies relevant external passages alongside the question, giving the model evidence beyond the conversation and its learned parameters."
  },
  {
   "from": "prompt-engineering",
   "type": "upgrades_to",
   "to": "structured-output",
   "when": "The reply's format has to be valid on every single call, not just usually valid.",
   "note": "A declared schema and supported output constraints make the reply machine-readable; validation still checks whether its values are correct."
  },
  {
   "from": "structured-output",
   "type": "upgrades_to",
   "to": "function-calling",
   "when": "The model itself has to decide whether to use the schema-shaped output at all, not just fill in values for a shape your code already chose.",
   "note": "The structured reply becomes a request for a named operation, which the application validates and executes before returning a result."
  },
  {
   "from": "inference-time-reasoning",
   "type": "upgrades_to",
   "to": "evaluator-optimizer",
   "when": "The same mistake shows up across every sample or every extra round of thinking, so more computation on the same approach stops helping and the draft needs checking against a stated criterion instead.",
   "note": "An explicit evaluator checks a draft against criteria and supplies feedback for revision, adding a check beyond more thinking on the initial attempt."
  },
  {
   "from": "multimodal",
   "type": "upgrades_to",
   "to": "human-in-the-loop",
   "when": "The model is generating an image, audio or video rather than reading one, so there is no source to check the result against, and a wrong one is expensive or hard to undo where it is going.",
   "note": "A person reviews generated media in its intended context before it is accepted or used for a consequential purpose."
  },
  {
   "from": "orchestrator-workers",
   "type": "upgrades_to",
   "to": "long-horizon",
   "when": "The task cannot finish inside one bounded team run and has to pick up again across separate sessions.",
   "note": "Persisting team results, pending assignments, and checkpoints lets coordinated work continue beyond one bounded run."
  },
  {
   "from": "agent-graphs",
   "type": "upgrades_to",
   "to": "organizations-swarms",
   "when": "The roster of agents itself has to change while the work is in progress, not stay fixed for one run.",
   "note": "Coordination expands from a fixed set of graph nodes to roles that can be created, reassigned, or retired as the work changes."
  },
  {
   "from": "debate-review",
   "type": "upgrades_to",
   "to": "agent-teammates",
   "when": "The checking has to run continuously against everything a standing assistant does, not once against one finished draft.",
   "note": "Review becomes part of an assistant's ongoing responsibilities, with stored commitments and repeated checks across separate tasks."
  },
  {
   "from": "embeddings-search",
   "type": "upgrades_to",
   "to": "rag",
   "when": "The person asking wants an answer with the passages behind it, not a ranked list of passages to read themselves.",
   "note": "The retrieved passages become evidence for a generated answer, rather than only a ranked list for the user to read."
  },
  {
   "from": "knowledge-graphs",
   "type": "upgrades_to",
   "to": "agentic-rag",
   "when": "Which entity to follow next depends on what the last hop returned, so the queries cannot be written in advance.",
   "note": "The agent chooses subsequent entity lookups or searches based on what each graph traversal reveals."
  },
  {
   "from": "memory",
   "type": "upgrades_to",
   "to": "long-horizon",
   "when": "What has to survive between sessions is work still in progress, not facts about the person you are talking to.",
   "note": "Persistent storage expands from remembered facts to checkpoints, unfinished steps, and decisions needed to resume a task."
  },
  {
   "from": "routing",
   "type": "upgrades_to",
   "to": "function-calling",
   "when": "The right destination depends on something the message does not say, so the choice needs a lookup before it can be made.",
   "note": "The model can request a lookup or other operation and use its result before deciding how to handle the request."
  },
  {
   "from": "mcp",
   "type": "upgrades_to",
   "to": "agent-harness",
   "when": "The tools are connected and what is missing is everything around the model: the loop, the permissions, the caps and the sandbox.",
   "note": "A harness surrounds connected tools with execution control, permissions, context handling, and run limits."
  },
  {
   "from": "agentic-rag",
   "type": "upgrades_to",
   "to": "orchestrator-workers",
   "when": "The searches do not depend on each other and there are more of them than one agent's context can carry.",
   "note": "A lead agent splits independent research questions among workers and combines their evidence into one result."
  },
  {
   "from": "coding-agents",
   "type": "upgrades_to",
   "to": "orchestrator-workers",
   "when": "The change is larger than one agent can hold at once and splits into parts that can be worked separately.",
   "note": "A lead agent assigns separable code changes to workers and coordinates integration and review of their results."
  },
  {
   "from": "agent-harness",
   "type": "requires",
   "to": "single-agent",
   "note": "The harness implements the surrounding agent loop, including tool execution, context management, limits, and stopping conditions."
  },
  {
   "from": "coding-agents",
   "type": "combines_with",
   "to": "agent-harness",
   "note": "The harness gives the coding agent a controlled workspace, tool access, execution limits, and a way to collect test results."
  },
  {
   "from": "skills",
   "type": "combines_with",
   "to": "agent-harness",
   "note": "The harness discovers and loads skill instructions and resources into the agent's context when they are relevant."
  },
  {
   "from": "long-horizon",
   "type": "combines_with",
   "to": "agent-harness",
   "note": "The harness records checkpoints, restores task state, and enforces limits across resumed runs."
  },
  {
   "from": "fine-tuning",
   "type": "requires",
   "to": "adaptation",
   "note": "Fine-tuning is one form of adaptation: training on examples changes model behavior, so first decide what behavior needs to change and how to measure it."
  },
  {
   "from": "distillation",
   "type": "requires",
   "to": "fine-tuning",
   "note": "Distillation trains a student on a teacher's outputs or behavior, using the training-and-evaluation process introduced in fine-tuning."
  },
  {
   "from": "synthetic-data",
   "type": "requires",
   "to": "adaptation",
   "note": "Generated examples can supply adaptation data, but they need filtering and independent evaluation to avoid reinforcing errors."
  },
  {
   "from": "prompt-optimization",
   "type": "requires",
   "to": "evals",
   "note": "An optimizer needs a scoring method and held-out examples to distinguish a better prompt from one that merely fits the tuning set."
  },
  {
   "from": "prompt-optimization",
   "type": "combines_with",
   "to": "prompt-engineering",
   "note": "Prompt engineering defines the instructions and constraints; optimization systematically compares candidate versions against a task score."
  },
  {
   "from": "observability",
   "type": "requires",
   "to": "ops",
   "note": "Observability supplies the traces and metrics used to diagnose and operate a model-backed system."
  },
  {
   "from": "ai-gateways",
   "type": "requires",
   "to": "ops",
   "note": "Gateways centralize operational controls such as provider routing, credentials, rate limits, and request logging."
  },
  {
   "from": "cost-optimization",
   "type": "requires",
   "to": "ops",
   "note": "Reducing cost requires measurements of usage, latency, and quality so savings do not silently degrade the service."
  },
  {
   "from": "local-inference",
   "type": "requires",
   "to": "ops",
   "note": "Running a model locally shifts capacity planning, serving, updates, and monitoring onto your own infrastructure."
  },
  {
   "from": "cost-optimization",
   "type": "combines_with",
   "to": "routing",
   "note": "Routing can send simpler requests to cheaper models while reserving more expensive paths for tasks that need them."
  },
  {
   "from": "cost-optimization",
   "type": "combines_with",
   "to": "context-engineering",
   "note": "Selecting relevant context and reusing stable prefixes can reduce token costs while preserving the evidence needed for the task."
  },
  {
   "from": "guardrails",
   "type": "requires",
   "to": "safety",
   "note": "Safety analysis defines the unwanted behaviors and boundaries that guardrail checks attempt to enforce."
  },
  {
   "from": "red-teaming",
   "type": "requires",
   "to": "safety",
   "note": "Red-teaming starts from a threat model and probes where a system's safety boundaries can fail."
  },
  {
   "from": "red-teaming",
   "type": "combines_with",
   "to": "evals",
   "note": "Failures found during adversarial testing can become repeatable evaluation cases that check whether fixes hold."
  },
  {
   "from": "guardrails",
   "type": "combines_with",
   "to": "human-in-the-loop",
   "note": "A guardrail can pause ambiguous or consequential actions and route them to a person for a decision."
  },
  {
   "from": "eval-frameworks",
   "type": "requires",
   "to": "evals",
   "note": "Frameworks run datasets, scorers, and comparisons; evaluation design determines whether those measurements reflect useful task performance."
  },
  {
   "from": "observability",
   "type": "combines_with",
   "to": "evals",
   "note": "Traces expose the intermediate steps behind an evaluation result and help turn production failures into test cases."
  },
  {
   "type": "combines_with",
   "to": "guardrails",
   "note": "The harness can run input, output, and tool checks around each model step.",
   "from": "agent-harness"
  },
  {
   "type": "combines_with",
   "to": "human-in-the-loop",
   "note": "The harness enforces which actions pause for human approval.",
   "from": "agent-harness"
  },
  {
   "type": "combines_with",
   "to": "context-engineering",
   "note": "The harness assembles the next request and manages growing context.",
   "from": "agent-harness"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Traces record model calls, tool results, refusals, and stop conditions.",
   "from": "agent-harness"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Evaluate the whole model-and-harness system, including tool actions and final outcomes.",
   "from": "agent-harness"
  },
  {
   "type": "combines_with",
   "to": "cost-optimization",
   "note": "Step, token, and spending limits bound the cost of a run.",
   "from": "agent-harness"
  },
  {
   "type": "combines_with",
   "to": "guardrails",
   "note": "Check proposed actions before tool execution.",
   "from": "single-agent"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Assess task outcomes and the sequence of actions, not only the final reply.",
   "from": "single-agent"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Check retrieval coverage, source support, and when the search stops.",
   "from": "agentic-rag"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Trace each query and retrieved result to understand the final answer.",
   "from": "agentic-rag"
  },
  {
   "type": "combines_with",
   "to": "safety",
   "note": "Sandbox execution and scope access to files, credentials, and networks.",
   "from": "coding-agents"
  },
  {
   "type": "combines_with",
   "to": "reviewing",
   "note": "Review the diff and test evidence before accepting the change.",
   "from": "coding-agents"
  },
  {
   "type": "combines_with",
   "to": "safety",
   "note": "Review skill instructions, bundled code, and requested permissions before trusting them.",
   "from": "skills"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Test both whether a skill is selected appropriately and whether it completes its task.",
   "from": "skills"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Test turn-taking, interruptions, task success, and recovery.",
   "from": "voice-agents"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Track latency and interruption events as well as model calls.",
   "from": "voice-agents"
  },
  {
   "type": "combines_with",
   "to": "delegating",
   "note": "Define worker responsibilities, boundaries, and acceptance criteria.",
   "from": "orchestrator-workers"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Trace the lead agent and worker runs together.",
   "from": "orchestrator-workers"
  },
  {
   "type": "combines_with",
   "to": "cost-optimization",
   "note": "Bound worker count and parallel calls against the task budget.",
   "from": "orchestrator-workers"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Record handoffs, checkpoints, and the state at each decision.",
   "from": "agent-graphs"
  },
  {
   "type": "combines_with",
   "to": "guardrails",
   "note": "Validate state and permissions at handoffs between agents.",
   "from": "agent-graphs"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Check whether review improves accuracy rather than just agreement.",
   "from": "debate-review"
  },
  {
   "type": "combines_with",
   "to": "reviewing",
   "note": "Review evidence independently; agreement among agents is not proof.",
   "from": "debate-review"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Track progress, retries, and recovery across sessions.",
   "from": "long-horizon"
  },
  {
   "type": "combines_with",
   "to": "cost-optimization",
   "note": "Enforce a budget across the whole task, not just one call.",
   "from": "long-horizon"
  },
  {
   "type": "combines_with",
   "to": "guardrails",
   "note": "Check proposed actions on every scheduled run.",
   "from": "agent-teammates"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Keep an activity log and track pending approvals.",
   "from": "agent-teammates"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Test allowed, forbidden, and approval-required actions over repeated runs.",
   "from": "agent-teammates"
  },
  {
   "type": "combines_with",
   "to": "delegating",
   "note": "Make each role accountable for a defined part of the work.",
   "from": "organizations-swarms"
  },
  {
   "type": "combines_with",
   "to": "observability",
   "note": "Trace which role introduced or checked each claim and action.",
   "from": "organizations-swarms"
  },
  {
   "type": "combines_with",
   "to": "cost-optimization",
   "note": "Cap roster growth and coordination costs.",
   "from": "organizations-swarms"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Test the complete team and whether additional roles improve outcomes.",
   "from": "organizations-swarms"
  },
  {
   "type": "combines_with",
   "to": "safety",
   "note": "Enforce physical operating limits independently of model proposals.",
   "from": "embodied"
  },
  {
   "type": "combines_with",
   "to": "evals",
   "note": "Evaluate control limits and real-world behavior as well as simulation outcomes.",
   "from": "embodied"
  }
 ],
 "page_blocks": {
  "use": "No code. Where this lives in products the reader has.",
  "build": "Runnable example, trace, failure modes, eval.",
  "run": "200 words: what to monitor, cost at volume, how it fails in production, what to log.",
  "try": "Two or three exercises, at least one per lane.",
  "out_there": "Named developers, models, products and tools that embody this order, by id from landscape.json. At least two makers where two exist."
 },
 "teardowns": {
  "cap": 6,
  "expires_days": 180,
  "first": [
   {
    "slug": "deep-research-mode",
    "title": "A deep-research mode, decoded",
    "patterns": [
     "agentic-rag",
     "parallelization",
     "debate-review",
     "orchestrator-workers"
    ]
   },
   {
    "slug": "coding-agent",
    "title": "A coding agent, decoded",
    "patterns": [
     "agent-harness",
     "single-agent",
     "coding-agents",
     "skills",
     "orchestrator-workers",
     "safety"
    ]
   },
   {
    "slug": "agent-teammate",
    "title": "An always-on agent teammate, decoded",
    "patterns": [
     "agent-teammates",
     "long-horizon",
     "computer-use",
     "human-in-the-loop"
    ]
   },
   {
    "slug": "answer-engine",
    "title": "A search-grounded answer engine, decoded",
    "patterns": [
     "rag",
     "context-engineering",
     "routing"
    ]
   },
   {
    "slug": "workplace-assistant",
    "title": "A workplace assistant over your own documents, decoded",
    "patterns": [
     "rag",
     "embeddings-search",
     "knowledge-graphs",
     "safety"
    ]
   },
   {
    "slug": "browser-agent",
    "title": "A browser agent, decoded",
    "patterns": [
     "computer-use",
     "single-agent",
     "human-in-the-loop",
     "safety"
    ]
   }
  ]
 },
 "recipe_backlog": {
  "note": "Planned nodes only. They show breadth on the matrix and cost nothing until a phase picks them up.",
  "built": "A node leaves this list when a recipe covers it. Built in wave 9: household paperwork (household-paperwork), trip planning with bookings (trip-planning), meeting to decisions and owners (meeting-notes), contract review against a checklist (contract-review), invoice matching (invoice-matching), incident response runbook (incident-runbook), storyboard from a script (storyboard-from-a-script), grading against a rubric with a human check (rubric-grading), and literature review (literature-watch), which is the site's one worked example of two job shapes joined: a watch and a per-item read, each settled on its own level. The engineering-and-lab group is empty because the engineering recipes already cover all four of its nodes: datasheet question answering is ask-the-datasheet, design review against requirements is design-review-checklist, test log triage is test-failure-triage, and lab notebook to report is measurement-writeup.",
  "personal": [
   "personal knowledge base"
  ],
  "knowledge-work": [],
  "engineering-and-lab": [],
  "business-operations": [
   "lead qualification",
   "questions over a database in natural language"
  ],
  "creative": [
   "brand-consistent image sets"
  ],
  "education": [
   "tutor that follows a syllabus"
  ]
 },
 "level_rule": "A new level starts where the answer to “who decides the next step” changes: nobody, you, your code, the model for one action, the model for every step, several models, the models including when to start.",
 "tracks_overview": {
  "title": "Topics at every level",
  "who": "These topics apply whichever level you use.",
  "description": "Five topics cut across all the levels. Each has its own set of pages."
 }
}