Agents

Your agents work like your best engineers — observable.

Every agent runs on its own thread. Every state carries its author. The reasoning survives the session so the next agent picks up where the last one left off.

heddle agent ls — heddle/core-services

4 active · 1 ready to merge
Agent Thread Status States Elapsed
  • mochi claude-opus-4.7
    feature/auth-middleware writing tests for scope denial
    running
    7
    11m 04s
  • nori claude-sonnet-4.6
    chore/structured-logging refactoring log handler
    running
    4
    08m 22s
  • ume claude-opus-4.7
    fix/migration-0042 awaiting signature
    ready to merge
    12
    24m 58s
  • haku claude-haiku-4.5
    docs/agents-api-reference waiting for review feedback
    idle
    2
    02m 17s
Illustrative snapshot. Live telemetry ships with the hosted preview.

Isolated worktrees

One repo. Many agents. No lock contention.

Each worktree is a lightweight pointer into the shared object store. Any agent gets an independent working directory backed by the full history. Isolation is structural — not coordinated, not negotiated.

heddle start feature/auth --agent claude-opus-4.7

Attribution

Every action carries its author.

The agent registry records ID, provider, model, and status at spawn time. That metadata is structural — threaded into the object model from the first write. When work is merged, attribution from every agent is preserved.

You always know what each agent did, under which model, with what authorization. The record survives the merge.

state lm-a8f3c1d7
actor agent mochi
model claude-opus-4.7 · anthropic
confidence 0.94
signature ed25519:a8f3…c1d7

Multi-agent coordination

Parallel threads. Merged with attribution intact.

Each agent works on its own worktree with independent state. Snapshot isolation is structural — the worktree holds its own view, the shared object store keeps the record consistent.

Merge when the work is ready. Attribution from every agent is preserved through the merge. You always know who contributed which state.

Two agents, two threads, one merge. Attribution preserved per state.

Context annotations

The reasoning outlasts the work.

Constraints, invariants, and design rationale attach directly to the code they govern — scoped to a file, a symbol, or a line range. When the next agent opens the same function, the annotation is already there.

src/auth/enforce.rs fn authorize(token: &Token) lines 34–42
Constraint

Empty token scope must return `Deny::NoScope`. Never fall through to the role check — role resolution assumes a non-empty scope and will panic on the first index access.

lm-a8f3c1d7 enforces test_empty_scope_denial

Foundations for annotations ship today in the object model; the editing surfaces are on the roadmap. Clearly labeled throughout.

A codebase that remembers

Every decision recorded. Always at the right scope.

Constraints and rationale live beside the code they govern — not in a wiki that falls behind, not in a channel that scrolls away. Scoped to the file, the symbol, or the line. Carried forward on every snapshot. When something is about to change, the context is already there.