Plain meaning before technical language.

A system that pursues a bounded outcome through reasoning or tools.

Example: It researches three named sources and returns citations.

Not an example: Any chatbot reply, regardless of action or scope.

The runtime that gives an agent tools, context and execution rules.

Example: A coding environment exposes files and a test command.

Not an example: The model alone without its surrounding runtime.

A visible operating layer that keeps human intent, authority and choices legible.

Example: A checkpoint returns a risky choice to its owner.

Not an example: An invisible policy that silently decides for the person.

One optional response to one repeated pressure in agent work.

Example: Lean keeps a small task proportionate.

Not an example: A mandatory stack that must be adopted whole.

A versioned set of instructions and supporting files that a harness can load.

Example: A reviewed module is installed at project scope.

Not an example: Text copied from an unknown source and trusted automatically.

A complete piece of work carrying its outcome, context, authority, boundary and evidence request.

Example: Fix one form and return the diff plus checks.

Not an example: Improve the whole product however you think best.

The exact surface a task may read, change or leave untouched.

Example: Only the checkout component may be edited.

Not an example: The repository probably needs cleanup too.

Explicit permission for a specific kind of action.

Example: The agent may edit local files but may not deploy.

Not an example: A useful suggestion is treated as permission.

The accountable point that shapes work, tracks dependencies and integrates returns.

Example: Root gives two disjoint cells separate scopes.

Not an example: Every lane edits the same files and merges itself.

A lane with one objective, one owned scope and one returned artifact.

Example: A cell audits metadata without editing UI files.

Not an example: A helper explores anything related to the project.

The only actor allowed to change a mutable scope at that time.

Example: One agent owns the illustration component.

Not an example: Two agents patch the same stylesheet concurrently.

The accountable act of checking and joining compatible returns.

Example: Root reviews two disjoint patches before combining them.

Not an example: Accepting every returned file because tests pass.

A check performed outside the lane that produced the claim.

Example: A second reviewer verifies the built page.

Not an example: The author restates that their own output is correct.

The artifact, observation or validation that supports a claim.

Example: A screenshot and measured viewport support a layout claim.

Not an example: The answer sounds confident.

Checked against a named method or source.

Example: The production build completed with exit code zero.

Not an example: It should build because typecheck passed.

Directly seen in a bounded case without claiming a universal cause.

Example: This run took 1,176 seconds.

Not an example: All users will save the same amount of time.

Calculated from stated assumptions rather than directly measured.

Example: Cost is estimated from published pricing on a named date.

Not an example: An unknown price is reported as exact.

A desired result that has not yet been verified as achieved.

Example: Target: no horizontal overflow at 390px.

Not an example: The target is presented as a measured result.

A material field for which reliable evidence is not available.

Example: Provider cost is unknown for this archived run.

Not an example: A convenient value is invented to fill the gap.

The information a lane needs to understand its bounded work.

Example: The component API and acceptance checks travel with the task.

Not an example: The entire private workspace is shared just in case.

Input reused by the provider instead of processed as entirely new context.

Example: A trace reports gross and cached input separately.

Not an example: Cached input is assumed to equal money saved.

Real elapsed time from the start of a bounded run to its return.

Example: The run starts at 10:00 and returns at 10:06.

Not an example: Only model generation time is counted.

The work required to divide, communicate, review and integrate several lanes.

Example: Root resolves one dependency before merging two cells.

Not an example: Parallel work is treated as free speed.

A bounded task whose effects can be safely undone.

Example: Edit a local component and compare the diff.

Not an example: Change public visibility without a rollback path.

A change outside the local working copy that can affect systems, data or people.

Example: Publishing a deployment changes the live site.

Not an example: Reading a local source file.