Stream Chain
Chain multiple agent prompts so each step’s stream output feeds the next for analysis, codegen prep, or repeatable multi-agent pipelines.
Overview
Stream-Chain is an agent skill most often used in Build (also Ship review, Operate iteration) that chains Claude Flow stream-JSON steps so multi-agent pipelines run sequentially with prior output as context.
Install
npx skills add https://github.com/ruvnet/ruflo --skill stream-chainWhat is this skill?
- Two modes: custom `run` chains (min 2 prompts) and predefined `pipeline` recipes such as `analysis`
- Sequential stream-JSON flow—each step receives the full prior step output for multi-agent handoffs
- CLI entry: `claude-flow stream-chain run` and `claude-flow stream-chain pipeline`
- Supports data transformation and sequential workflows across distributed cognitive steps
- Battle-tested pipeline shortcuts for common agent analysis workflows
- Minimum 2 prompts required for custom `run` chains
- Two orchestration modes: custom `run` and predefined `pipeline`
Adoption & trust: 645 installs on skills.sh; 58.5k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You need several agent passes in order but copying streamed output between prompts by hand breaks flow and drops context.
Who is it for?
Indie builders using claude-flow who run repeatable multi-agent analysis or transformation chains from the terminal.
Skip if: Single-prompt tasks, teams not on Claude Flow, or workflows that need parallel agents instead of strict sequential chaining.
When should I use this skill?
You need multi-step stream-JSON agent pipelines, sequential data transformation, or predefined analysis workflows via claude-flow.
What do I get? / Deliverables
You get a finished multi-step agent run where each prompt executed in sequence with chained context, ready to act on the last step’s output or drop into a follow-on skill.
- Chained stream output from the final pipeline step
- Completed predefined or custom multi-agent run
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build because stream-chain wires Claude Flow agents into sequential pipelines—the core job is assembling agent tooling during product development. agent-tooling fits orchestration CLIs that connect agents, not shipping a single UI or API surface.
Where it fits
Chain structure analysis → improvement list → action plan while scaffolding a new repo.
Run the analysis pipeline before tagging a release to surface risky areas.
Re-execute a custom chain after incidents to regenerate prioritized fix plans.
How it compares
Orchestration skill for sequential agent streams—not a generic MCP server or one-shot code generator.
Common Questions / FAQ
Who is stream-chain for?
Solo and indie builders on Claude Flow who want multi-step agent pipelines without manual copy-paste between prompts.
When should I use stream-chain?
During Build when wiring agent tooling, during Ship when running analysis pipelines before release, and during Operate when re-running structured improvement chains on a living codebase.
Is stream-chain safe to install?
Review the Security Audits panel on this Prism page and the upstream ruflo repo license before running chained prompts that may invoke shell or network tools in your environment.
SKILL.md
READMESKILL.md - Stream Chain
# Stream-Chain Skill Execute sophisticated multi-step workflows where each agent's output flows into the next, enabling complex data transformations and sequential processing pipelines. ## Overview Stream-Chain provides two powerful modes for orchestrating multi-agent workflows: 1. **Custom Chains** (`run`): Execute custom prompt sequences with full control 2. **Predefined Pipelines** (`pipeline`): Use battle-tested workflows for common tasks Each step in a chain receives the complete output from the previous step, enabling sophisticated multi-agent coordination through streaming data flow. --- ## Quick Start ### Run a Custom Chain ```bash claude-flow stream-chain run \ "Analyze codebase structure" \ "Identify improvement areas" \ "Generate action plan" ``` ### Execute a Pipeline ```bash claude-flow stream-chain pipeline analysis ``` --- ## Custom Chains (`run`) Execute custom stream chains with your own prompts for maximum flexibility. ### Syntax ```bash claude-flow stream-chain run <prompt1> <prompt2> [...] [options] ``` **Requirements:** - Minimum 2 prompts required - Each prompt becomes a step in the chain - Output flows sequentially through all steps ### Options | Option | Description | Default | |--------|-------------|---------| | `--verbose` | Show detailed execution information | `false` | | `--timeout <seconds>` | Timeout per step | `30` | | `--debug` | Enable debug mode with full logging | `false` | ### How Context Flows Each step receives the previous output as context: ``` Step 1: "Write a sorting function" Output: [function implementation] Step 2 receives: "Previous step output: [function implementation] Next task: Add comprehensive tests" Step 3 receives: "Previous steps output: [function + tests] Next task: Optimize performance" ``` ### Examples #### Basic Development Chain ```bash claude-flow stream-chain run \ "Write a user authentication function" \ "Add input validation and error handling" \ "Create unit tests with edge cases" ``` #### Security Audit Workflow ```bash claude-flow stream-chain run \ "Analyze authentication system for vulnerabilities" \ "Identify and categorize security issues by severity" \ "Propose fixes with implementation priority" \ "Generate security test cases" \ --timeout 45 \ --verbose ``` #### Code Refactoring Chain ```bash claude-flow stream-chain run \ "Identify code smells in src/ directory" \ "Create refactoring plan with specific changes" \ "Apply refactoring to top 3 priority items" \ "Verify refactored code maintains behavior" \ --debug ``` #### Data Processing Pipeline ```bash claude-flow stream-chain run \ "Extract data from API responses" \ "Transform data into normalized format" \ "Validate data against schema" \ "Generate data quality report" ``` --- ## Predefined Pipelines (`pipeline`) Execute battle-tested workflows optimized for common development tasks. ### Syntax ```bash claude-flow stream-chain pipeline <type> [options] ``` ### Available Pipelines #### 1. Analysis Pipeline Comprehensive codebase analysis and improvement identification. ```bash claude-flow stream-chain pipeline analysis ``` **Workflow Steps:** 1. **Structure Analysis**: Map directory structure and identify components 2. **Issue Detection**: Find potential improvements and problems 3. **Recommendations**: Generate actionable improvement report **Use Cases:** - New codebase onboarding - Technical debt assessment - Architecture review - Code quality audits #### 2. Refactor Pipeline Systematic code refactoring with prioritization. ```bash claude-flow stream-chain pipeline refactor ``` **Workflow Steps:** 1. **Candidate Identification**: Find code needing refactoring 2. **Prior