Kiln stands out by orchestrating a complex multi-agent AI workflow without relying on any dedicated runtime, server, or npm package. Instead, it uses a folder of markdown files combined with the native capabilities of Claude Code to manage an elaborate pipeline of AI agents. This approach challenges the typical expectations where multi-agent systems usually require a runtime environment or an external orchestration layer.
what Kiln does and how it’s built
Kiln is a native plugin for Claude Code designed to implement a 7-step AI orchestration pipeline. It coordinates 34 named agents that cover distinct stages including brainstorming, research, architecture, building, quality assurance, validation, and reporting. Rather than shipping as a typical runtime or JavaScript package, Kiln’s entire system operates as a directory of markdown files.
Under the hood, Kiln leverages Claude Code’s native primitives — specifically TeamCreate, SendMessage, and TaskCreate commands — to manage agent lifecycles and communication. These primitives allow Kiln to create persistent teams of agents to retain context across interactions, while cycling fresh workers for each chunk of the build process. This balances the need to maintain state with the benefit of fresh execution contexts to reduce stale or corrupted state.
The pipeline runs primarily on the Opus 4.7 model within Claude Code, with optional fallback support for GPT-5.5 or 5.4 models accessed through a Codex CLI integration. This hybrid model approach lets Kiln tap into different AI capabilities depending on task requirements or availability.
State management is handled explicitly via a .kiln/STATE.md markdown file that tracks the orchestration state. This design choice supports crash-proof operation, enabling Kiln to resume workflows after interruptions without losing progress—a practical necessity for long-running or complex distributed AI pipelines.
The project is marked as a work-in-progress, with some known limitations such as edge cases related to terminal focus. These caveats highlight that while the design is clever and minimalistic, the implementation is not yet fully polished for all usage scenarios.
the technical approach behind Kiln’s orchestration
What makes Kiln particularly interesting is its zero-runtime architecture. Unlike most multi-agent AI orchestrators that require a dedicated service, daemon, or runtime environment, Kiln operates entirely inside Claude Code’s environment using markdown files as the coordination medium.
This means the orchestration logic, state tracking, and agent coordination are all represented as markdown documents. The agents themselves are managed via Claude Code’s native commands to create teams and send messages, which essentially act as workflow primitives. This reduces external dependencies and the complexity of managing separate infrastructure.
Kiln’s use of persistent teams to hold context is a key technical strength. It ensures that agents can retain relevant information across multiple steps, which is critical for coherence in multi-stage workflows. At the same time, Kiln cycles fresh workers for each build chunk, which helps avoid issues related to stale context or degraded agent performance over time.
The fallback mechanism to GPT models via Codex CLI provides additional flexibility. By optionally invoking GPT-5.5 or 5.4 when needed, Kiln can adapt to different AI model capabilities or availability constraints. This hybrid approach is pragmatic and acknowledges the strengths and limitations of each underlying model.
Using markdown files as the core artifact has pros and cons. On the positive side, markdown is lightweight, human-readable, and easy to version control. It also fits naturally with Claude Code’s native plugin model, which supports markdown-based workflows.
The tradeoff is that this approach lacks the dynamic flexibility of a dedicated runtime or orchestrator service. Certain edge cases—like terminal focus issues—may arise because the system depends on manual or semi-automated interaction with the markdown files and Claude Code commands. This means Kiln may not be suitable for high-throughput or fully automated production pipelines without additional tooling.
Overall, the code and architecture emphasize minimalism and platform-native integration over complexity or feature bloat. The approach is opinionated but worth understanding, especially if you want to explore multi-agent orchestration without adding external dependencies.
explore the project
Since there is no quickstart or installation section in the publicly available documentation, the best way to get started with Kiln is by exploring the repository structure and its markdown-based orchestration files.
The core of the project is a folder of markdown files that define the 7-step pipeline and the 34 agents involved. Reviewing these files gives insight into how the orchestration primitives of Claude Code are used in practice.
The .kiln/STATE.md file is a critical resource to understand how Kiln tracks its state and supports crash recovery. Examining this file along with the orchestration markdown reveals the pipeline’s flow and state transitions.
Documentation within the repository and any README files provide guidance on the expected environment — particularly the reliance on Claude Code version supporting Opus 4.7 and the Codex CLI for optional GPT fallback.
While Kiln is not currently packaged for a straightforward install or usage, its markdown-driven design means it can be adapted or extended by modifying or adding markdown orchestration files. This makes it a useful reference or starting point if you are building AI orchestration solutions on Claude Code or similar platforms.
verdict
Kiln offers a fascinating example of multi-agent AI orchestration that eschews traditional runtime dependencies in favor of a purely markdown-based approach using Claude Code’s native features. This design is clever and lightweight, avoiding the complexity of deploying external orchestrators or npm packages.
However, this minimalism comes with tradeoffs. The system is a work-in-progress with some known issues, and the reliance on markdown files and native primitives means it may not handle all edge cases or scale easily for high-demand production use without further development.
Kiln is most relevant for developers and researchers interested in exploring multi-agent orchestration on Claude Code or similar AI environments who want to experiment with zero-runtime, markdown-driven workflows. It’s worth understanding even if you don’t adopt it directly, as the approach highlights alternative ways to manage AI workflows leveraging platform-native capabilities.
If you need a battle-tested, production-ready multi-agent orchestration system, Kiln may not yet fit the bill. But if you’re exploring the boundaries of AI orchestration design and want to see a clean, minimal integration that sidesteps runtime complexity, Kiln is a project worth studying.
→ GitHub Repo: Fredasterehub/kiln ⭐ 180 · Python