Glossary
Terminology used across Tracker pipelines, the Dippin language, and the multi-agent runtime.
Pipeline & runtime
The core abstractions the engine works with.
Pipeline
A directed graph of nodes connected by edges, plus shared context. Defined in a .dip file and executed by the engine.
Engine
The Tracker runtime that walks the graph: pick a node, execute its handler, evaluate outgoing edges, advance. Treats every node the same — no special-cases for parallel or fan-in.
Node
A single step in the pipeline. Identified by ID; carries a handler (agent, tool, human, parallel, …) and attributes (prompt, model, command, …).
Edge
A directed connection between two nodes. Optionally guarded by a condition like when ctx.outcome = success. Labeled edges can carry a human-readable choice.
Run
One execution of a pipeline. Has a unique runID, an artifact directory, and a status. Resumable from a checkpoint.
Checkpoint
A snapshot of the engine’s state — completed nodes, context, edge selections — written after each node finishes. Used to resume a stopped run.
Dippin language
The text format pipelines are authored in.
Dippin
The pipeline language used by Tracker. Has its own parser, linter (dippin doctor), and simulator. Ships as a Go module: github.com/2389-research/dippin-lang.
.dip file
A Dippin source file declaring nodes, edges, and workflow-level defaults. Loaded by tracker run, tracker validate, and tracker simulate.
IR (Intermediate Representation)
The parsed in-memory form of a Dippin pipeline. Converted to Tracker’s Graph model by pipeline/dippin_adapter.go.
Workflow defaults
A defaults: block at the top of a .dip file that sets pipeline-wide values — default model, provider, budget ceilings — folded in as fallbacks beneath CLI flags and library config.
writes: / reads:
Declarative I/O contracts on agent, tool, and interview-human nodes. Lists the context keys a node produces (writes:) or expects (reads:). Extracted into first-class context keys at runtime.
Context
The shared key/value store every node reads from and writes to. Bare keys live at the top; per-node aliases (node.<nodeID>.<key>) appear after each node finishes.
Agents & backends
How LLM calls actually happen.
Agent
The LLM-driven actor that runs inside an agent node. Has a model, a prompt, and access to tools; produces a session result with token usage and final response.
Backend
The execution strategy for an agent node. Three are built in: Native, Claude Code, and ACP. Selected per-node via backend: or globally via --backend.
Native backend
Wraps agent.Session with a turn loop, tool registry, and context compaction. Calls the provider SDK directly (Anthropic / OpenAI / Gemini / OpenAI-compat).
Claude Code backend
Spawns the claude CLI as a subprocess and parses NDJSON output. API keys are stripped from the subprocess env so subscription auth works; override with TRACKER_PASS_API_KEYS=1.
ACP backend
Bridges to any Agent Client Protocol agent over stdio — claude-agent-acp, codex-acp, gemini --acp. Provider-based defaults; override per node via acp_agent.
Provider
The LLM vendor for a native-backend call: anthropic, openai, gemini, or openai-compat. Base URL resolved via tracker.ResolveProviderBaseURL(provider).
Node handlers
The set of behaviors a node can have. Selected by the handler: attribute.
Agent (codergen)
Runs an LLM session via the selected backend. Carries a prompt, model, optional tools, and an optional structured-output schema.
Tool
Runs a shell command. Stdout/stderr are captured (tail-windowed at 64KB by default) and surfaced as ctx.tool_stdout / ctx.tool_stderr.
Human gate
Pauses the pipeline for human input. Modes: default choice, yes/no, freeform, labeled freeform, and interview (multi-field form from JSON questions).
Parallel
Dispatches multiple branches concurrently from parallel_targets. Each branch runs in its own goroutine with panic recovery; emits per-branch start/complete events.
Fan-in
Joins parallel branches back into a single path. The parallel handler hints the engine at the join node via suggested_next_nodes.
Conditional
A no-op node whose only job is to route the run based on when… guards on its outgoing edges. Useful as an explicit branching point.
Subgraph
Embeds another .dip pipeline as a node. The child runs in isolation with its own context window; results merge back via declared writes:.
Manager loop
A controller node that repeatedly spawns a child agent with steerable context (steer.<key>) until a termination condition fires. Lives in the stack.manager_loop handler.
Routing & outcome
How the engine decides where to go next.
Node outcome
What a handler returns when its node finishes: success, fail, or retry. Drives routing — available on outgoing edges as ctx.outcome. Distinct from Run terminal status, which is what the engine carries on EngineResult.Status when the whole run ends.
Run terminal status
What EngineResult.Status carries when a run completes: success, validation_overridden, budget_exceeded, or fail. Open enum — future releases may add values. Use TerminalStatus.IsSuccess() (true for success and validation_overridden) or the status_class JSON companion field to classify, rather than switching on the raw string.
Conditional edge
An edge with a when… guard like when ctx.outcome = success. Evaluated against the context; unmatched conditional edges are skipped.
Strict failure edge
When a node’s outcome is fail and every outgoing edge is unconditional, the engine stops. Prevents tool nodes from silently masking errors.
Suggested next nodes
An optional hint a handler can set to redirect the engine past the normal edge-walk — used by the parallel handler to jump to the fan-in.
Escalation
A routing convention, not a distinct outcome: an edge guarded by ctx.outcome = fail that leads to an escalation gate (e.g. EscalateMilestone). Marking an escalation edge override: true doesn’t change the routing — it marks the audit signal so the run terminates as validation_overridden rather than success.
Override edge
An edge from a wait.human node marked override: true. Routing is unchanged — the run still flows to the chosen target — but a record is added to EngineResult.ValidationOverrides and the terminal status flips from success to validation_overridden. Used when a human, autopilot, or webhook accepts a result the automated checks flagged as failed.
Preferred label
The human-readable choice a human-gate node returned. Drives label-based edge selection when an edge specifies a target label.
Governance
Budgets, ceilings, and headless decision-making.
Budget
The set of ceilings a run will halt under: max tokens, max cost (cents), max wall-time. Configured via tracker.Config.Budget, CLI flags, or a defaults: block.
Cost ceiling
A dollar (or cents) cap. Enforced between nodes after each cost update; breach halts the run with outcome budget_exceeded and fires EventBudgetExceeded.
Autopilot
Replaces every human gate with an LLM-backed decision. Four personas: lax (forward progress), mid (balanced, default), hard (high bar), mentor (approve with feedback).
Auto-approve
Deterministic alternative to autopilot — always picks the default or first option at a gate. No LLM call.
Webhook gate
Headless alternative to autopilot: gates are POSTed to an external service and blocked on a callback. Enabled via --webhook-url.
Circuit breaker
A per-area attempt counter (e.g. fix_attempts on disk) that caps how many times a section of a pipeline can retry. Persists across run restarts.
Artifacts & inspection
Everything a run leaves behind, and the commands that read it.
Artifact
Any file written by a node during a run — agent transcripts, tool outputs, generated code. Lives in the run directory.
Run directory
The on-disk home for one run: <workDir>/.tracker/runs/<runID>/. Contains status.json, checkpoint.json, transcripts, and the git-artifacts repo if enabled.
Git artifacts
When WithGitArtifacts(true) is set, the run directory is initialized as a git repo and a commit is made after every terminal node — every run is replayable.
Bundle
A portable, self-contained git bundle of the run directory’s full history. Built by tracker.ExportBundle or --export-bundle; clone with git clone <bundle>.
Activity log
The append-only event stream for a run (activity.jsonl). Lives in a secured XDG state dir; a sentinel-stripped copy is written back to the run dir for bundle export.
tracker diagnose
Reads status.json + activity.jsonl for a failed run and surfaces tool output, stderr, errors, timing anomalies, and suggested fixes. Without an ID, analyzes the most recent run.