# Gradient Ascent
Practical examples and design guidance: six practical examples within the existing recipe Markdown pages, starting at https://reedos.dev/gradient_ascent/recipes/document-qa.md, and https://reedos.dev/gradient_ascent/design-decisions.md. The examples have local-model smoke records, not a quality benchmark. See https://reedos.dev/gradient_ascent/downloads/quality-prototype-notes.md for scope and limitations.
Brief improvement team application: https://reedos.dev/gradient_ascent/examples/reviewer-feedback-loop.md — a lead agent coordinates a writer, parallel receiving agents, independent reviewers, and revisions; includes supporting evaluation methods.
Project tools and Markdown templates: https://reedos.dev/gradient_ascent/tools.md — agent instructions, workflows, acceptance criteria, workflow audits, tool specifications, and project handoffs.
Project brief builder: https://reedos.dev/gradient_ascent/apply/ — copy or download a brief for your own model. Blank template: https://reedos.dev/gradient_ascent/project-brief.md.

Worked examples: https://reedos.dev/gradient_ascent/examples/ — 98 authored, scripted cases with evidence, changed conditions, and review decisions.
> A manual for the main ways to use a language model, from one chat message to agents that run on their own, in eight levels ordered by how much the model decides for itself. Each level's techniques (49 written or planned) show what it costs and how it fails, not just how it works. Technique, topic, thread, recipe, teardown, level, and builder pages have a clean Markdown version at the same path with .md appended, for example /techniques/rag.md.

> How a level is defined: 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.

> Status: most technique, topic and recipe pages are SOURCED — written with primary references, not guaranteed error-free, but with no recorded run and no scored result file behind them. A page marked MEASURED prints a committed result file, the model it ran on and that model's class, and holds only for that class. Every other cost strip and every stepped trace is an illustration and is labeled as one.

