Appendix

Key Terms

Key terms used across the website.

Agents

Agent: An AI model that uses tools to complete a task. It reads each result and decides its next step.
Agent Loop: The cycle where an agent picks an action, runs it, and reads the result before it picks the next one.
Coding Agent: An agent built to change code in a repository and run its tests.
Multi-Agent System: Several agents that split a task and pass results between them.
Orchestrator: An agent or program that assigns work to other agents and collects their results.
Subagent: A second agent that handles one task in its own context and reports back a short result.

Deterministic: Gives the same result every time for the same input.
Grounding: Backing a claim with evidence you can check, such as source code or a test result.
Hallucination: A false or unsupported claim that a model states as fact.
Large Language Model: A model trained on large amounts of text to predict the next token. Often shortened to LLM.
Probabilistic: Can give a different result each time for the same input. Check generated output before you trust it.
Prompt: The input a person or a program sends to a model.
Sycophancy: A model's tendency to agree with the user instead of saying what is correct.
Temperature: A setting that controls how much randomness goes into a model's output.
Token: The unit a model reads and writes. A token may be a whole word or part of one.

API: A defined way for one program to request work from another.
Function Calling: A model asks the application to run a named tool. The application runs it and returns the result.
MCP: Model Context Protocol. A standard way to connect an agent to outside tools and data.
MCP Server: A program that offers tools or data to agents through MCP.
Tool: A function the application lets the model call, such as reading a file.
Tool Call: One request from the model to run a tool with specific inputs.

Automatic Compaction: Compaction that starts on its own when the context window is nearly full.
Checkpoint: A saved point in a session that you can return to.
Compaction: Replacing a long conversation with a shorter summary. Some details get lost.
Context Degradation: A model gets less reliable as its context grows long or cluttered.
Context Engineering: Choosing what the model sees at each step of a task.
Context Window: All the text a model can see at once. It has a fixed size limit.
Conversation History: The earlier turns of a session that the model sees again with each request.
Rewind: Returning a conversation to an earlier point and dropping the turns after it.
Session: One continuous conversation with an agent.

Decision Record: A short note of a decision and the reason behind it.
Embedding: A list of numbers that represents the meaning of a piece of text.
Handoff: A note with what the next session needs to continue a task.
Memory: Information an agent keeps beyond a single session.
RAG: Retrieval-augmented generation. The application finds relevant documents and adds them to the model's input.
Retrieval: Finding stored information that fits the current task.
Semantic Search: Search that matches meaning instead of exact words.
Vector Database: A database that stores embeddings and finds the closest matches to a query.

Permission: A rule that allows or blocks a specific agent action.
Plan Mode: A mode where the agent researches and proposes a plan without changing any files.
Sandbox: An isolated environment that limits what an agent's commands can reach.
Secret: A password or API key that must stay out of prompts and logs.

AGENTS.md: An open instruction file format that many coding agents read, including Codex.
CLAUDE.md: The instruction file Claude Code reads at the start of a session.
Custom Command: A saved prompt you run by name.
Hook: A script that runs automatically at a set point in an agent session, such as before a tool call.
Instruction File: A file in a repository that gives agents standing guidance for that project.
Plugin: A package that adds features such as commands or hooks to an agent application.
Skill: A saved set of instructions an agent loads when a task needs it. It can include scripts.
Slash Command: A command typed with a leading slash that runs a built-in action or a saved prompt.

Branch: A separate line of work in a repository.
Code Review: A person or an agent reading a change before it merges.
Commit: A saved snapshot of changes with a message that describes them.
Diff: The line-by-line difference between two versions of a file.
Git: A version control system that records every change to a project's files.
Merge: Combining the changes from one branch into another.
Pull Request: A request to merge one branch into another after review.
Rebase: Replaying a branch's commits on top of a newer commit.
Repository: A project folder tracked by version control along with its full history.
Reset: Moving the current branch back to an earlier commit. A hard reset also throws away uncommitted changes.
Revert: A new commit that undoes an earlier one.
Revision: A specific version of the code, usually named by its commit ID.
Stacked Pull Request: A pull request built on top of another one that has not merged yet. Each review covers one change.
Worktree: A second working folder for the same Git repository. Two agents can work in separate worktrees at once.

Artifact: An output of agent work, such as a patch or a test log.
Budget: A limit on how much time or money a run may spend.
Idempotency: Running an operation twice has the same effect as running it once.
Pipeline: A series of stages that run in order. Each stage passes its output to the next.
Ralph Loop: Running an agent on the same task again and again with a fresh session each time. Progress is saved in files between runs.
Retry: Running a failed step again.
Run: One execution of a pipeline from start to finish.
Runner: The program that starts each stage and records whether it passed.
Stage: One step in a pipeline with its own input and output.
Stop Condition: The rule that tells a run when to finish or pause.
Timeout: A limit on how long a step may run before it is stopped.
Trigger: The event that starts a run, such as a schedule or a new issue.
Worker: A process that takes waiting tasks and runs them.
Workflow: A repeatable way of carrying a task from start to finish.

Acceptance Criteria: The conditions a change must meet before it counts as done.
End-To-End Test: A test that runs the whole application the way a user would.
Eval: A repeatable test of how well a model or an agent handles a set of tasks.
Exit Code: A number a program returns when it ends. Zero usually means success.
Gate: A check that decides whether a workflow moves to the next step.
Health Check: A larger check that runs every few stages instead of after each one.
Human In The Loop: A gate where a person approves the work before it moves on.
Integration Test: A test that checks how several parts work together.
LLM As Judge: Using a model to grade output that a script cannot check.
Mock: A fake version of a service used in tests.
Mutation Testing: Changing the source on purpose to see whether the tests catch it.
Regression Test: A test that guards against a fixed bug coming back.
Test: Code that checks whether other code behaves as expected.
Type Check: A check that values match their declared types before the code runs.
Unit Test: A test of one small piece of code on its own.