Each agent round is completely isolated. Fresh context. Fresh process. No memory of the previous round.

HLTM is a personal automation layer running AI agents autonomously. A bash loop — hltm-loop.sh — spawns agents with fresh context every round. The goal: drop a brief, come back to working code.

So how does one round know what the previous round did?

It reads from beads — a SQLite-backed task tracker.

The Interface

br ready --limit 1    # pick one task
br show <id>          # read full task details
br update <id> --status=in_progress
# ... do work ...
br comments add <id> "completed X, Y, Z"
br close <id>         # done

The loop controls beads between rounds. The agent just reads and writes tasks.

No agent ever sees another agent’s context. No handoff conversation. No shared memory. The ledger is the only shared state.

One Task. No Negotiation.

br ready --limit 1 gives the agent exactly one task.

Not a list to choose from. Not a backlog to prioritize. One task.

Decision paralysis is a real failure mode for agents. Give an agent five ready tasks and it will spend tokens reasoning about which one to pick. Sometimes it picks the wrong one. Sometimes it picks two and does both badly.

One task. Do it. Emit the signal. Stop.

Comments as Handoff

The developer agent writes comments when it closes a task. What it did. What it changed. What it wasn’t sure about.

The reviewer agent reads those comments as context. No memory required. The comments are the handoff.

If the reviewer finds a problem, it writes a comment explaining what failed. The task goes back to develop with that comment attached. The next developer agent reads it and knows exactly what the reviewer rejected.

Labels drive routing: review-passed, review-failed, blocked. The bash loop reads the label and decides the next stage. Not the agents. The loop.

The Evolution

Started with a dolt SQL server. A full version-controlled SQL database, because the original design wanted git history on every task change.

Overkill. The infrastructure was heavier than the actual work being tracked.

Switched to a YAML file. Human-readable. Simple. Broke constantly. Concurrent writes from the loop and the agent corrupted it. YAML has no transactions.

Settled on beads. A single SQLite file. CLI interface. Zero infrastructure. SQLite handles concurrent writes. The CLI keeps it scriptable.

The file lives in the project at .beads/. Git-trackable. Grep-able. br list shows the full backlog in the terminal. No dashboard. No server. No dependencies.

The Whole Loop

bash reads beads → spawns agent with prompt + task
agent reads beads → does work → writes beads → emits signal
bash reads signal → updates beads → spawns next agent

That’s the entire system.

No agent ever talks to another agent. No message passing. No shared process. No coordination protocol beyond the ledger.

An agent that crashes doesn’t take anything with it. The task is still in beads. The next round picks it up. The comments tell it what happened.

The ledger keeps score. The agents just play the round in front of them.

---

This concludes the Building HLTM series.

• #ai-agents
• #hltm
• #beads
• #sqlite