Glossary
Plain-English definitions for the terms you’ll see across these docs. Hover or tap any underlined term in the prose to surface a short definition — the Full entry → link in the popover scrolls you here.
- admission
Placing a card in the drainable column. Admission is intent; completion is truth.
A column may carry intent and must never carry truth. Dragging a card to a done column declares nothing about whether the work succeeded — only the outcome pointer does that.
- Artifact
A work product whose existence and content are observable facts — a file at a path the card’s acceptance criteria named, or a commit.
Distinguish an artifact from a result declaration — a worker’s claim about how it went. The artifact is fact; the declaration is opinion, and nothing schedules off opinion.
- Background Runner
The workspace scheduler that drains the Ready column of its connected board, plus queued loops, dispatching each eligible item into its own lane.
See also: Background Runner
- Board
The kanban board — the mutable, realtime record of intent: what should happen and in what order.
Boards and cards live in their own collections; the kanban tile is a view of the board, not the board itself. Humans and the root orchestrator both edit it. A board is a queue, not a run — it has no terminal success state.
- Card
One unit of work with a prompt — the only work type there is.
There are no step modes. Verification is not a different kind of thing: it is a card that depends on another card. A card is sized by statability — if you cannot write checkable acceptance criteria for it, it is too big or too vague.
- continuous drain
The termination mode: a board is a queue, not a run, so there is no terminal success state.
"Idle" means nothing is eligible right now — never that the objective is met. No surface reports "complete" at board level, and a board is never called a Run. Do not confuse this with the Background Runner's drain-once mode ("process the queue until empty, then stop") — that decides when the runner turns itself off; here idle is a queue state, not completion.
- DAG
Directed Acyclic Graph — nodes connected by one-way edges that never form a cycle.
A graph where edges point in one direction and no path loops back on itself.
- dependency edge
The only edge type — a card’s "blocked by" list.
A dependency expresses necessity, never ordering. The test is: could this card start and produce something useful if the other had not run? If yes, there is no edge. Ordering is expressed by card order within a column, not by edges. The structure is cycle-safe.
- Desktop
A named collection of tiles. Use desktop tabs to switch between collections in a workspace.
- drain (drain-once)
A Background Runner lifecycle mode — process the queue until empty, then stop.
See also: Background Runner
- drain tick
The deterministic dispatch step — one card per call: find one ready card, claim it once, create its lane, spawn its agent.
Returns spawned, at-capacity, or idle. The Background Runner runs it on each scheduler pass. Its "drain-once" and "standing" lifecycle modes decide what an idle result means for the runner, not how the tick dispatches.
- drainable column
The one column, chosen in the Background Runner's settings, whose cards are admitted — "this may be picked up".
A runner setting, not a property of a card, and there is exactly one. A new board with To do / Doing / Done columns has To do filled in, so connecting it is one step. Dependencies still decide eligibility; admission alone does not make a card ready. Two drainable columns would need an arbitration rule, which is scheduling policy.
- fast-forward
A git merge that moves a branch pointer forward to a descendant commit, with no merge commit.
Only possible when the target branch has no commits the source branch doesn’t already contain.
- FF (fast-forward)
Short for fast-forward — a git merge that just moves the branch pointer to a descendant commit, with no merge commit.
- Full YOLO
Marketing shorthand for letting the workspace run itself — the Background Runner on, with After success set to Auto merge. There is no one-tap "Full YOLO" preset in the app: the header chip reads "Runner: <state>" (On, Off, No board, Paused, Finishing, Cancelling), and its popover offers "Start runner" (confirmed with the drained board and target branch named, starting the Kanban runner with its saved settings) or "Finish current, then pause", plus "All settings". With no board connected it shows a board and column picker with "Connect and start" instead.
See also: Background Runner
- git worktree
A separate working directory backed by the same git repo, with its own checked-out branch.
Native git feature (`git worktree add`). YOLO lanes do not use worktrees: each lane is an independent `git clone` of the workspace repo (see Lane).
- Goal
An outcome you want to make happen, with success checks and a plan of steps. You queue each step as a card and review the results; only you mark a goal achieved.
See also: Goals
- Kata Container
A container backed by a lightweight VM (with its own guest kernel) for kernel-level isolation.
See also: Sandbox isolation
- KVM
Kernel-based Virtual Machine — Linux's built-in hardware virtualization layer. YOLO pods require it to schedule.
- Lane
A full git clone of the workspace repo at ~/lanes/<name>, with its own index — where one agent works on one branch.
Created by `git clone <workspace> ~/lanes/<name>`, in the same pod on the same volume as the workspace. That makes a lane git-state isolation only: it is not resource isolation and it is not a security boundary. A lane is the execution vehicle for a card, not the unit of work itself.
- Live agent
The agent the user is currently chatting with in a workspace — pinned to the main desktop.
- MCP
Model Context Protocol — the standard YOLO uses to expose tools (studio.*, deploy.*, loops.*, yolo_background.*, …) to coding agents.
MCP is an open protocol for connecting AI models to tools and data sources. Agents use the workspace MCP server to inspect workspace state, manage tiles and boards, and publish artifacts.
- outcome pointer
The system-written record of what a card actually produced: lane id, exit status, artifact, commit SHA, and when it was observed.
Never human-written and never worker-declared. Readiness reads the outcome pointer, never a column: a card dragged to done with no successful pointer does not unblock its dependents. The record is written before the lane is reclaimed.
- Pod
Kubernetes' smallest deployable unit — one or more containers sharing network and storage.
- PVC
Persistent Volume Claim — Kubernetes durable storage attached to a pod that survives pod restarts.
- root orchestrator
The agent that curates intent and interprets results — decomposes objectives into cards, authors prompts, reads outcomes, proposes follow-up work.
It never computes readiness, holds a lease, or dispatches. It must be disposable: kill it and a fresh one reconstructs everything it needs from the board.
- Runner
The agent process executing work inside a lane (e.g. Claude Code, Codex, opencode-yolo).
The runner is what actually edits files, runs commands, and emits events. It receives its task at spawn time on stdin (or a prompt file, never on argv) and reports status by emitting lane events.
See also: CLIs
- sandbox
An isolated workspace container. Each YOLO workspace runs in its own Kata-isolated pod with its own guest kernel.
See also: Containers
- Scout
A read-only, ephemeral spawn with no lane and no card.
Scouts look things up and report back. The moment a spawn can write, it is a worker and needs a card.
- spawn anchor
The commit a lane was branched from. Used to compute commitsSinceSpawn for the no-commits failure heuristic.
- SSE
Server-Sent Events — a one-way HTTP streaming protocol the server uses to push events to the browser.
- standing
A Background Runner lifecycle mode — long-lived orchestrator that idles on an empty queue and waits for new work.
See also: Background Runner
- terminal-mux
The service that serves web terminals over HTTP/WebSocket inside every YOLO sandbox. Runs on port 7782.
terminal-mux multiplexes several terminal sessions over one service and carries the context bus that studio.send_to_tile uses to deliver prompts to agent tiles. Port 3000 is left free for your own dev server.
- Tile
A panel in the workspace UI. Tiles host agents, terminals, previews, browsers, kanban boards, etc.
See also: Tiles
- ttyd
A small web-terminal daemon kept only as an emergency fallback for terminal-mux.
terminal-mux serves terminals; ttyd starts on port 7782 only if terminal-mux is missing. Port 3000 is left free for your dev server.
- WebSocket
A two-way streaming protocol over a single TCP connection. YOLO uses WebSockets to ship live tile events to the browser.
- Worker
The agent dispatched to execute one card — it gets the card, a lane, a claim, and an outcome pointer.
A worker is dispatched, never self-selected. The dividing line against a scout is write access: a spawn that can write is a worker and needs a card.
- WS (WebSocket)
Short for WebSocket — a two-way streaming protocol over a single TCP connection.
- YOLO Mode
The workspace autonomy umbrella: the landing mode: whether finished, verified work is left for you, opened as a PR for review, or merged automatically (respecting your repository's checks and review settings), plus the Background Runner. The runner's own After success setting (Manual, PR + review, Auto merge) governs Kanban landing; Auto only ever merges mechanically verified work at the exact reviewed commit.
See also: Background Runner