Holistic Attuned Layered Orchestration. The full envelope you put around a brand so that everything you produce is dictated, by construction, by the brand's own DNA.
HALO is three concentric layers:
HALO the whole envelope around the brand
+--------------------------------------+
| EXEC layer how you build it |
| +-------------------------------+ |
| | TRIAD what you're build| |
| | +------------------------+ | |
| | | GENOME who they are *| | | <- identity core
| | +------------------------+ | |
| +-------------------------------+ |
+--------------------------------------+
- GENOME (core) -- who the brand is. The DNA that dictates every asset.
- TRIAD (middle) -- what you're building. Three source-of-truth documents that produce six computed views.
- EXEC (outer) -- how you build it. The gap between vision and reality, materialized as agent-executable work and self-driving loops.
Each letter of HALO is a layer or its engine: Holistic (the whole envelope), Attuned (to the Genome), Layered (the concentric stack), Orchestration (the loop chain that runs it). Name the brand once at the core, and everything downstream conforms.
Full doctrine: docs/halo.md.
A workflow that produces brand assets without a Genome corrects every asset toward the brand after the fact. With a Genome, assets come out on-brand by construction. The Genome is a small canonical file set that the production layer reads. Three genes, mirroring the Triad's three documents:
| File | Gene | Dictates |
|---|---|---|
DESIGN.md |
how it looks | color, type, spacing, components, motion |
VOICE.md |
how it sounds | tone, lexicon, do/not words, register, language rules |
ETHOS.md |
who they are | positioning, values, who they serve, what they would never say |
Plus the machine and provenance layer:
genome.json-- the genes as parseable data (hex values, rule lists, a held-out eval set) so agents can enforce them programmatically.EVIDENCE/-- the canonical corpus the genes were derived from (site, decks, transcripts). The ground truth.AGENT.md-- the enforcement contract: "you are producing for this brand; obey the Genome; here is how to check conformance."
The Genome is client-scoped: one Genome spans every engagement you ever run for that brand, while the Triad below it is per-engagement. Templates are in templates/genome/.
A documentation system that replaces your dead PRD. Three source-of-truth documents, three temporal perspectives.
VISION.md
(FUTURE)
/ \
/ \
/ THE \
/ WORK \
/ \
SPEC.md -------- BUILDING.md
(PRESENT) (PAST)
VISION.md -- Where the product is going. Soul, pillars, anti-vision, edges. SPEC.md -- What the product is right now. Testable contract with drift detection. BUILDING.md -- How it got here. The build journal.
The gap between VISION and SPEC is the roadmap. You don't maintain a roadmap. You don't maintain a changelog. You don't maintain an onboarding guide. The triangle produces them.
The three documents are a normalized data store. Six commands compute views over them:
| Command | What It Produces | Inputs |
|---|---|---|
/roadmap |
Prioritized build order | VISION + SPEC + BUILDING |
/drift |
Are we building toward the vision or wandering? | VISION + BUILDING |
/changelog |
What shipped recently, classified by type | BUILDING + SPEC |
/pitch |
Investor/user-facing narrative | VISION + SPEC |
/debt |
Technical and product debt | SPEC + VISION + BUILDING |
/onboard |
New contributor orientation | BUILDING + SPEC |
Every output is computed fresh. When the source documents change, every derived view updates automatically. This is the same principle as database views vs. tables -- store facts once, derive everything else.
The three documents dictate priority order, not a human maintaining a list:
- Dependency depth (from VISION) -- Does this pillar unblock others? Foundational items first.
- Momentum (from BUILDING) -- Recent entries pointing at this item? Active energy = higher priority.
- Distance from done (from SPEC) -- Partial items closer to completion are cheaper to finish.
- Recency (from BUILDING) -- Stale items with no mention in 30+ days deprioritize.
Maps every recent BUILDING entry to VISION pillars:
- Entries that don't map to any pillar = scope creep candidates
- Pillars with zero BUILDING momentum = neglected priorities
- Entries that contradict the Anti-Vision = drift warnings
The derivation engine computes ephemeral views. The execution layer materializes one of those views -- the roadmap -- into persistent, agent-executable documents.
TRIAD (what is this?) EXECUTION (what do we do about it?)
VISION.md ROADMAP.md
SPEC.md --> MILESTONE_TASKLISTS.md
BUILDING.md TICKETS.md
MILESTONE_N_CHECKLIST.md
Four documents, four zoom levels:
| Doc | Role | Audience |
|---|---|---|
ROADMAP.md |
Strategy, sequencing, gates, planning principles | Humans and agents |
MILESTONE_TASKLISTS.md |
Tactical task lists per milestone with verification criteria | Humans and agents |
TICKETS.md |
Agent-executable work units with status, priority, dependencies, file targets | Agents (primary), humans |
MILESTONE_N_CHECKLIST.md |
Deep-dive for the current milestone with file-level targets | Agents |
An agent session opens TICKETS.md, reads the status of every ticket, finds the highest-priority unblocked ticket, marks it in_progress, does the work, verifies it, marks it done, and updates affected docs. No human intervention required for routine execution.
When you want to orchestrate the build instead of prompting it task by task, the execution layer runs as a chain of six self-driving loops. Each loop is self-feeding (pulls its next unit from a queue file, never from you typing) and self-verifying (re-derives its own claim from fresh ground truth). When both hold, the only input a loop cannot generate for itself is a judgment call that is genuinely yours.
| Loop | Does | Exits to |
|---|---|---|
| Build | implements the next ready ticket, one commit each | Verify |
| Verify | re-derives the claim from ground truth; failures become fix-tickets | Build / next |
| Review | code-review + simplify on the milestone diff | Taste |
| Taste | judges rendered output against the Genome; auto-applies polish | your gate |
| Reconcile | syncs the Triad + status + journal to what the code now is | exit gate |
| Gate-Watch | watches for a human gate to clear, then arms the chain | you |
You sit at three gates per milestone: Entry (a gate cleared), Taste (an identity-level call), Exit (ship). A milestone can run start to finish on three one-word replies. The protocol that governs a single loop is in templates/orchestration.md; the chain is in templates/loop-chain.md.
/reconcile maintains the triangle through conversation. Five modes:
| Mode | When | What Happens |
|---|---|---|
/reconcile init |
New project | Soul interview + codebase scan |
/reconcile spec |
Something shipped | Scan code, update contract |
/reconcile vision |
Learned something new | Conversational interview, update north star |
/reconcile scan |
Things feel off | Drift report, no edits |
/reconcile |
Full checkup | All of the above |
The reconcile skill is conversational. It asks questions, listens, and writes the docs. No brackets to fill in.
HALO maintains itself through integration with your existing workflow:
| Trigger | What Happens |
|---|---|
Session start (/morning) |
Lightweight drift check -- flags stale SPEC, asks one question |
Pre-ship (/ship) |
Scans diff for new capabilities not in SPEC, asks to add them |
| Post-gate (pipeline) | Checks if pillar status should change after gate pass |
| Significant commit | Silently notes new routes/pages/migrations, prompts at next breakpoint |
All automation uses structured questions (AskUserQuestion) with a skip option. The system never interrupts flow -- it prompts at natural breakpoints.
Full spec: skills/triad-derive/AUTOMATION.md
git clone https://github.com/eddiebelaval/halo.git
cd halo
chmod +x install.sh
./install.shThis copies templates, commands, and skills to your ~/.claude/ directory.
# Just the Genome templates
cp -r halo/templates/genome your-project-root/
# Just the Triad templates
cp halo/templates/vision.md halo/templates/spec.md halo/templates/building.md your-project-root/
# Just the slash commands
cp halo/commands/*.md ~/.claude/commands/- Genome. Name the brand. Fill
DESIGN.md,VOICE.md,ETHOS.mdfromtemplates/genome/. This is the DNA every asset conforms to. - Triad. Create
VISION.md(why this exists, the pillars),SPEC.md(what it does today, testable),BUILDING.md(how it got here). The gap between them is your roadmap. - Exec. When agents need to build autonomously, materialize
ROADMAP.md,TICKETS.md, and the loop chain fromtemplates/.
halo/
docs/
halo.md # HALO doctrine -- the full concept
templates/
genome/
design.md # DESIGN.md -- how the brand looks
voice.md # VOICE.md -- how the brand sounds
ethos.md # ETHOS.md -- who the brand is
genome.json # machine layer (hex, rules, eval set)
agent.md # AGENT.md -- enforcement contract
vision.md # VISION.md -- north star template
spec.md # SPEC.md -- living specification template
building.md # BUILDING.md -- build journal template
roadmap.md # ROADMAP.md -- execution roadmap template
milestone-tasklists.md # MILESTONE_TASKLISTS.md -- tactical task lists
tickets.md # TICKETS.md -- agent execution board
milestone-checklist.md # MILESTONE_N_CHECKLIST.md -- current milestone deep-dive
orchestration.md # single-loop protocol (gates + ground-truth checks)
loop-chain.md # the six-loop autonomous chain
commands/
reconcile.md # /reconcile -- maintain the triangle
roadmap.md # /roadmap -- prioritized build order
drift.md # /drift -- trajectory analysis
changelog.md # /changelog -- what shipped recently
pitch.md # /pitch -- narrative from vision + proof
debt.md # /debt -- tech + product debt scan
onboard.md # /onboard -- new contributor guide
morning.md # /morning -- daily brief with triangle health
skills/
reconcile/ # Full reconciliation skill (5 modes)
triad-derive/ # Derivation engine (6 computed views) + automation
install.sh # Installer script
Every product team has the same dirty secret: the PRD died on day three. You wrote it before you started building, then you started building and learned things, and now the PRD describes a product that doesn't exist.
The Triad fixes that structurally. Three documents, three temporal perspectives. Each stays in its lane. The power is in the gaps:
- VISION - SPEC = what to build next (the roadmap)
- SPEC - BUILDING = what shipped but wasn't documented
- BUILDING -> VISION = are we converging on the vision or drifting?
Two documents give you a line. Three give you a plane. You can triangulate your position. Any two documents reconstruct the third.
HALO is the generalization. The Triad tells you what you are building and whether it is on course. The Genome above it tells you who it is for, so every asset is on-brand by construction. The Exec layer below it turns the whole thing into work an agent can run. Name the brand once at the core; the rest conforms.
Built by Eddie Belaval at id8Labs while shipping AI-augmented products with Claude Code. The three-document Triad was developed on Parallax, an AI companion for conflict resolution. The derivation engine was added after realizing the three documents could produce every planning artifact a team needs without maintaining any of them separately. The Genome layer and the HALO framing were added while running client engagements, when it became clear the same brand DNA had to govern every asset across every engagement.
Part of the Squire ecosystem.
MIT