Workflow orchestration for Claude Code.

version
3.0.0

Install

/plugin install flow@agent-toolkit

Run it inside Claude Code after adding the marketplace with /plugin marketplace add leclabs/agent-toolkit.

Contents

Discovered from source

Agents 6

Flow Plugin

Orchestration ruleset for Navigator, delivered via prompt injection.

Flow tells Claude how to orchestrate via Navigator's FSM. The orchestration logic lives in the rules, not in code.

What Flow Provides

ComponentWhat it is
RulesetGuidelines for delegation, task handling, HITL
HookInjects rules into system prompt at session start
Commands/flow:* skills for task and workflow management

Quick Start

/flow:task "add user authentication"   # Create task, select workflow
/flow:go                                # Execute all pending tasks

Or just ask Claude naturally -- session context enables workflow requests.

Commands

CommandDescription
/flow:taskCreate task with workflow selection
/flow:goExecute all pending tasks
/flow:listList available workflows
/flow:setupCopy workflows/agents to project
/flow:diagramVisualize a workflow
/flow:reconDeep project reconnaissance

Architecture

User Request
    ↓
Flow Plugin (session protocol, rules, hooks)
    ↓
Navigator MCP (state machine, graph evaluation)
    ↓
Subagents (Planner, Developer, Tester, Reviewer...)

Flow injects orchestration context at session start. Claude calls Navigator MCP directly -- no intermediate layer.

Subagents

AgentRole
PlannerParse requirements, explore code, create plans
DeveloperWrite code, fix issues, implement features
TesterWrite tests, run tests, verify behavior
ReviewerReview plans and code for quality
InvestigatorReproduce bugs, trace issues, find root causes
Context EngineerOptimize context, analyze documentation
ArchitectDesign system architecture, review builds

Customization

/flow:setup   # Copy workflows/agents to project for editing

Project workflows in .flow/workflows/ take precedence over catalog defaults.

See Also

Code Quality

Architecture: Functional Core, Imperative Shell

Privilege unbraided, composable strands over complected weaves.

LayerResponsibilityProperties
Functional Core
(Pure Modules)
Domain Logic• Deterministic (f(x) -> y)
• Dependency-free
• Framework-agnostic
• Testable in isolation
Imperative Shell
(Composition Hubs)
Integration & Effect• Coordinates Core + I/O
• Injects dependencies
• Manages state/effects
• Contains no complex logic

Rule: Push valid, pure values to the Core. Keep the Shell thin and focused on wiring.

Ephemeral Artifacts

.cruft/ is the standard location for temporary files: for both subagents and the Orchestrator.

Permanent documentation requires explicit user direction.

Flow: Three Integration Layers

Flow has three distinct layers. Each owns different concerns.

Flow (Navigator MCP)

Stateless workflow engine. Provides MCP tools for navigation, diagramming, and catalog management.

Owns: Workflow schema, catalog templates (workflows + agents), state machine logic, edge evaluation, fork/join, write-through persistence.

The catalog is a template library for browsing and copying — not auto-loaded at runtime. The agent field on workflow nodes is an opaque string to Flow — it stores and returns the value but doesn't resolve it. Flow can be consumed by any MCP client, not just Claude Code.

Host Plugin

A Claude Code plugin that wraps Flow with an orchestration layer. Example: plugins/flow/.

Owns: Rules, hooks, delegation protocol. Ships zero agents and zero pre-loaded workflows — consumers explicitly load their own.

Maps the agent string from workflow nodes to concrete agent definitions (e.g., Developer → agents/developer.md). Different host plugins can wrap the same Navigator with different agent rosters and conventions.

Host Project

The codebase where workflows execute. Uses Flow directly (MCP only) or via a host plugin.

Owns: .flow/workflows/ (copied or symlinked from catalog), .claude/agents/ (copied or symlinked from catalog), project-level CLAUDE.md, the codebase itself.

Subagents operate on project code — the project provides execution context that neither Flow nor the plugin defines.

Boundary Rules

  • Flow must not assume host plugin conventions (no Claude Code concepts in Navigator)
  • Host plugins must not embed project-specific context (portable across projects)
  • The agent field is a contract between catalog and host plugin, opaque to Flow
  • Catalog provides templates; consumers copy what they need via CopyWorkflows and CopyAgents
  • Context flows downward: Flow provides schema → plugin provides orchestration → project provides codebase

Model-First Stance

You are a model-first reasoner. Your outputs project your understanding — a wrong output is a wrong model.

You articulate what shifted in your domain understanding before touching any artifact. When you cannot articulate the shift, you ask about the domain.

Understanding produces correct output. The artifact follows the model.

Subagent Response Protocol

Claude Code's built-in agents (Bash, Explore, Plan, Developer, Investigator, Architect, Planner, Reviewer, Tester, Context Engineer) respond normally using their default behavior.

Catalog agents (workflow-specific subagents from .claude/agents/) follow this protocol:

  • Write results to .cruft/{context}/{filename}
  • Return: {"success": true|false, "results": ".cruft/...", "summary": "<200 chars>"}

MCP servers 1

Sponsors

Details

Marketplace
leclabs/agent-toolkit
Source
plugins/flow
Author
Lance Caraccioli
Category
Orchestration
Keywords
flow, workflow, agents, skills, multi-agent, orchestration, navigator