Smithers - Smithers

Orchestrate agents at scale with composable workflows.

Smithers is a durable runtime for long-running AI coding agents. Install a skill and your agent writes the workflow — a composable TypeScript tree — then runs it for minutes or days with crash recovery, retries, human approvals, replay, and full observability across any agent, any model, and any machine.

/** @jsxImportSource smithers-orchestrator */
import { createSmithers, Sequence, Task } from "smithers-orchestrator";
import { z } from "zod";

const { Workflow, smithers, outputs } = createSmithers({
  hello: z.object({ message: z.string() }),
});

export default smithers((ctx) => (
  <Workflow name="hello">
    <Sequence>
      <Task id="greet" output={outputs.hello}>
        {{ message: `Hello, ${ctx.input.name}` }}
      </Task>
    </Sequence>
  </Workflow>
));

bunx smithers-orchestrator init
bunx smithers-orchestrator up workflow.tsx --input '{"name":"world"}'

Outputs are validated by Zod, persisted to SQLite, and survive crashes. Resume with --resume true, or drive everything from your coding agent with the smithers skill.

What makes Smithers different

Composable workflows

Sequence, fan out, branch, and loop tasks into workflows shaped to your task and your project, not one giant one-size-fits-all agent.

Model- & harness-agnostic

Claude Code, Codex, Pi, Antigravity, and more, plus any model through the AI SDK. Swap the harness without rewriting the workflow.

Robust by default

Durable execution, retries, replay, time-travel, evals, human approvals, and Prometheus metrics. Guarantees no single agent gives you.

Why Smithers

We build Smithers to put power in the hands of builders. You shouldn’t have to wait and see what the model companies decide to ship next. With composable, model- and harness-agnostic workflows, you can build the future you want to see today, on whatever model and harness is best this week. Every decision in Smithers is about making builders more powerful, not replacing them. Where other tools race to swap human craftsmanship for slop, Smithers is built to get higher-quality output out of agents, with the review loops, approvals, evals, and structure that real work demands. And we don’t believe in one-size-fits-all orchestration. The best results come from task-specific and project-specific workflows, so Smithers ships dozens of them ready to run, and treats having your agent author new ones as a first-class path.

Built-in workflows

bunx smithers-orchestrator init scaffolds a .smithers/ folder preloaded with production-ready workflows. Point your agent at one and go with bunx smithers-orchestrator workflow run <id> --prompt "...":

# break a request into tickets, then implement them on a board
bunx smithers-orchestrator workflow run tickets-create --prompt "add rate limiting and audit logging"
bunx smithers-orchestrator workflow run kanban

Build

implement · research-plan-implement · mission · kanban · ralph. Turn a request into validated, reviewed code, from a focused change to a long-horizon mission.

Plan

research · plan · grill-me · write-a-prd · ticket-create · tickets-create. Gather context and shape the work before any code is written.

Quality

review · debug · improve-test-coverage · feature-enum · audit. Review changes, fix bugs, raise coverage, and audit for gaps.

Browse the catalog

Every bundled workflow is a normal Smithers TSX file: run it as-is, edit it for your repo, or fork it as a starting point.

Examples

The examples cover real patterns you can copy: multi-agent panels and debates, fan-out/fan-in, review and coverage loops, migrations, PR shepherding, canary judging, SLO breach explainers, repo janitors, and more.

Multi-agent review

N specialists review in parallel; a moderator synthesizes the verdict.

Approval gates

Pause a run for a human decision, then resume exactly where it left off.

Dynamic plans

Let an agent plan the work, then fan the plan out across worker tasks.

Loops

Iterate until tests pass, coverage hits target, or a reviewer approves.

Any agent, any model

Smithers doesn’t bet on one lab or one harness. Point each task at whichever agent is best for the job, and switch freely:

CLI agents: Claude Code, Codex, Pi, Antigravity, Kimi, and more, driven through their own runtimes.
SDK agents: any model the AI SDK supports, with tools, structured output, and MCP.
Mix them in one workflow: a frontier model plans, a fast model fans out, a specialized harness does the edits. The workflow doesn’t change when the model does.

Durable and observable

Runs survive crashes, restarts, and flaky tools. Every completed step is persisted the moment it finishes, so the runtime always knows what’s done and what to run next, and you can rewind, fork, and replay any run.

smithers up workflow.tsx --run-id abc123 --resume true   # resume after a crash
smithers rewind abc123 --frame 4                         # time-travel to an earlier frame
smithers observability up                                # Grafana + Prometheus + Tempo + OTLP
smithers up workflow.tsx --serve --metrics               # HTTP API, SSE events, and /metrics

Every run emits Prometheus metrics and OpenTelemetry traces, so you can watch token spend, task latency, retries, and failures across thousands of runs. See How It Works for the render → execute → persist loop.

Scale across machines

Most workflows run fine on your laptop. When you need isolation, parallelism, or horizontal scale, the same <Sandbox> primitive runs a child workflow through an injectable provider (local or remote) with no change to the workflow:

Local: run agents in an isolated sandbox on your own machine.
Remote: gVisor, Kubernetes, freestyle.sh, Daytona, and Cloudflare.

Install the agent skill

Make your coding agent drive Smithers for you.

Tour

A 6-step worked example that introduces every core feature.

How It Works

The render → execute → persist loop that makes runs durable.

Components

The full JSX surface: tasks, sequences, loops, approvals, and more.

Documentation Index

​What makes Smithers different