How It Works
The Tack pipeline from objective to PR.
The Pipeline
Tack takes an objective (a description of what you want built), plans how to break it into parallel work, executes each piece in isolation, checks quality, reviews the result, merges everything, and creates a PR.
What Is Deterministic vs Agentic
Each pipeline step is either deterministic or agentic:
- Deterministic steps are infrastructure: quality gates (lint, typecheck, tests), merge ordering, scheduling, file scope enforcement, timeout management. These behave the same way every time regardless of which LLM you use.
- Agentic steps involve LLM reasoning: planning (decomposing the objective), building (writing code), reviewing (evaluating quality). The blueprint YAML defines which steps are which.
The key insight: Tack's product surface is the deterministic harness around the agent, not the agent itself. The agent is replaceable. The harness is what makes the output reliable.
Agent Roles
| Role | What it does | When It Runs |
|---|---|---|
| Discovery | Explores the codebase, produces a cited context dossier | First, before planning — see Discovery & Dossiers |
| Planner | Consumes the dossier, decomposes the objective into parallel streams with file scopes and dependencies | After discovery |
| Scout | Optional pre-build investigation of specific files or patterns | Before builder, if the blueprint includes it |
| Builder | Implements the stream's task in an isolated sandbox, commits changes | After plan approval |
| Reviewer | Reviews the implementation for correctness and quality | After builder passes quality gates |
The merge processor is a deterministic step, not an agent. It integrates ready streams and runs post-merge checks. See Merge Queue.
Key Principles
Deterministic Infrastructure
Everything that is not an LLM decision is deterministic infrastructure you control: scheduling, quality gates, merge ordering, scoped rules, file scope enforcement, timeout management, and recovery policies. The harness is the product.
Isolation by Default
Each agent works in its own sandbox (a git worktree or remote VM). Agents never see each other's changes during execution. This prevents interference and makes merge the explicit integration point.
Human in the Loop
You approve the plan before execution begins. When agents hit blockers they cannot resolve, Tack pauses and sends you an escalation instead of silently failing or looping forever. You stay in control of what gets merged.
Partial Completion
When some streams fail, Tack merges the ones that succeeded and marks the objective partial. You do not lose successful work because one stream failed. You can retry failures or accept the partial result.
Self-Healing by Default
The default build-review workflow uses a self_healing retry profile. Quality gate failures and reviewer rejections automatically send the builder back with fix context. Only when the retry budget is exhausted does Tack block for human input.