HEDDLE.
Enter HEDDLE
writing
the record
HEDDLE.

The versioned memory layer your agents always needed. What one agent learns, the next one remembers.

Lukehuman Mochiagent Atlasagent Juniperagent
Git
compatible
One thread
per task
Reversible
history
Annotations as
versioned memory
the unit

The unit is the task,
not the commit.

One agent task is a run of captures, the retries between them, the attempt it abandoned, a conflict someone had to resolve, and one signed merge at the end. Git records the result. Heddle keeps the whole run as a single named thread — attributed, reviewable, undoable.

feature/auth Reconnect the sync stream without dropping the session in review 1 open discussionactive 2m ago
statehc-5aqcfrwvcs7d
agentanthropic/claude-opus-5-5
saved byLuke <luke@heddle.sh>
3 captures 2 retries 1 abort 1 conflict 1 signed merge, once reviewed
open-source cli · public alpha

Version control
for agent work.

When agents write the code, the unit of work stops being the commit. Heddle records each task as one isolated thread, makes your whole history undoable, and writes straight through to the Git repo you already have. No lock-in.

Install CLI >_ Star on GitHub
~/heddle · status
$ heddle status
Heddle status for main
Repository: Git + Heddle
Verification: 1 Git worktree path(s) have uncommitted changes

Thread: main
Verdict: work in progress
  checkout health needs attention
