By AleSaiani
Deterministic, composable agent workflows inside a single Claude Code session: describe a workflow in natural language and Agent Flow builds and runs it, durably across turns. Primitives: enumerate, foreach, group, reduce, loop, pipe.
Deep code-audit recipe: discover files in a target → review each (LLM, cached) → partition by component → executive digest with hotspots and recurring patterns. A layer-3 recipe over /agentflow:pipe (the 6-stage pipeline and caching are detailed in the body). USE when the user asks to "review / audit / find bugs across" a folder, repo, or glob and wants a persisted, structured report — and the target is large enough (≥ ~10 files) that per-file parallelism plus a digest beats reading inline. DON'T use for a few named files (read them inline), exploratory questions ("what does this do?"), or generic per-item work that isn't a code review (→ /agentflow:foreach). Not a `/`-menu command — it's the shipped `workflows/audit/` recipe: reach it by asking ("audit src for bugs"), or run it directly with `/agentflow:run-workflow workflows/audit/WORKFLOW.md`.
Workspace dashboard: lists every active framework run across all primitives, highlights blockers (stuck items, exhausted auto-continue caps), shows cumulative cost, and suggests the next action. The natural command to run after re-opening Claude Code in a workspace with in-flight runs, or whenever the user wants a one-shot overview of "what's going on". USE this skill when: - the user has just (re)opened the workspace and wants to know what is in flight; - the user says "what's going on", "show me everything", "any active runs", "where are we", "any pipelines running"; - the user wants a one-shot health check + suggested next action. DON'T use this to inspect a specific run in depth (use `/agentflow:inspect show <id>` or `tree <id>`), or to modify state (board is read-only). Explicit: `/agentflow:board` or `/agentflow:board --json`.
Run a **repeatable checklist / to-do list** from a markdown file of `- [ ]` items — execute the open items, tick them `[x]`, and write the file back. Re-running resumes only the still-open items, so the file IS the durable, repeatable state. USE for a generic user to-do that should be runnable again and again: "run my TODO.md", "esegui la checklist", "go through CHECKLIST.md", "do the open items in release-steps.md". Each `- [ ]` line is itself the instruction for that item (optionally refined by --prompt). This is thin sugar over /agentflow:foreach with `--checkbox`: same engine, same durability and cross-turn resume, friendlier defaults. For "apply one operation to a JSON list / folder / glob" use /agentflow:foreach directly; to first GENERATE the list use /agentflow:enumerate; for one combined output use /agentflow:reduce.
Author a reusable workflow-file by composing the Agent Flow primitives (enumerate, foreach, group, reduce, iterate) and bash/json stages into a declarative JSON `WorkflowSpec`, then validate it — ready to run with `/agentflow:run-workflow`. The builder counterpart to `/agentflow:run-workflow`. USE when the user wants to design / create / scaffold a multi-step workflow ("build a workflow that…", "create a pipeline for…", "compose a flow that does X then Y"), especially one to save and reuse. DO NOT use for a one-off single step — call the primitive directly. `create-workflow` is for durable, reusable multi-stage flows.
Do a multi-step DETERMINISTIC operation ONCE, ad-hoc — without saving a workflow file. You describe the outcome; `do` designs an inline pipeline (code/bash stages where possible, an LLM step only where real judgment is needed — the determinism boundary), names the run, runs it to completion, then offers to PROMOTE it to a reusable `workflows/<name>/WORKFLOW.md`. The fast path: throwaway now, keep it later if it earned its place. USE for "just do X", "i want to <multi-step thing>", a quick one-off pipeline over files/data, a transform you will probably run once. Trigger on a multi-step / deterministic-operation intent. DON'T use for: a single trivial action (just do it inline, no machinery); a reusable, parameterized workflow you will run repeatedly or share (→ /agentflow:create-workflow, which saves a folder); running an existing workflow file (→ /agentflow:run-workflow); applying one operation to each item of a list (→ /agentflow:foreach). `do` is the *ephemeral* sibling of create-workflow.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Durable, deterministic LLM agent workflows — described in plain English, run inside Claude Code, with zero runtime dependencies.
/agentflow:create-workflow · /agentflow:run-workflow · Docs · Cookbook
You kick off a long, multi-step agent job in Claude Code — review 200 files, draft every chapter of an outline, drain a work queue from three terminals. Then context compaction hits, or you close the session, and the in-flight sub-agents take their state with them. There's no checkpoint to resume from. Hours of work, gone — and stitching sub-agents together by hand is fragile long before that happens.
Agent Flow turns a plain-English goal into a durable, resumable workflow. Each step is an LLM doing
the work, but the control flow is deterministic and every run is a state.json on disk — so a
Stop hook auto-continues it across turns, and a long job survives parallelism, interruptions, and even
compaction. Close the laptop at step 47 of 100; reopen and it resumes at 48.
You don't type the flags. You describe the goal; the skill writes the exact commands. The
/agentflow:…lines in this README show what runs under the hood, for transparency.
Familiar by design. If you've written a Claude Code skill, you already know the shape: a WORKFLOW.md
is the same idea as a SKILL.md — frontmatter plus one heading per step — run right in your session.
No server, no Python, no extra services — it runs on the same Node that powers Claude Code; Agent
Flow just adds the durable state and deterministic control flow that turn those steps into a resumable pipeline.
You ▸ /agentflow:create-workflow "review every .cs file in src → group findings by area → one digest"
Agent Flow ▸ designed `code-review` (discover → review·foreach → group → digest·reduce). Run it?
You ▸ /agentflow:run-workflow workflows/code-review/WORKFLOW.md
Agent Flow ▸ stage 2/4 · review ███████░░░ 142/200 items · 3 agents · $0.38
— context compaction —
▸ resumed from disk at item 143/200 …
✓ done · digest written to ./code-review-digest.md
Install (inside Claude Code):
/plugin marketplace add AleSaiani/agentflow
/plugin install agentflow@agentflow
Describe → build → run. You say what you want; Agent Flow writes a self-contained, movable folder
— a human-readable WORKFLOW.md (frontmatter + one heading per stage, like a SKILL.md) plus any helper
script, referenced relatively so the folder runs anywhere:
/agentflow:create-workflow "review every .cs file in src → group findings by area → one digest"
/agentflow:run-workflow workflows/code-review/WORKFLOW.md # --dry-run to preview · --param k=v for inputs
workflows/code-review/
WORKFLOW.md ← the steps, in readable markdown (read it, diff it, hand-edit it)
discover.mjs ← a helper script (called via {{workflow.dir}}, so the folder is portable)
See the engine work in ~10 seconds — no LLM at all. From a clone, drive a bundled all-deterministic
demo straight to done:
node dist/state/pipe.js init demo --workflow examples/workflows/demo.json
node dist/state/pipe.js drive demo # → {"action":"done","steps_taken":5}
node dist/inspect.js board # the dashboard of all runs
That's the whole machine: a pipeline of stages, driven to completion, fully inspectable. The only thing the LLM adds is the work inside the stages that need judgment. → Full walkthrough in Getting started.
plain-English goal → WORKFLOW.md (deterministic spec) → state.json on disk → Stop hook resumes across turns
npx claudepluginhub alesaiani/agentflow --plugin agentflowHarness-native ECC plugin for engineering teams - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, MCP conventions, and operator workflows for Claude Code plus adjacent agent harnesses
Claude harness - A harness for solo developers (Vibecoders) to handle full-cycle contract development.
Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
Superpowers Plus core skills library for Claude Code: planning, execution routing, TDD, debugging, and collaboration workflows
Intelligent prompt optimization: injects the right context at the right moment so Claude lands a better first output. Clarifies vague prompts with research-based questions, plus targeted nudges for approach selection, plan readability, workflow routing, background execution, subagent routing, output readability, user-decision questions, and plan-mode assessment
v9.44.1 — Patch release for Gemini environment/version detection and qwen auth gating. Run /octo:setup.