βάθος — Greek for “depth, the abyss.”

Give your AI the depth of a full product team.

BATHOS turns a single Claude Code session into a disciplined team: 17 specialist roles across a 7-wave pipeline, scale-adaptive routing, and hard quality gates, all backed by a deterministic Rust engine.

View on GitHub View on βάθος

v0.2.0 · Rust engine · runs on Claude Code

Install in three steps

Build the engine, point your hooks at it, then drive the pipeline from Claude Code.

Build the engine

Clone the repository and compile the single Rust binary.

git clone <your-fork-url> bathos && cd bathos
cd core && cargo build --release && cd ..

Expose it to the hooks

Set BATHOS_BIN so the commands and hooks can find the engine.

export BATHOS_BIN="$(pwd)/core/target/release/bathos"

Drive the pipeline

Open Claude Code in your project and run the wave commands in order.

/team-kickoff
/route              /abs/path/to/project
/wave1-discovery    /abs/path
/wave2-design       /abs/path
/wave3-story-gate   /abs/path
/wave5-implement    /abs/path
/wave6-verify-report /abs/path
/team-confirm

Requires Claude Code v2.1.32+ with Agent Teams enabled, plus the Rust toolchain and jq.

Structure where a chat has none

A single long LLM conversation drifts: context is lost between design and build, checks get skipped, and the same model both writes and approves its own work. BATHOS replaces that with structure.

Plain LLM chat

BATHOS

One conversation, growing context drift

17 specialist roles across a 7-wave pipeline

Context lost between design and implementation

Zero-context-loss, self-contained story files (Wave 3)

Implicit, one-size-fits-all effort

A scale-adaptive router with explicit Lv0–4

Implementation starts whenever

A hard readiness gate physically blocks the build on FAIL

The author also “verifies” its own work

Independent reviewers and a tamper-evident audit chain

Advice that quietly overrides you

User Sovereignty: the AI proposes, you decide

Two planes, one runtime

You mostly type slash commands. A single Rust binary is the deterministic core those commands call underneath.

Markdown under .claude/

Orchestration

Slash commands, roles, and hooks that run the waves and spawn, review, and retire teammates, driven by the lead: your main Claude Code session.

A single static Rust binary

Engine

Computes and enforces state, gates, wave transitions, routing, story freshness, and plugins. The hooks and commands invoke it automatically.

A seven-wave delivery pipeline

Work moves from discovery to a verified release through explicit waves. The mainline is W0 → W1 → W2 → W3 → W5 → W6; IP & research (W4) is an optional plug-in off the critical path.

Analysis

Caleb

Optional pre-brief: brainstorm, forge the idea, product brief.

Discovery & market

John · Caleb

Reverse-engineering and market research; sharpen the USP.

Plan · architecture · design

Joshua → James · Jonnathan

Planning gates the wave, then architecture and UX in parallel.

Story engineering

Matthew + Thomas · Matthias

Condense to self-contained story files; the implementation-readiness gate.

IP & research

Mark · Nathanael

Optional plug-in, off the critical path. Patents and papers.

Implementation

Phillip · Andrew · Stephen

Backend, frontend, and ML build against the story files.

Verify · docs · report

Thomas · Michael · Hananiah · Martin

Review, security audit, behavior-preserving refactor, and the release report.

Wave 3 · the heart

Wave 3 closes the design-to-build gap: the story engineer condenses upstream work into a self-contained story file where every technical claim is tagged to its source, independent reviewers sign off, and on FAIL a hook physically blocks entry into implementation.

Scale-adaptive routing

BATHOS activates only the waves a task needs. The router recommends a level from four stakes axes; you confirm it.

Level	Work type	Active waves
Lv0	Bug fix / trivial	W5 (+ minimal W6)
Lv1	Small feature / local refactor	Light W2 + W3 (slim) + W5 + light W6
Lv2	Standard feature / module	W1 + W2 + W3 + W5 + W6
Lv3	New product / large	W0–W6 (W4 optional)
Lv4	Enterprise / deep-tech / regulated	Full W0–W6 + W4

Seventeen specialists, one lead

The lead is your main session and is never spawned. Specialists are spawned per wave, with concurrency capped at three.

00PaulLead / final confirmall

01JohnReverse specialistW1

02CalebMarket analysis / USPW1

03JoshuaService planningW2

04JamesSW / cloud architectW2

05MarkIP specialist (patents)W4

06NathanaelResearch writerW4

07JonnathanChief designer (UX/UI)W2

08PhillipBackend & data leadW5

09AndrewFrontend & mobile leadW5

10StephenAI / ML leadW5

11TimothyDev-definition docsW6

12ThomasCode reviewerW6

13MichaelSecurity specialistW6

14HananiahRefactoring specialistW6

15MatthiasQA / validationW6

16MartinMonitoring / reportW6

17MatthewScrum master / story engineerW3

Gates that actually gate

Every wave gate speaks one vocabulary, and the critical one is enforced in code. No evidence-free auto-pass.

PASS

Criteria met, no blockers

Proceed to the next wave

CONCERNS

Conditional pass, non-blocking risk

Log the risk, then proceed

FAIL

Blocking defect

Entry blocked; remediate and re-gate

Tamper-evident by design

Every state change is written to a keyed audit hash-chain (HMAC-SHA256). A single command, bathos audit verify, proves the trail has not been altered.

A deterministic core, not vibes

The critical invariants (state, gates, routing, story freshness) live in a single static Rust binary, so they are computed and enforced the same way every time.

Single static binary: One compact bathos executable, no runtime dependencies.
Schema-validated SSOT: manifest.json is the source of truth: schema-validated, atomic writes.
Tamper-evident audit: A keyed HMAC hash-chain with a one-command verify.
Proven: 510 Rust tests + 86 hook determinism checks, all green; clippy clean.

$ echo '{"scope":"feature","novelty":true}' \
    | bathos --state-dir _state route decide

→ {"recommended_level":2,"requires_confirmation":true}

Recommend a level from the stakes. The engine proposes, you confirm.

Bring depth to your next build.

Read the source, or explore more on the web.

View on GitHub View on βάθος