Saved change: hc-9h82p53w3s51
Change message: docs: add 0.5.0 changelog entry (#786)

Worktree
Checkout: Git branch checkout
Lifecycle: active

Changed paths: 1
Work in progress
  - Worktree: 1 Git worktree path(s) have uncommitted changes

Next
  command: heddle capture -m "..."
  why: there are uncommitted worktree changes; capture saves them and writes the matching Git checkpoint
  then: run `heddle push` when the Git commit is ready to publish
the core loop

Git records what changed. Heddle records who, why, and what failed.

Every pass records who acted (signed attribution), why (an annotation the next agent reads before it edits), and what failed (a wrong approach turned into a guardrail). Each task runs on its own isolated thread, so parallel agents never collide.

HEDDLE.
01status
~/work/api · core loop
$ heddle init
Initialized Heddle data in .heddle for Git-overlay workflows
Side effects:
  - created Heddle sidecar for the existing Git repository
  - updated .git/info/exclude for Heddle metadata
  - left Git-tracked files untouched
$ heddle status
Heddle status
Repository: Git + Heddle
Verification: clean
Thread: main (in sync with Git)
Next: open an isolated thread with heddle start <name>
$ heddle start feature/auth
Started isolated thread feature/auth
  (Heddle-managed checkout, no .git directory)
$ heddle capture -m 'wire reconnect into sync loop'
Captured hc-5aqcfrwvcs7d as Git commit 711ec9de
Saved by: Luke <luke@heddle.sh>
Agent: anthropic/claude-opus-5-5
Included: crates/grpc_hosted/src/sync.rs
Verification: clean
$ heddle context set --kind invariant
--kind invariant --scope symbol:reconnect -m "…"
Annotated …/grpc_hosted/sync.rs (1 active annotation)
  stored in .heddle/ · injected on PreToolUse
$ heddle land --thread feature/auth
Landing thread feature/auth → main
$
01 · init

Set up beside Git.

heddle init writes a .heddle/ sidecar next to .git/. It never rewrites history and never touches your tracked files. Git commits stay in Git; walk away byte-identical whenever you want.

additive · your Git history stays untouched
created.heddle/ sidecar
git historyuntouched
tracked filesuntouched
02 · status

See where you stand.

heddle status is observe-only. It reads your repo and recommends the next step. Nothing is written, nothing uploaded, history untouched.

read-only · safe to run anytime
.heddle/≈.git/
heddle start≈git worktree
heddle land≈git merge
heddle status≈git status
03 · start

Branch an isolated thread.

heddle start spins up a copy-on-write, Heddle-managed checkout, one per task or agent. Point a model at it and it never collides with main or another thread.

copy-on-write · no full clone

atlas · Threads

  • feature/auth Reconnect the sync stream without dropping the session in review 1 open discussionactive 2m ago
  • main landing targets active 1h ago
  • refactor/db Move the session store onto Postgres drafts active 3h ago
04 · capture

Every capture names who made it.

heddle capture saves a checkpoint named for whoever made it, person or agent, and the model they used. It writes straight through to your .git as a real Git commit, so plain git log shows it. On the thread, each capture is a stop with its checks and reviews.

who, which model, what passed

atlas · feature/auth

  1. Base9c41e2a0

    Nothing recorded on this revision

  2. Earlier revision3f2b9e10

    Luke · anthropic claude-opus-5-5 pushed 2 filesHold the session lock on reconnect

    • cargo test passed
    • mara approvedon an earlier revision; doesn't carry to the headLock order matches the session store's.

  3. Head711ec9de

    Luke · anthropic claude-opus-5-5 pushed 1 filewire reconnect into sync loop

    • cargo test passed
    • clippy passed

    To land here

    • An approval on the head: mara's was on the revision before it
05 · annotate

The next agent reads it before it edits.

Annotations are versioned objects (constraint, invariant, rationale) attached to a symbol and injected into the agent's context before it edits. Failed attempts become future guardrails.

injected into Claude Code on PreToolUse

atlas · Context

claude-opus-5-5 agent on reconnect in crates/grpc_hosted/src/sync.rs:88–121 at 711ec9de

Reconnect must hold the session lock; racing reconnects corrupt the stream cursor.

invariant

06 · land

Review by symbol, then land.

Before a thread merges, its change map shows every symbol it touched: logic, added, removed or cosmetic, with open discussions and notes marked, and whose reads cover it. Then it lands back to main.

by symbol, not by line

atlas · feature/auth · Changes

Show reads by

Point at a tile for details.

logicaddedremovedcosmetic◌ blocking◌ discussion▲ note✓ read

why it compounds

Isolated threads.
Memory bound to the code.

Two ideas do the heavy lifting. Every task runs in its own copy-on-write thread, and what each agent learns gets written into the code so the next one inherits it.

copy-on-write threads

Every task gets its own checkout.

heddle start spins up an isolated, Heddle-managed checkout: copy-on-write, no full clone, no .git of its own. Point one agent at feature/auth and another at refactor/db and they never touch the same files or stack onto each other's half-finished work. Parallel agents stop colliding, and any thread can be thrown away without a trace.

heddle start feature/auth
$ heddle start feature/auth
Started isolated thread feature/auth
  (Heddle-managed checkout, no .git directory)

$ heddle thread list
Current
* main           current
Other threads
- feature/auth   ● isolated checkout
- refactor/db    ● isolated checkout
embedded annotations

What one agent learns, the next one reads.

An annotation is a versioned note (invariant, constraint, rationale) pinned to a symbol or line and injected into the agent's context before it edits. For you: the reasoning behind a gnarly function stops living in one person's head. For the agent: last week's failed approach becomes this week's guardrail instead of a repeated mistake. And heddle context check tells you the moment an annotation goes stale because the code moved out from under it.

atlas · Context

Luke on require_minting_keypair in crates/auth/src/keys.rs:33–60 at e81a6c3b

Production startup must call require_minting_keypair. configured_minting_keypair returns None for verifier-only deploys, so a deploy that picks it looks healthy and accepts tokens it can't sign.

constraintstartup

mara on crates/auth/src/verifier.rs

Verification stays offline: a Biscuit carries its own proof, so the verifier never calls home on the hot path.

rationale

Version control
for agent work.
View on GitHub Read the quickstart macOS & Linux · release binaries

Early access

Reserve your handle.

Hosted Heddle is invite-only. Claim the handle you want, confirm your email, and we will hold it for you. We select users for access on a rolling basis.

heddle.sh/

No card required. We will email you when your spot opens.

Already have an invite? Redeem it