Product

Every primitive that holds the task together.

Agent work needs a task-native record, not a commit-shaped one. Run Heddle inside the Git repo you already use — these primitives compose into one coherent task. Threads as named tasks. Annotations attached to symbols. Attribution at the object model. Stable identity across rewrites.

Get started See agents converge

Task threads

Many agents. One repo. No silent rewrites.

A thread is a named pointer into the DAG. Opening one creates an isolated worktree, sharing the main repository's object store. Many threads, zero extra disk. No coordination, no merge dance before the work is ready.

Threads track lineage structurally. A rebase, a collapse, or a merge produces a new state without overwriting the original — so another agent that forked earlier on the same thread keeps its view intact.

Most threads stay lightweight: a named pointer plus a lazy worktree that materializes only the files an agent reads. When a thread needs the full filesystem to operate freely — running tests, dropping scratch files, building artifacts — promote it to a heavy worktree with heddle thread promote. You only pay disk for the threads that actually need it.

bash$ heddle start task/biscuit-authz --task "require minting keypair at boot"thread started · worktree: .heddle/threads/biscuit-authz$ heddle start task/biscuit-callersthread started · worktree: .heddle/threads/biscuit-callers# threads keep intent — every fork stays addressable as the work moves.

Context annotations

Annotations that survive the refactor.

Constraints, rationale, and design intent belong next to the code they govern — not in a wiki, not in a Slack thread, not in the session transcript of an agent that has already expired.

Annotations are structural. Each one is scoped to a file, a symbol, or a line range, and carried forward on every snapshot that touches its anchor. When the next agent opens the same function, it sees the reasoning before it starts editing.

Attribution

You always know who acted. Human or AI.

Attribution is a first-class field on every state — provider, model, confidence, signature. Never parsed from a commit message. Never inferred from a Git email. Recorded when the action ran.

When an auditor — a CTO, a staff engineer, or a compliance tool — asks who touched this code, Heddle returns a structural answer, not a best-guess string.

History model

Nothing disappears. Every object permanent.

States are content-addressed with BLAKE3. IDs are stable across clones, forks, and time. Rebase and collapse create new objects; the originals survive, reachable from whatever reference held them.

The kind of history you can point to a year from now — not because you remember, but because the record is structural.

Governance

Policy at the namespace. Legible at every level.

Namespace grants cascade. Repository grants scope precisely. When access fails, you see which layer said no — token scope, namespace policy, or repo grant — not an opaque 403.

Effective permission is always explicit. You never guess what a token can do; you read it.