Glossary

A unit of work with a goal and a measurable state. Every complex request is decomposed into tasks that can be tracked, executed, and completed independently.

A conversation context that spans multiple interactions. A thread holds the full history of messages between the user and the agent system, across multiple runs.

A single execution attempt within a thread. Each run processes one or more tasks and produces results. A thread may contain multiple runs if the first attempt fails or the user adds follow-up requests.

The isolation mode for running a task. OpenAgention teaches three lanes: local (runs in your working directory), worktree (runs in an isolated git directory), and cloud-like (runs in a remote environment). Each lane offers different tradeoffs between speed, safety, and cost.

An isolated git working directory bound to a specific task. Each worktree has its own file tree and index, so changes in one task cannot interfere with another. This is the key isolation primitive in the system.

An output that needs human approval before proceeding. When an agent produces code changes, a review item is created so a human can approve, reject, or request revisions before the changes are merged.

An injected capability that gives an agent domain knowledge. Instead of cramming everything into the system prompt, skills provide focused knowledge and tools for specific domains — like a database migration skill or a testing skill.

A background workflow triggered by events or schedules. Automations run without direct user interaction — for example, running tests on every commit, or summarizing PR discussions overnight.

A snapshot of system state for resume or rollback. Checkpoints capture the conversation history, task graph state, and metadata at a specific point. If something goes wrong, you can restore from a checkpoint instead of starting over.

An observable record of what happened during execution. Every LLM call, tool invocation, state transition, and error is captured as a trace event. The trace is how you understand and debug agent behavior after the fact.

Model Context Protocol — a standardized interface for connecting agents to external tools and data sources. Instead of building custom integrations for every service, MCP provides a uniform protocol that any tool provider can implement, making agents instantly compatible with new capabilities.

An enforced output schema that constrains the agent's response to a specific shape. Instead of parsing free-form text, structured output guarantees the agent returns valid JSON matching a predefined schema — enabling reliable downstream processing.

A feedback loop where the agent's output is validated against rules or schemas, and failures are fed back as context for a corrective retry. This pattern turns single-shot generation into iterative refinement, dramatically improving reliability for complex outputs.

Source tracking that records where each claim or artifact originated. Provenance metadata links generated content back to the tools, documents, and reasoning steps that produced it — essential for auditability and trust in production systems.

A pattern for processing multiple items concurrently with controlled parallelism. Batch processing manages rate limits, collects results, and handles partial failures — turning what would be sequential one-at-a-time work into efficient parallel execution.

A failure isolation gate that prevents cascading errors. When a downstream service or tool starts failing, the circuit breaker opens to stop further requests, gives the service time to recover, and then cautiously allows traffic again — protecting the overall system from a single point of failure.