## If a person sent you here to help them choose
Read agents.md first. It says what to ask them, how to walk the seven-question worksheet to the candidate level and check the design against their desired automation and human effort, how to name the shape of the job and use the worked examples as illustrations, what a good answer contains, and what not to claim. Their instructions outrank anything on this site.
- [/agents.md](https://reedos.dev/gradient_ascent/agents.md): This guide: how to turn a person’s job into a recommendation.
- [/tools.md](https://reedos.dev/gradient_ascent/tools.md): Builder directory: choose a template for agent instructions, workflows, acceptance criteria, audits, tool specifications, or handoffs. Fetch its Markdown directly; completing the interactive form is not required.
- [/project-brief.md](https://reedos.dev/gradient_ascent/project-brief.md): Reusable project brief template and recommendation requirements; fill unknowns with questions.
- [/worksheet.md](https://reedos.dev/gradient_ascent/worksheet.md): The decision tree as text: seven questions that classify a candidate design, four that change the advice.
- [/shapes.md](https://reedos.dev/gradient_ascent/shapes.md): The kinds of job, by the shape of the work and not its subject: how to recognize each, where it usually settles, what moves it lower or higher, and jobs from other fields with the same shape.
- [/method.md](https://reedos.dev/gradient_ascent/method.md): Why the site exists, its ten principles, how a level is defined, how a name is checked, and what the registry is not. Other pages cite it.
- [/data/use-cases.json](https://reedos.dev/gradient_ascent/data/use-cases.json): Every recipe and teardown: the shapes it illustrates, the levels used by its illustrated design, the techniques it is made from, and where to read it.
- [/llms.txt](https://reedos.dev/gradient_ascent/llms.txt): An index of every page with a one-line description.
- [/llms-full.txt](https://reedos.dev/gradient_ascent/llms-full.txt): Every technique, recipe, teardown and thread page as Markdown in one file. Large.
- [/data/taxonomy.json](https://reedos.dev/gradient_ascent/data/taxonomy.json): Levels, techniques, recipes and the typed relations between pages (requires, upgrades_to with its condition, combines_with, alternative_to with its question).
- [/data/worksheet.json](https://reedos.dev/gradient_ascent/data/worksheet.json): The decision tree as data, with every reason resolved to plain text.
- [/data/shapes.json](https://reedos.dev/gradient_ascent/data/shapes.json): The job shapes as data.
- [/data/landscape.json](https://reedos.dev/gradient_ascent/data/landscape.json): The registry of named models, products and tools, each with its maker, what it demonstrates, a source and the date it was checked. Names change: read retired and superseded_by.
- [/data/glossary.json](https://reedos.dev/gradient_ascent/data/glossary.json): The terms the site uses, each defined from the page that explains it.
- [/data/timeline.json](https://reedos.dev/gradient_ascent/data/timeline.json): Dated milestones per level, with sources.
- [/data/frontier.json](https://reedos.dev/gradient_ascent/data/frontier.json): What is still unsolved at each level and what is being tried, with sources and the date checked.
- [/data/changes.json](https://reedos.dev/gradient_ascent/data/changes.json): What changed on this site and when. Check it if you cited a page before.

## Levels
- [Level 0 · Conventional software](https://reedos.dev/gradient_ascent/levels/0/): 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.
- [Level 1 · Direct prompting](https://reedos.dev/gradient_ascent/levels/1/): 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.
- [Level 2 · Added context](https://reedos.dev/gradient_ascent/levels/2/): 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.
- [Level 3 · Workflows](https://reedos.dev/gradient_ascent/levels/3/): 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.
- [Level 4 · Tool use](https://reedos.dev/gradient_ascent/levels/4/): 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.
- [Level 5 · Agent loops](https://reedos.dev/gradient_ascent/levels/5/): 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.
- [Level 6 · Teams of Agents](https://reedos.dev/gradient_ascent/levels/6/): 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.
- [Level 7 · Always-on agents](https://reedos.dev/gradient_ascent/levels/7/): 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.

## Techniques by level
- [When not to use a model](https://reedos.dev/gradient_ascent/techniques/order-zero.md): How to tell when ordinary code, search or a form is enough.
- [Chat](https://reedos.dev/gradient_ascent/techniques/chat.md): Asking a model a question in a chat app.
- [Prompt engineering](https://reedos.dev/gradient_ascent/techniques/prompt-engineering.md): Writing instructions that get consistent results.
- [Structured output](https://reedos.dev/gradient_ascent/techniques/structured-output.md): Getting answers in a fixed format such as JSON.
- [Reasoning at answer time](https://reedos.dev/gradient_ascent/techniques/inference-time-reasoning.md): Letting the model think for longer before it answers.
- [Images, audio and video](https://reedos.dev/gradient_ascent/techniques/multimodal.md): Giving the model images, audio, video and documents, and getting them back.
- [Context engineering](https://reedos.dev/gradient_ascent/techniques/context-engineering.md): Deciding what goes into the request, and caching the parts that repeat.
- [Embeddings and search](https://reedos.dev/gradient_ascent/techniques/embeddings-search.md): Finding text by meaning instead of by keyword.
- [Retrieval-augmented generation (RAG)](https://reedos.dev/gradient_ascent/techniques/rag.md): Searching your documents and giving the results to the model.
- [Knowledge graphs and GraphRAG](https://reedos.dev/gradient_ascent/techniques/knowledge-graphs.md): Storing facts as entities and relations, for questions that span several documents.
- [Memory](https://reedos.dev/gradient_ascent/techniques/memory.md): Keeping information from one conversation to the next.
- [Prompt chaining](https://reedos.dev/gradient_ascent/techniques/prompt-chaining.md): Splitting a task into steps, each with its own prompt.
- [Routing](https://reedos.dev/gradient_ascent/techniques/routing.md): Sorting inputs and sending each one to the right prompt.
- [Parallel calls](https://reedos.dev/gradient_ascent/techniques/parallelization.md): Running several prompts at once and combining the results.
- [Write and check](https://reedos.dev/gradient_ascent/techniques/evaluator-optimizer.md): One prompt writes, another checks, and the loop repeats until the check passes.
- [Workflow graphs](https://reedos.dev/gradient_ascent/techniques/workflow-graphs.md): Describing a workflow as steps and the connections between them.
- [Human approval](https://reedos.dev/gradient_ascent/techniques/human-in-the-loop.md): Pausing for a person to approve or correct.
- [Function calling](https://reedos.dev/gradient_ascent/techniques/function-calling.md): Letting the model call functions that you define.
- [Code execution](https://reedos.dev/gradient_ascent/techniques/code-execution.md): Letting the model write code and run it in a sandbox.
- [Model Context Protocol](https://reedos.dev/gradient_ascent/techniques/mcp.md): A standard way to connect models to tools and data.
- [Computer and browser use](https://reedos.dev/gradient_ascent/techniques/computer-use.md): Letting the model operate a screen, a mouse and a keyboard.
- [Single agent](https://reedos.dev/gradient_ascent/techniques/single-agent.md): A model that plans, acts and checks its own work in a loop.
- [The agent harness](https://reedos.dev/gradient_ascent/techniques/agent-harness.md): Everything around the model in an agent: the loop, tools, context handling, permissions, caps and sandbox.
- [Agentic RAG and deep research](https://reedos.dev/gradient_ascent/techniques/agentic-rag.md): An agent that runs its own searches until it has an answer.
- [Coding agents](https://reedos.dev/gradient_ascent/techniques/coding-agents.md): Agents that read, write, run and test code.
- [Skills](https://reedos.dev/gradient_ascent/techniques/skills.md): Reusable instructions that an agent loads when it needs them.
- [Voice agents](https://reedos.dev/gradient_ascent/techniques/voice-agents.md): Agents you talk to in real time.
- [Lead agent and workers](https://reedos.dev/gradient_ascent/techniques/orchestrator-workers.md): A lead agent splits the task and hands parts to other agents.
- [Agent graphs](https://reedos.dev/gradient_ascent/techniques/agent-graphs.md): Describing a team of agents and how work passes between them.
- [Review and debate](https://reedos.dev/gradient_ascent/techniques/debate-review.md): Agents that check, or argue with, each other's work.
- [Long-running tasks](https://reedos.dev/gradient_ascent/techniques/long-horizon.md): Tasks that run for hours or days.
- [Always-on assistants](https://reedos.dev/gradient_ascent/techniques/agent-teammates.md): Agents that resume work across sessions, schedules, and events.
- [Organizations of agents](https://reedos.dev/gradient_ascent/techniques/organizations-swarms.md): Large groups of agents with roles and shared goals.
- [Robots and machines](https://reedos.dev/gradient_ascent/techniques/embodied.md): Models that control robots and other machines.

## Topics
- [Topics at every level](https://reedos.dev/gradient_ascent/levels/tracks/): Five topics that apply whichever level you use.
- [Evals](https://reedos.dev/gradient_ascent/techniques/evals.md): Measuring whether a change made the results better.
- [Evaluation frameworks](https://reedos.dev/gradient_ascent/techniques/eval-frameworks.md): The tools that run test sets and graders for you, and what to check before trusting their numbers.
- [Changing the model](https://reedos.dev/gradient_ascent/techniques/adaptation.md): Fine-tuning, distillation, synthetic data and automated prompt tuning.
- [Fine-tuning and adapters](https://reedos.dev/gradient_ascent/techniques/fine-tuning.md): Training a model further on your own examples, in full or with small adapters such as LoRA.
- [Distillation](https://reedos.dev/gradient_ascent/techniques/distillation.md): Training a smaller model to reproduce what a larger one does on your task.
- [Synthetic data](https://reedos.dev/gradient_ascent/techniques/synthetic-data.md): Using a model to write training or test examples, and checking them before they are used.
- [Prompt optimization](https://reedos.dev/gradient_ascent/techniques/prompt-optimization.md): Letting a program search for better prompts against a test set.
- [Safety, privacy and governance](https://reedos.dev/gradient_ascent/techniques/safety.md): Prompt injection, permissions, data handling and audit.
- [Guardrails](https://reedos.dev/gradient_ascent/techniques/guardrails.md): Checks on what goes into a model and what comes out, and the limits of those checks.
- [Red teaming](https://reedos.dev/gradient_ascent/techniques/red-teaming.md): Attacking your own system on purpose, before someone else does, and turning what you find into tests.
- [Operations](https://reedos.dev/gradient_ascent/techniques/ops.md): Cost, speed, monitoring and running models on your own hardware.
- [Observability](https://reedos.dev/gradient_ascent/techniques/observability.md): Recording what each run did, so a bad result can be traced to the step that caused it.
- [AI gateways](https://reedos.dev/gradient_ascent/techniques/ai-gateways.md): One entry point in front of several model providers, for keys, routing, limits, fallback and logs.
- [Cost optimization](https://reedos.dev/gradient_ascent/techniques/cost-optimization.md): Spending fewer tokens and less time for the same result: caching, batching, smaller models, shorter context.
- [Running models locally](https://reedos.dev/gradient_ascent/techniques/local-inference.md): Running open-weight models on your own hardware: what fits, quantization, and what you give up.
- [Working with a model](https://reedos.dev/gradient_ascent/techniques/operator-craft.md): How to brief a model, review its work and decide what to hand over.
- [Briefing: saying what you want](https://reedos.dev/gradient_ascent/techniques/briefing.md): Saying what you want clearly enough that the model does not have to guess.
- [Reviewing work you did not do](https://reedos.dev/gradient_ascent/techniques/reviewing.md): Checking work you did not do yourself before it goes anywhere.
- [Deciding what to hand over](https://reedos.dev/gradient_ascent/techniques/delegating.md): Deciding which parts of a task to hand to a model and which to keep.
- [Calibrating trust](https://reedos.dev/gradient_ascent/techniques/trust.md): Learning, from results over time, how much to rely on a model without checking.

## Threads
- [Graph engineering](https://reedos.dev/gradient_ascent/threads/graph-engineering.md): Two uses of graphs that are often confused: graphs that connect information, and graphs that connect work. Knowledge graphs connect information; agent graphs connect work.
- [Who approves what](https://reedos.dev/gradient_ascent/threads/who-approves-what.md): 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. A person never leaves; what they hold changes from the answer, to the action, to the rules the actions run under.
- [Checking the work](https://reedos.dev/gradient_ascent/threads/checking-the-work.md): 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. Every level has a way to be wrong that the level below could not be, and a check that costs less than the mistake.
- [What the model sees](https://reedos.dev/gradient_ascent/threads/what-the-model-sees.md): 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. A model knows what it was trained on and what is in this request; everything else is a choice somebody made.

## Recipes
- [Answer questions about a set of documents](https://reedos.dev/gradient_ascent/recipes/document-qa/): Uses RAG, structured output and an eval set. Level 2 is enough because a single search answers most questions. (this example uses level 2)
- [Sort an inbox](https://reedos.dev/gradient_ascent/recipes/inbox-triage/): 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. (this example uses level 3)
- [Write a research brief with citations](https://reedos.dev/gradient_ascent/recipes/research-brief/): 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. (this example uses level 5)
- [Coding assistant on your own repo](https://reedos.dev/gradient_ascent/recipes/repo-assistant/): 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. (this example uses level 5)
- [Turn photos and PDFs into records](https://reedos.dev/gradient_ascent/recipes/document-extraction/): Reads the image or PDF, fills a fixed schema, and saves the record once a person confirms it. (this example uses level 3)
- [Voice notes into structured entries](https://reedos.dev/gradient_ascent/recipes/voice-notes/): Transcribes a voice note, splits it into steps, and turns each step into a structured entry that an eval set checks for accuracy. (this example uses level 3)
- [Support desk](https://reedos.dev/gradient_ascent/recipes/support-desk/): 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. (this example uses level 4)
- [Nightly source monitor](https://reedos.dev/gradient_ascent/recipes/nightly-monitor/): 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. (this example uses level 3)
- [Data analysis by conversation](https://reedos.dev/gradient_ascent/recipes/data-analysis/): A single agent writes and runs code against a dataset, one question at a time, to answer questions a fixed query could not anticipate. (this example uses level 5)
- [Drafting with a reviewer](https://reedos.dev/gradient_ascent/recipes/content-pipeline/): One prompt drafts a piece of writing and another checks it against a rubric, repeating until the draft passes. (this example uses level 3)
- [A team of personal assistants](https://reedos.dev/gradient_ascent/recipes/assistant-team/): Several always-on agents split personal tasks among themselves, sharing memory and staying inside the same safety rules. (this example uses level 7)
- [Plain-language maintenance log](https://reedos.dev/gradient_ascent/recipes/maintenance-log/): 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. (this example uses level 4)
- [Keep the household paperwork straight](https://reedos.dev/gradient_ascent/recipes/household-paperwork/): 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. (this example uses level 0)
- [Turn a meeting transcript into decisions and owners](https://reedos.dev/gradient_ascent/recipes/meeting-notes/): Turn a transcript into decisions, owners, and open questions in one model call. Someone who attended reviews the draft before it is shared. (this example uses level 1)
- [Match invoices to purchase orders](https://reedos.dev/gradient_ascent/recipes/invoice-matching/): 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. (this example uses level 3)
- [Check an agreement against your own checklist](https://reedos.dev/gradient_ascent/recipes/contract-review/): Check an agreement against a fixed checklist, with cited clauses for each finding. Merge the findings for a person to review. (this example uses level 3)
- [Turn an incident write-up into a runbook](https://reedos.dev/gradient_ascent/recipes/incident-runbook/): Turn an incident write-up into a timeline and repeatable steps. Check owners and success criteria, then ask the incident lead to approve it. (this example uses level 3)
- [Turn a script into a shot list](https://reedos.dev/gradient_ascent/recipes/storyboard-from-a-script/): 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. (this example uses level 3)
- [Plan a trip and hold the bookings](https://reedos.dev/gradient_ascent/recipes/trip-planning/): 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. (this example uses level 5)
- [Grade against a rubric, with a second reader](https://reedos.dev/gradient_ascent/recipes/rubric-grading/): Two independent reviewers apply the same rubric. Disagreements go to the teacher rather than being averaged away. (this example uses level 6)
- [Watch a topic for new work and summarize what turns up](https://reedos.dev/gradient_ascent/recipes/literature-watch/): 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. (this example uses level 1)
- [Assemble a weekly status report from several systems](https://reedos.dev/gradient_ascent/recipes/weekly-status-report/): 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. (this example uses level 1)
- [Keep a tracker document current from several sources](https://reedos.dev/gradient_ascent/recipes/project-tracker-upkeep/): 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. (this example uses level 3)
- [Check measurements against limits, and chart what drifts](https://reedos.dev/gradient_ascent/recipes/limits-without-a-model/): Use code to calculate limits, yield, process capability, and trends across lots and fixtures. The pass/fail decision stays deterministic; no model is involved. (this example uses level 0)
- [Sweep a design over its corners and report the margins](https://reedos.dev/gradient_ascent/recipes/characterize-a-design/): Sweep prototype boards across line, load, and temperature. Code calculates margins, uncertainty, and guardbanded verdicts; no model is needed. (this example uses level 0)
- [Turn a measurement session into a report somebody can review](https://reedos.dev/gradient_ascent/recipes/measurement-writeup/): 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. (this example uses level 1)
- [Answer questions from a datasheet, a test spec and a change notice](https://reedos.dev/gradient_ascent/recipes/ask-the-datasheet/): 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. (this example uses level 2)
- [Pull an instrument's accuracy table out of its manual](https://reedos.dev/gradient_ascent/recipes/accuracy-specs-from-the-manual/): Extract specification rows from a manual, validate their structure, and calculate uncertainty in code. A person verifies ranges, intervals, and conditions against the source. (this example uses level 3)
- [Sort failing units and operator notes into causes](https://reedos.dev/gradient_ascent/recipes/test-failure-triage/): 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. (this example uses level 3)
- [Check a board against the design rules document](https://reedos.dev/gradient_ascent/recipes/design-review-checklist/): 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. (this example uses level 3)
- [Turn a requirements list into a test plan](https://reedos.dev/gradient_ascent/recipes/requirements-to-test-plan/): 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. (this example uses level 3)
- [Draft an instrument control script from its programming manual](https://reedos.dev/gradient_ascent/recipes/instrument-script-from-the-manual/): 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. (this example uses level 4)
- [Ask questions of a production test log](https://reedos.dev/gradient_ascent/recipes/test-data-by-conversation/): 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. (this example uses level 4)
- [Work a bring-up problem at the bench](https://reedos.dev/gradient_ascent/recipes/bring-up-debug-assistant/): 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. (this example uses level 5)

## Teardowns
- [A deep-research mode, decoded](https://reedos.dev/gradient_ascent/teardowns/deep-research-mode/): one kind of product decoded into agentic-rag, parallelization, debate-review, orchestrator-workers (reviewed 2026-09-18, expires 2027-03-17).
- [A coding agent, decoded](https://reedos.dev/gradient_ascent/teardowns/coding-agent/): one kind of product decoded into agent-harness, single-agent, coding-agents, skills, orchestrator-workers, safety (reviewed 2026-09-18, expires 2027-03-17).
- [An always-on agent teammate, decoded](https://reedos.dev/gradient_ascent/teardowns/agent-teammate/): one kind of product decoded into agent-teammates, long-horizon, computer-use, human-in-the-loop (reviewed 2026-09-18, expires 2027-03-17).
- [A search-grounded answer engine, decoded](https://reedos.dev/gradient_ascent/teardowns/answer-engine/): one kind of product decoded into rag, context-engineering, routing (reviewed 2026-09-19, expires 2027-03-18).
- [A workplace assistant over your own documents, decoded](https://reedos.dev/gradient_ascent/teardowns/workplace-assistant/): one kind of product decoded into rag, embeddings-search, knowledge-graphs, safety (reviewed 2026-09-19, expires 2027-03-18).
- [A browser agent, decoded](https://reedos.dev/gradient_ascent/teardowns/browser-agent/): one kind of product decoded into computer-use, single-agent, human-in-the-loop, safety (reviewed 2026-09-19, expires 2027-03-18).

## Names
- [Named products, tools and models](https://reedos.dev/gradient_ascent/names/): Every developer, model, product and tool this site names, listed as of 2026-09-19.

## Map
- [Map](https://reedos.dev/gradient_ascent/map/): Every technique as a node, laid out by level, with the taxonomy's requires, upgrades-to, combines-with and alternative-to relations as edges, and the full edge list as text underneath.

## Method
- [Method](https://reedos.dev/gradient_ascent/method/): How a level is defined, how a page is written, how results are measured.

## What changed
- [What changed](https://reedos.dev/gradient_ascent/changes/): Dated record of what changed on this site and why it matters to a reader, newest first. Atom feed at https://reedos.dev/gradient_ascent/changes.xml.

## Glossary
- [Glossary](https://reedos.dev/gradient_ascent/glossary/): 106 terms a newcomer meets on this site, each defined from the page that explains it.

## Failure modes
- [Failure gallery](https://reedos.dev/gradient_ascent/failures/): 242 named failure modes across every technique, grouped by level, each with how to notice it and how to test for it.