Skip to main content
You talk to your coding agent instead of writing workflows or running the CLI yourself. It uses create-workflow to author the durable recipe you need, or copies a matching pattern from examples/init-pack/ (patterns init doesn’t install), then drives it to a validated result. This page catalogs those patterns: each row pairs what you say with what Smithers runs. For everything around a run (plugging in your own logging, alerting, time travel, memory, evals, accounts, packs), see Platform Capabilities.

Build

You know what you want shipped. These workflows enforce a build-check-review loop, turning requests into validated, reviewed code instead of first drafts.
Smithers workflow UI showing the implement workflow with implementation, validation, and reviewer nodes wired into a loop

implement runs a build → validate → review loop and feeds failures back in, so you get reviewed code instead of a first draft.

Smithers workflow UI showing research, plan, and validation-loop stages chained in sequence

research-plan-implement gathers context and plans before touching code, the pipeline for work in unfamiliar territory.

Smithers workflow UI showing a mission plan with milestones, parallel feature workers, integration, and validation

mission breaks long-horizon work into approved milestones with parallel workers, so a multi-day migration runs as scoped, reviewable chunks.

Smithers workflow UI showing kanban fanning tickets out into separate worktree branches before a merge step

kanban implements each ticket in its own worktree branch and merges only the ones that pass: isolated parallelism on one board.

Plan

Shape the work before any code is written: plans, tickets, sharper requirements, no repo changes.
Smithers workflow UI showing a single plan task that emits an ordered step list

plan returns ordered steps without changing the repo, the input you feed into implement, mission, or tickets-create.

Smithers workflow UI showing a request decomposed into multiple structured tickets

tickets-create splits one broad request into discrete tickets with acceptance criteria; drop them in .smithers/tickets/ and hand them to kanban.

Smithers workflow UI showing grill-me running an iterative question-and-answer interview loop

grill-me interrogates you before any planning, so the plan is built on real requirements instead of a vague one-liner.

Smithers workflow UI showing a research agent inspecting the repository and external sources

research gathers repo and external context up front, so the plan that follows cites real files and prior art.

Quality

Make existing work stronger: review it, fix bugs at the root, raise coverage, audit the whole repo for gaps.
Smithers workflow UI showing reviewer agents producing approval status and structured issues

review returns approval status plus issues tagged by severity, so 'is this production-ready' gets a structured answer.

Smithers workflow UI showing debug reproducing, fixing, and validating a bug across fixed iterations

debug reproduces the bug before fixing it and runs every validation iteration, with no early exit until the fix is verified.

Smithers workflow UI showing improve-test-coverage adding and validating tests

improve-test-coverage fills high-impact gaps and validates that the new tests actually pass.

Smithers workflow UI showing feature-enum producing grouped feature names from a repo scan

feature-enum produces a code-backed feature inventory that audit then reviews group by group in parallel: a whole-repo gap report.

Smithers workflow UI showing audit fanning out across feature groups and merging a report

audit consumes the feature map and reviews each group for missing tests, docs, and error handling across the whole inventory.

Run while you’re away

Smithers runs are durable: they survive crashes, restarts, and flaky tools, tracking what’s done and what’s next. Start something long-running, close the lid, come back to progress. Keep going until you stop it. Say:
“Keep working on reducing flaky tests. Don’t stop until I tell you to.”
Your agent runs ralph, an unbounded loop that re-runs the smart agent on your prompt. Say stop and it runs bunx smithers-orchestrator cancel RUN_ID.
Smithers workflow UI showing ralph running a single agent task in an unbounded loop

ralph loops the same prompt indefinitely, so a long-grind task keeps making progress while you're away.

Run on a schedule. Say:
“Every morning, scan the repo for stale TODOs and broken doc examples and open fixes.”
Your agent registers a cron schedule (bunx smithers-orchestrator cron add) to run the workflow automatically. Ask what’s scheduled with bunx smithers-orchestrator cron list. Gate on your approval. Say:
“Draft the release blog post, but don’t publish until I approve it.”
The workflow durably suspends at an approval gate. Say “approve it” and your agent runs bunx smithers-orchestrator approve, resuming right where it left off: work happens while you’re away, the irreversible step waits for you. mission uses the same gate for its milestone-plan sign-off.

Make your own workflows discoverable

Smithers treats agent-authored workflows as first-class. Once you’ve built task- and project-specific ones, say:
“Write skill docs for every Smithers workflow in this repo so any agent can find and run them.”
Your agent can copy the archived workflow-skill example, or ask create-workflow: it reads local workflow metadata and source, then writes concise agent-facing skill docs under .smithers/skills/.
Smithers workflow UI showing workflow-skill reading local workflows and emitting skill documentation

workflow-skill turns your local workflows into agent-facing skill docs, so the next agent on the repo can drive them by name without reading the source.

Platform capabilities

Reference: custom logging, alerting, time travel, memory, evals, accounts, and packs, with the prompt that asks for each.

Talk to your agent

How-to: phrase the outcomes above so your agent picks the right one.

Watch and steer

How-to: see a run live, approve gates, and redirect work in flight.

All workflows

Reference: the deeper catalog, with inputs and behavior for every built-in workflow.