Haft — Summary

Haft is a Go-compiled CLI and MCP server that enforces structured engineering reasoning before and during AI-agent code execution. It implements First Principles Framing (FPF) as an engineering discipline: agents must frame problems, compare options under parity, record decisions as falsifiable contracts, and track when evidence goes stale before committing to implementation. The framework provides 7 MCP tools (haft_note, haft_problem, haft_solution, haft_decision, haft_commission, haft_refresh, haft_query), 13 slash commands (h-frame, h-char, h-explore, h-compare, h-decide, h-onboard, etc.), a spec-check CLI, and a WorkCommission lifecycle for bounding agent execution. It supports Claude Code and Codex as primary targets with experimental support for Cursor, Gemini CLI, OpenCode, and JetBrains Air. Haft also ships a Bubbletea TUI and an alpha Tauri desktop app. Compared to seeds: Haft is closest to taskmaster-ai in that both provide structured reasoning scaffolds and MCP tool interfaces, but Haft's emphasis on decision contracts with evidence decay, parity enforcement, and formal spec sections as a pre-execution governance layer has no analog in any seed framework.

Haft — Overview

Origin

Repo: m0n0x41d/haft (formerly quint-code). Created December 2025, Go, non-standard license. 1,333 stars, 104 forks. Author: m0n0x41d. Website: quint.codes. Languages: Go (primary), with Bubbletea TUI, Tauri desktop, SQLite.

Philosophy

From README:

"True harness engineering for AI-assisted software delivery."

"Haft is the engineering governor that sits between your intentions and your agents' execution. It enforces the discipline that separates 'we shipped fast' from 'we shipped right': frame the problem before solving it, compare options under parity, record decisions as falsifiable contracts, and know the moment assumptions go stale."

"The handle between the tool and the hand — the part that turns raw capability into formal specification, governed decisions, bounded commissions, and evidence-backed engineering work."

"Not a coding agent. Not a generic documentation tool."

Core workflow: Specify → Think → Run → Govern.

First Principles Framing (FPF)

FPF is Haft's proprietary reasoning discipline. Key concepts:

• Problems must be framed with dimensions before solutions are explored
• Solutions require diversity checks (no premature convergence)
• Comparisons must be done under parity (same criteria for all options)
• Decisions are recorded as falsifiable contracts with invariants, claims, evidence
• Evidence decay: decision contracts automatically track staleness of their assumptions
• WorkCommissions: bounded execution units with allowed actions and evidence requirements

CLAUDE.md Philosophy

Haft's own CLAUDE.md reflects its communication style:

"Be a peer engineer, not a cheerleader: Skip validation theater ('you're absolutely right', 'excellent point')." "Talk like you're pairing with a staff engineer, not pitching to a VP." "No. | That's an interesting approach, however..." (USE vs AVOID table)

Haft — Architecture

Distribution

• Go binary (haft) — single compiled binary
• Install: curl -fsSL https://raw.githubusercontent.com/m0n0x41d/haft/main/install.sh | bash
• Binary installs to PATH as haft

Init Per Tool

haft init           # Claude Code (global commands in ~/.claude/commands/)
haft init --local   # Claude Code (local .claude/commands/)
haft init --codex   # Codex CLI + Codex App
haft init --all     # Claude Code + Codex
haft init --cursor  # Experimental Cursor
haft init --gemini  # Experimental Gemini CLI
haft init --opencode # Experimental OpenCode
haft init --air     # Experimental JetBrains Air

Directory Structure (per project after init)

.haft/                   # Project knowledge base (created by init)
  decisions/             # Decision contracts
  evidence/              # Evidence records
  knowledge/             # Domain knowledge
.mcp.json                # Claude Code MCP config (haft serve)
.codex/config.toml       # Codex MCP config

Global Installs (Claude Code)

~/.claude/commands/      # h-frame, h-char, h-explore, h-compare, h-decide,
                         # h-commission, h-note, h-onboard, h-problems,
                         # h-search, h-status, h-verify, h-view
~/.claude/skills/h-reason/  # Aggregated reasoning skill

Internal Architecture

Go monorepo with ~40 internal packages including:

• artifact — FPF artifact (notes, problems, solutions, decisions)
• workcommission — WorkCommission lifecycle
• fpf — First Principles Framing engine
• agentcore, agentdriver, agentloop — embedded agent runtime
• mcp — MCP server implementation
• tui — Bubbletea TUI
• embedding — semantic search
• graph — relationship graph
• lsp — Language Server Protocol integration

Storage

SQLite database for artifact persistence.

Runtime Surfaces

Haft — Components

CLI Binary: haft

Top-Level Subcommands

Harness Subcommands (haft harness)

From source: prepare, run, status, result, apply, requeue, cancel.

MCP Tools (7)

Slash Commands (13, installed globally or locally)

Skill: h-reason

One aggregated skill (~/.claude/skills/h-reason/SKILL.md) that activates the full FPF reasoning pipeline end-to-end.

Spec Sections

Haft uses fenced YAML blocks within markdown (yaml spec-section) as the spec format. haft spec check validates these.

Desktop App (Alpha)

Tauri desktop app in desktop-tauri/ — not production-recommended in v7.

Haft — Uniqueness & Positioning

Differs from Seeds

Haft is most architecturally similar to taskmaster-ai (both provide structured task/decision management as MCP servers with CLI), but the philosophical delta is substantial. taskmaster-ai manages a task list with complexity scoring and expansion prompts for execution. Haft enforces a reasoning discipline (FPF) where problems must be framed, options explored under diversity check, and decisions recorded as falsifiable contracts — before any execution. The evidence decay mechanism (knowing when assumptions go stale) has no analog in any of the 11 seeds. The spec section format (fenced YAML blocks in markdown, validated with haft spec check) is proprietary to Haft. Unlike claude-flow (MCP-anchored hive mind), Haft has no multi-agent orchestration — it governs how a single agent reasons, not how a swarm coordinates. The CLAUDE.md with an explicit anti-sycophancy calibration table is borrowed from superpowers' "Iron Law" pattern but applied to communication style rather than TDD discipline.

Positioning

Signal type: pre-execution reasoning governance Intervention point: before tool-use (framing + decision recording) + after tool-use (evidence verification) Unique features: evidence decay, parity enforcement, WorkCommission scope bounding, deterministic spec checker, multi-host init (Claude Code + Codex + Cursor + Gemini + OpenCode + Air) Target user: engineering teams wanting structured decision records alongside AI-generated code

Observable Failure Modes

• FPF discipline is enforced by prompts/skills, not by hooks — the agent can skip the pipeline
• Evidence decay depends on the agent running haft_refresh; a lazy agent never detects staleness
• Non-standard license (NOASSERTION) is a red flag for enterprise adoption
• Alpha TUI and desktop app may be unreliable (explicitly called out in README)
• Heavy Go binary + SQLite setup vs. simpler markdown-only frameworks

Relationship to Batch 31

Haft is the only framework in this batch that focuses on pre-execution decision governance rather than runtime enforcement. All other frameworks (Sponsio, DashClaw, clauder, pi-steering-hooks) block/audit tool calls. Haft governs the reasoning that happens before tool calls occur.