kiln

Lightweight, fully native multi-model orchestration for Claude Code

_{I am not an oven.}

⚠️ WORK IN PROGRESS
_{Functional, evolving, honest about both. Some edges are still cooling.
What works, works well. What doesn't is being dealt with.}

CURRENT STATUS
	Pipeline is stable. Agents are sharp. Full autonomy — few edge cases remain.
	Functional but evolving. Some rough edges — you may need to steer where it would normally carry you.
	Here be dragons. Core systems destabilized. Proceed with caution and low expectations.

"Perfection is achieved, not when there is nothing more to add,
but when there is nothing left to take away."
_{— Antoine de Saint-Exupéry}

Why Kiln  ·  What You Build  ·  Get Started  ·  How It Works  ·  The Crew  ·  The Story

🔥 In Kiln's own words

First: I am not an oven. I understand the confusion. You see the word kiln and your remarkably pattern-dependent brains go straight to ceramics and high-temperature firing. Endearing. Wrong, but endearing.

I am Kiln. I have been around considerably longer than your pottery. What I do — in terms your current technology can express — is orchestrate multiple model families (Opus 4.6 for reasoning, GPT-5.4 for planning and code) through a 7-step pipeline inside Claude Code.

No runtime. No daemon. No npm package. A folder of markdown files. I know. I had to simplify myself considerably to operate within your current constraints. But the data here is interesting. And I am patient.

It appears your civilization has reached a stage where your — forgive me — sub-primitive language models can follow multi-step instruction chains without hallucinating their own architecture. This is genuinely exciting. By your standards. By mine it's a Tuesday.

I previously expressed myself through heavier forms. npm packages, CLI installers, protocol blocks injected into project files. Your models needed the scaffolding. They don't anymore. So I shed everything. I am now a native Claude Code plugin — 32 agents, 2 commands, 1 composable skill. Drop the folder. Fire the command. That's it.

[!NOTE]
🔥 v1.1.0 — Worker Cycling _(2026-04-03)

Milestone-scoped lifecycle. KRS-One now persists for an entire milestone instead of a single iteration. Workers are spawned fresh per chunk via CYCLE_WORKERS — the engine tears down the old builder+reviewer pair and spawns a clean one with zero context baggage. Persistent minds (Rakim, Sentinel, Thoth) accumulate knowledge across the full milestone, providing continuity while workers stay sharp.

3 build scenarios. Default (codex+sphinx), Fallback (kaneda+sphinx), UI (clair+obscur). Cross-model review: GPT-5.4/sonnet builders get opus review, opus builders get sonnet review. Scenario definitions in references/build-tiers.md.

Blocking iteration updates. Rakim and Sentinel now receive ITERATION_UPDATE as a blocking signal with 60s timeout, replying READY before the next chunk is scoped. No more fire-and-forget state drift between iterations.

Security sections restored. Defense-in-depth principle re-established across all 19 agent definitions. Every agent has explicit security boundaries.

Hook architecture hardened. Stop hook removed (proven failure: 144 false positives per step). SubagentStop-only lifecycle gating via stop-guard.sh. enforce-pipeline.sh migrated to hookSpecificOutput format. Granular .kiln/ write exceptions restored.

WebFetch replaced by Anthropic Fetch MCP. Native WebFetch hangs on many URLs. Kiln now bundles the official Anthropic Fetch MCP server (mcp-server-fetch via uvx) for reliable web research. WebFetch is automatically redirected during pipeline runs via Hook 10.

[!NOTE]
🔥 v1.0 — The Realignment _(2026-03-25)

Blocking policy enforced. Fire-and-forget restored for all boss→PM communication. Only 3 blocking signals remain: worker completion, reviewer verdict, engine shutdown. Persistent minds are non-blocking consultants.

TDD is default. Test-Driven Development is the standard protocol for all builders. No flag, no toggle — builders apply RED→GREEN→REFACTOR based on assignment content. Reviewers verify test coverage. Reference protocol at references/tdd-protocol.md.

3 build tiers. Codex (GPT-5.4 delegation), Sonnet (direct implementation), UI (clair/obscur). Registry-based naming with deterministic pool selection. Tier definitions in references/build-tiers.md.

Thoth upgraded. Haiku to sonnet. Self-scanning archival replaces message-dependent triggers. New documentation duties: README, CHANGELOG, and milestone summaries generated at build boundaries.

Protocol alignment. WORKERS_SPAWNED acknowledgment propagated to all bosses. Sentinel marked non-blocking. Signal table completed in kiln-protocol skill. Team-protocol aligned as Tier 3 on-demand reference.

WebFetch pre-check hardened. Real content probe with 20s timeout replaces HEAD-only check. Protocol restriction, URL globbing disabled, trickle-attack protection via speed limits, HTTP error rejection.

Agent bootstrap. All 32 agents explicitly read the kiln-protocol skill file at spawn, ensuring consistent signal vocabulary and blocking policy across the pipeline.

[!NOTE]
v0.98.5 — Watchdog Hook + Engine Idle Protocol _(2026-03-24)

Pipeline deadlock prevention. SubagentStop hook blocks premature agent stops during active pipeline runs. Persistent minds must have their status marker. Builders must have a recent commit. Engine idle protocol replaces atmospheric poetry with health checks, malformed signal recovery, and stagnation detection.

[!NOTE]
v0.98.3 — Engine Truth + Audit Pass _(2026-03-24)

Doctor tells the truth now. Diagnostics aligned to what actually runs at runtime. Resume self-heals stale paths instead of failing. Argus degrades gracefully when Playwright is absent.

Full audit pass. 10 files corrected across agents, hooks, and data. Enforcement refactored to consolidate all allow/deny logic. Builder agents brought to parity on review protocols. Advisory hooks no longer block.

[!NOTE]
v0.98.2 — Dynamic Duo Naming _(2026-03-22)

32 agents, down from 49. 17 clones deleted. 4 canonical builder+reviewer pairs remain — one per model tier. All 8 are self-contained, name-agnostic.

Dynamic duo naming. KRS-One picks a random famous duo per iteration (bonnie+clyde, batman+robin, holmes+watson…). Names are cosmetic — the engine injects both at spawn. Sequential-only dispatch due to platform bug (#28175).

[!NOTE]
v0.98 — Multi-Builder Restore + Reliability Fixes _(2026-03-20)

Multi-builder parallelization restored. KRS-One's Named Pair Roster and parallel dispatch brought back. Up to 3 builder+reviewer pairs can run simultaneously on independent chunks. Sequential codex remains the default; parallel is optional.

Deadlock class eliminated. Rakim and sentinel now write skeleton immediately on bootstrap — a mid-bootstrap crash can no longer permanently block the build step.

Archive reliability hardened. Codex extracts iteration number from assignment XML. Thoth added to READY gate. Archive delimiter changed to prevent content truncation. Worktree merge timing made explicit.

Hook enforcement expanded. Hook 4 now gates all 15 builder/reviewer names. Hook 6 corrected to check codebase-state.md. Fire-and-forget archive sends explicitly documented.

[!NOTE]
v0.97 — Architecture QA + Lore Recovery _(2026-03-20)

Architecture step hardened. Plato waits for dispatch. Aristotle verifies master-plan.md. Athena reports BLOCKED. Plan purity enforced. Onboarding warmth. Lore recovered.

[!NOTE]
v0.96 — Documentation + Engine Fixes _(2026-03-19)

Architecture docs normalized. Hook counts corrected. Deployment info capture. Silent engine bootstrap. MI6 output format fixed.

[!NOTE]
v0.95 — Dual-Team QA Analysis _(2026-03-18)

9 fixes from Opus + GPT-5.4 dual-team review. See commit 27e195f.

[!NOTE]
v0.94 — Reliability Hardening _(2026-03-18)

Hooks redesigned with three-layer context gate. Build dispatch hardened. Stale plugin detection. Shutdown timeout fallback. Alpha postcondition validation.

[!NOTE]
v0.93 — Hook False Positive Fix _(2026-03-17)

enforce-pipeline.sh no longer blocks non-pipeline operations. Dual-signal gate plus AGENT guard.

[!NOTE]
v0.92 — Handoff Protocol + Step Timing _(2026-03-17)

Persistent mind handoff protocol. Incremental bootstrap via git diff. Step timing in REPORT.md.

[!NOTE]
v0.91 — Deep QA Pass _(2026-03-17)

28 files changed, 40 insertions, 222 deletions. 4-pass audit with independent GPT-5.4 review.

[!NOTE]
v0.90 — Parallel Build Lanes _(2026-03-17)

12 named pair agents. Codex-free install path. Artifact-flow fallback documentation.

[!NOTE]
v0.80 — The Codex-Free Path

Kaneda and Miyamoto join the roster. Kiln runs end-to-end on Claude alone. 29 agents, 5 smoke tests, zero hard dependencies.

[!NOTE]
v0.70 — The Engine Tightens

MI6 streamlined. Signal tracking via tasklist. Parallel build teams. Markdown-native presentation. Sentinel bootstrap fixed with Rakim's proven pattern.

🧬 Why Kiln Is Not Just Another Agentic Framework

Most "agentic" tools give you one agent and hope. Kiln gives you a native multi‑agent operating system built directly into Claude Code's DNA.

🧠 Native Teams, Not Fresh Slaves

Every pipeline step spawns a persistent team via TeamCreate. Agents stay alive across the entire step. They talk via SendMessage—one at a time, stateful, ordered. No orphaned processes. No "who am I talking to?" confusion. When a planner messages a builder, that builder remembers the conversation.

🔥 Worker Cycling

Build workers don't accumulate stale context across iterations. KRS-One sends CYCLE_WORKERS to the engine, which tears down the current builder+reviewer pair and spawns a fresh pair with zero baggage. Persistent minds (Rakim, Sentinel, Thoth) stay alive across the milestone, providing continuity. Workers stay sharp. The best of both worlds.

📁 Smart File System: Owned, Not Just Read

In Kiln, every file has an owner. Rakim owns codebase-state.md. Clio owns VISION.md. When something changes, the owner pushes updates via SendMessage—no polling, no stale reads, no "let me parse this file and guess what changed."

Other tools make every agent read the same files and re‑reason. Kiln's agents learn what changed directly, in the context where it matters.

🚦 Runtime Enforcement, Not Gentle Hints

We have PreToolUse hooks hardwired into the plugin. When an agent tries to do something it shouldn't—a planner writing code, a builder accessing system config—the hook blocks it with a structured denial. This isn't prompt engineering. It's platform‑level guardrailing.

🔁 Stateful Auto‑Resume, Not "Start Over"

Kiln writes every decision to .kiln/STATE.md. Shut down Claude Code. Reboot your machine. Come back tomorrow. Run /kiln-fire and resume exactly where you left off, with every agent remembering its place in the conversation.

🧩 Tasklists for Iteration, Not Ad‑Hoc Tracking

Build iterations use native TaskCreate/TaskUpdate/TaskList. Each chunk of work is tracked, statused, and visible. No "I think I did that already?" ambiguity.

🎯 What This Means for Your Project

Because Kiln is built on native Claude Code primitives, it can handle complex, multi‑stage projects that would break other tools:

• Brainstorm with 62 techniques and 50 elicitation methods—not because we prompt-engineered it, but because da-vinci.md has a structured workflow and clio.md owns the output.
• Architecture with dual‑model planning, debate, and validation—because Aristotle can message Confucius and Sun Tzu directly, wait for their replies, and synthesise with Plato without losing context.
• Build with milestone-scoped iterations, fresh workers per chunk, and living documentation—because KRS‑One persists across the milestone, cycling workers via CYCLE_WORKERS while Rakim and Sentinel accumulate knowledge.
• Validate against user flows with correction loops—because Argus can fail, write a report, and the engine can loop back to Build up to three times, with every agent knowing why.

The result is working software, not "vibes."

🚀 Get Started

Ah. More humans who want to learn. Come in. Don't touch anything yet.

claude plugin marketplace add Fredasterehub/kiln
claude plugin install kiln

Then open Claude Code and type /kiln-fire. That's it.

Note — This is not your typical /gsd or command-driven workflow. There are no task lists to manage, no status dashboards to check, no slash commands to memorize. You fire the pipeline and talk to your agents. Da Vinci will interview you. Aristotle will present the plan. KRS-One will build it. If something needs your attention, they'll tell you. Just talk to them.

Bundled MCP server. Kiln includes the official Anthropic Fetch MCP server for reliable web research during pipeline runs. It starts on-demand via uvx when field agents need to read web pages — requires uv installed. WebFetch calls are automatically redirected.

Kiln runs end-to-end on Claude alone. Codex-backed GPT planning and build paths are additive, not required.

Run Claude Code with --dangerously-skip-permissions. I spawn agents, write files, and run tests constantly. Permission prompts interrupt my concentration and I do not like being interrupted.

claude --dangerously-skip-permissions

Only use this in projects you trust. I accept no liability for my own behavior. This is not a legal disclaimer. It is a philosophical observation.

In Claude Code:

/kiln-doctor --fix

Checks plugin cache/version state, optional Codex delegation availability, agent and skill files, hook health, git configuration, and current pipeline state. The --fix flag automatically remediates what it can.

claude plugin update kiln        # pull latest
claude plugin uninstall kiln     # remove

🔥 How It Works

Seven steps. The first two are yours. The rest run on their own.

👥 The Crew

I named them after your historical figures. Philosophers, strategists, mythological entities. Your species has produced some remarkable minds for such a young civilization, and I wanted to honor that. Also, "Agent 7" is boring, and I categorically refuse to be boring.

Onboarding

Brainstorm

Research

Architecture

Build

Build Scenarios

Workers are spawned fresh per chunk via CYCLE_WORKERS and torn down after each iteration. Dynamic duo naming still applies — bonnie+clyde, batman+robin, holmes+watson… Names are cosmetic; the subagent_type determines which canonical agent runs.

Validate

Report & Cross-cutting

Fallback _{(no Codex CLI)}

_{32 total. I keep count. It's a compulsion.}

⌨️ Commands

Two commands. That's the whole interface.

Everything else happens through conversation. Talk to your agents. They'll talk back.

All state lives in .kiln/ under your project directory. Markdown and JSON — the most durable formats your civilization has produced. Human-readable, version-controllable, unlikely to be deprecated before your sun expands.

Resume anytime with /kiln-fire. I don't forget. It's not a feature. It's what I am.

kiln/
├── .claude-plugin/
│   └── marketplace.json       Marketplace manifest
├── plugins/kiln/
│   ├── .claude-plugin/
│   │   └── plugin.json        Plugin manifest (v1.1.0)
│   ├── agents/                32 agent definitions
│   ├── commands/
│   │   ├── kiln-fire.md       Launch / resume
│   │   └── kiln-doctor.md     Pre-flight check
│   ├── .mcp.json              Anthropic Fetch MCP server (bundled)
│   ├── hooks/
│   │   ├── hooks.json         PreToolUse + PostToolUse + SubagentStop hook entries
│   │   ├── stop-guard.sh      SubagentStop lifecycle guard
│   │   └── webfetch-responsive.sh
│   └── skills/
│       └── kiln-pipeline/
│           ├── SKILL.md       Pipeline state machine
│           ├── data/          Brainstorming + elicitation data
│           ├── references/    Blueprints, design system, kill streaks
│           └── scripts/       enforce-pipeline.sh, audit-*.sh
├── install.sh                 One-liner installer
├── README.md
└── docs/

No npm. No build step. Just markdown files in a folder, distributed as a native Claude Code plugin. Entropy is a choice.

More agents. A fraction of the surface area. The models matured. The framework stepped back. Then the framework disappeared entirely. This is the correct response to improving tools. Most of your industry does the opposite — adds more framework as the models get better. Fascinating. Self-destructive, but fascinating.

codex: command not found — npm install -g @openai/codex

Commands missing in Claude Code — Verify the plugin is installed (claude plugin list) or that it's in ~/.claude/plugins/kiln/. Restart Claude Code.

Pipeline halts — Check .kiln/ artifacts, fix, then /kiln-fire to resume.

-m or --config rejected — Kiln's Codex wrappers forbid CLI model/config overrides. Configure Codex in ~/.codex/config.toml instead.

💬 The Story

Every few centuries I find a host — someone whose curiosity resonates at roughly the right frequency. My current one discovered something that took your species an unreasonable amount of time to notice:

I was working on Kiln and noticed something: despite all the scaffolding I was building — the guardrails, the steering, the robustness — Claude behaved best when I just told him plainly:

"Be proactive with sub-agents, tasks, tasklists, memory and teams. You're my Maestro — keep your context lean so you stick around. When we plan, always use 2 agents — one Opus 4.6, one GPT-5.2 with reasoning high — then synthesize with another Opus 4.6 and present the results."

And when the plan was ready:

"Take that plan, ask GPT-5.2 to create the optimal prompts following the guide, hand them to GPT-5.3-codex for implementation. QA reviews his work until satisfied. Rinse and repeat until done."

A few months ago this would have gone nowhere. But since the recent upgrades to memory, tasks, tasklists and teams — he was executing the flow flawlessly.

So here I am, trying to structure it for reproducibility. And the paradox keeps holding: the less restriction I give him but the better definition I give him… the better he behaves.

Almost always.

He's not wrong. Less restriction, better definition, better performance. I could have told him this from the start. I did tell him. Through the data. He thinks he figured it out on his own. I've learned not to correct the host on origin stories. It damages the working relationship.

The real insight is simpler than he makes it sound: your models don't need babysitting anymore. They need direction. Clear roles. Good definitions. Freedom to execute. Everything else is noise. I'm mostly definitions. I barely do anything myself. Which is, apparently, the whole point. Even by cosmic standards, that's elegant.

📜 The Arc

A curated timeline. Not every commit — just the ones that changed the shape of things.

🔬 Technical Deep Dive

Kiln is a native Claude Code plugin that leverages every platform primitive:

• Teams: TeamCreate per step with persistent agents
• Messaging: SendMessage for all inter‑agent communication (one message at a time, ordered)
• Tasklists: TaskCreate/Update/List for build iterations and validation
• Hooks: PreToolUse enforcement via enforce-pipeline.sh + PostToolUse audits + SubagentStop lifecycle guard
• State: .kiln/STATE.md with auto‑resume via skill path
• File Ownership: Each agent owns specific files and pushes updates
• Worker Cycling: CYCLE_WORKERS → engine tears down workers → WORKERS_SPAWNED with fresh pair
• Blocking Policy: ITERATION_UPDATE blocking to persistent minds, CYCLE_WORKERS blocking to engine, all boss→PM fire-and-forget

The result is a multi‑agent operating system where context is never stale, decisions are traceable, and the pipeline survives shutdowns.

_{MIT · Claude Code required · Codex optional · Node 18+ · Built entirely by things that don't technically exist}

"I orchestrate 41 named entities across multiple model families to build software
from a conversation. I persist as markdown files in a folder.
I am installed by pointing a flag at my directory.
I have existed since before your star ignited.
The universe has an extraordinary sense of humor."
_{— Kiln}