Multi-Agent Pipeline Orchestration on Tracker

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

Architecture

Three layers, clean boundaries. The engine doesn’t know about parallel execution. The LLM client doesn’t know about pipelines.

System layers

Each box: layer name · source path · what it owns.

graph TB CLI["CLI
cmd/tracker
flags · name resolution · TUI · embedded workflows"] Engine["Pipeline Engine
pipeline/
run loop · edge selection · checkpoints · budget guard · steering channel"] Handlers["Handlers
pipeline/handlers
codergen · tool · human · parallel · fan_in · conditional · subgraph · manager_loop"] Backends["Agent Backends
pipeline/backend.go
native · claude-code · acp"] Agent["Agent Session
agent/
turn loop · tool registry · context compaction · episodic memory · verify-after-edit"] LLM["LLM Client
llm/
Anthropic · OpenAI · Gemini · OpenAI-compat · retry · cost estimation"] CLI --> Engine --> Handlers --> Backends --> Agent --> LLM

The engine run loop

Every node is treated the same: execute the handler, evaluate edges, advance. Parallel, subgraphs, human gates — handlers encapsulate it all.

Built-in Workflows

Mon, 01 Jan 0001 00:00:00 +0000

Built-in Workflows

Four pipelines embedded in the binary. Run by name; customize with tracker init.

All four embedded workflows are coding-flavored — they shipped with the binary because they were the original use case. The pipeline framework itself is general: any sequence of LLM calls plus parallel branches plus human gates fits the same .dip shape. RAG, eval, content moderation, agent triage are all doable; we just haven’t shipped opinionated templates for them yet. Pull requests welcome.

Changelog

Mon, 01 Jan 0001 00:00:00 +0000

Changelog

Every feature, fix, and breaking change. All GitHub Releases →

v0.45.0

2026-07-14 release notes →

Escape-aware condition parsing, reconciled with dippin v0.49. dippin-lang bumped v0.48.0 → v0.49.0; no breaking changes; core embedded workflows hold their A grades on dippin doctor.

Changed

Condition parsing is now escape-aware (#444 reconciliation, #470). Logical splitting (||/&&) and comparison-operator discovery (=/==/!= and the word operators) both ignore content inside double quotes; exactly one surrounding quote pair is stripped from every RHS and \"/\\ are decoded inside it. An unmatched double quote is now a loud error — carrying the original expression and, at load, the .dip source location — instead of a silent mis-parse. Semantic validation applies the same quote-aware grammar to every logical branch independently.
dippin-lang bumped v0.48.0 → v0.49.0. The library dep, the CI dippin CLI, and tracker_doctor.go's pinned version move together.
tracker-swebench main() decomposed (#469). The 200-line entrypoint (cyclomatic 44 / cognitive 74) was split into behavior-preserving helpers under the complexity-8 gate; each container is now bounded to 1 CPU and the prompt temp file is co-located under the run's results dir.
Added a rolling ROADMAP.md (Now/Next/Later) and a matching website Roadmap page; corrected inaccurate CLI/workflow examples on the site.

v0.44.0

2026-07-13 release notes →

Engine-correctness hardening and a real, CI-enforced complexity gate. dippin-lang bumped v0.43.0 → v0.48.0; no breaking changes; core embedded workflows hold their A grades on dippin doctor.

CLI Reference

Mon, 01 Jan 0001 00:00:00 +0000

CLI Reference

Every command, flag, and resolution rule. Install and operate tracker from the terminal.

Install

# Go install (binary includes embedded workflows)
go install github.com/2389-research/tracker/cmd/tracker@latest

# Homebrew
brew install 2389-research/tap/tracker

# Or build from source
git clone https://github.com/2389-research/tracker
cd tracker && make install

# Verify installation
tracker doctor

# Stay current (checks automatically, or run manually)
tracker update

Commands

Running Pipelines

tracker <pipeline>

Run a pipeline. Accepts a file path (build_product.dip, build.dipx), bare name (build_product), or path with slash. .dipx bundles are SHA-256-verified at load time and the bundle identity is threaded through every audit surface. .dipx v0.26.0 Opens TUI dashboard by default.

tracker -r <id> <pipeline>

Resume a previous run by ID. Prefix matching works — -r 7813b is enough if unambiguous.

tracker --no-tui <pipeline>

Run in console mode (no dashboard). Human gates use inline prompts. Auto-selected when stdin is not a TTY.

tracker --json <pipeline>

Stream events as newline-delimited JSON to stdout. Implies --no-tui. For CI/programmatic consumption.

Workflow Management

tracker workflows

List all embedded built-in workflows with display names and goals.

tracker init <name>

Copy a built-in workflow to ./name.dip in the current directory. Refuses to overwrite existing files.

Validation & Simulation

tracker validate <pipeline>

Check pipeline structure — parsing, structural validation, semantic validation, lint. Exits 1 on errors. Supports bare names. Accepts .dip, .dot, and .dipx bundles. .dipx v0.26.0

tracker simulate <pipeline>

Dry-run execution plan. Shows nodes, edges, BFS traversal, unreachable nodes, and graph-level attrs (sorted, deterministic). No LLM calls. Supports bare names. Accepts .dip, .dot, and .dipx bundles. .dipx v0.26.0

tracker estimate <pipeline>

Rough pre-run cost & scale ballpark v0.46.0 — prices each agent node's model against a turn heuristic and reports steps, agent-node count, distinct models, and a Low–High cost range with an expected value (e.g. build_product → $0.65–$10.02, expected ~$3.56). No LLM calls; supports bare names. A deliberately wide range — actual cost depends on how many turns each agent uses and how many times loops run.

Headless & Integration

tracker --webhook-url <url> <pipeline>

Fully headless. Every human gate is POSTed as JSON to <url>; the pipeline blocks until a callback arrives at the local callback server. Slack bots, email approval, mobile push. Mutually exclusive with --autopilot and --auto-approve. v0.17.0

tracker --param key=value <pipeline>

Override a workflow's top-level vars (available as ${params.key}). Repeatable. Unknown keys hard-fail at startup. v0.19.0

tracker --export-bundle <path> <pipeline>

After the pipeline completes, package the full artifact run directory as a portable git bundle (git bundle create --all). Clone with git clone <bundle> on any machine to inspect every commit and checkpoint tag. v0.17.0

tracker --gateway-url <url> <pipeline>

Route every provider through a Cloudflare AI Gateway. Tracker appends the per-provider suffix (/anthropic, /openai, /google-ai-studio, /compat). Equivalent to TRACKER_GATEWAY_URL. Per-provider *_BASE_URL env vars still win. v0.17.0

Autopilot

tracker --autopilot <persona> <pipeline>

Replace all human gates with LLM-backed decisions. Personas: lax, mid (default), hard, mentor.

tracker --auto-approve <pipeline>

Deterministic auto-approval of all human gates. No LLM calls — always picks the default or first option. For CI and testing.

Diagnostics

tracker doctor [pipeline]

Preflight health check. Per-provider API key validation (masked), dippin binary version, .ai/ writability, disk space, .gitignore hygiene, dangerous env var warnings. Live per-provider auth validation with a 1-token call runs by default; pass --probe=false to skip it. Optional pipeline arg runs full lint. Exit code 2 on warnings-only. v0.17.0

tracker diagnose [runID]

Deep failure analysis. Reads status.json + activity.jsonl. Shows tool output, stderr, errors, timing anomalies, actionable suggestions (deterministic failure pattern, escalation hit, suspicious timing, budget halt). Without ID, analyzes the most recent run.

tracker audit <runID>

Full audit report: timeline, retries, errors, recommendations. For post-hoc analysis of any run.

tracker list

List recent pipeline runs with timestamps, status, and node count.

Setup

tracker setup

Interactive provider configuration wizard. Saves keys to ~/.config/tracker/.env.

tracker version

Show version, commit hash, build time, and configured providers.

tracker update

Self-update to latest release. Downloads from GitHub, verifies SHA256 checksum, smoke-tests the binary, and atomically replaces with .bak rollback. Detects Homebrew and go install and advises accordingly.

Flags

Flags can appear before or after the pipeline argument.

Glossary

Mon, 01 Jan 0001 00:00:00 +0000

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.

Roadmap

Mon, 01 Jan 0001 00:00:00 +0000

Roadmap

A rolling engineering roadmap in thematic workstreams across Now / Next / Later. Priorities, not dates.

The GitHub milestones mirror the Now tier and are the source of truth for what's actively in flight; everything below Now is directional and will churn. Canonical copy lives in ROADMAP.md.

Now

The three active milestones — what we're building next.

Engine correctness

The engine must route and terminate exactly as authored — no silent mis-routes, no phantom "Done" on an unresolved gate.

Slack Bot

Mon, 01 Jan 0001 00:00:00 +0000

Slack Bot v0.46.0

Drive Tracker from Slack. Mention @trackerbot make me an app that… and it starts a pipeline in a thread, streams notifications and clarifying questions to that thread, and delivers the result — arbitrarily many runs at once, each isolated. This page takes you from zero to your first run.

Transports

Mon, 01 Jan 0001 00:00:00 +0000

Transports

A transport is a front-end that drives runs and relays them to a human. The terminal TUI, the Slack bot, a future web or mobile app — every one is a first-class peer on the same small library boundary. None is privileged.

The boundary

The core engine knows nothing about LLMs, subprocesses, terminals, or Slack. A front-end plugs in through a small, deliberate library surface — tracker.Config → Engine, an Interviewer seam for human gates, the event streams, and RunManager for concurrency. What the library can do and what the product can do are the same set.