@elyracode/swarm

Multi-agent swarm orchestration for Elyra. Automated pipelines where planner, coder, tester, and reviewer agents collaborate on a task with visual progress tracking.

Install

elyra install npm:@elyracode/swarm

Pipelines

Build (/swarm build <task>)

Full feature development pipeline:

plan -> code -> test -> review -> fix

1. Plan: Analyzes codebase, creates implementation plan with file paths
2. Code: Implements the plan, edits files
3. Test: Writes and runs tests for the implementation
4. Review: Reviews all changes for correctness, security, edge cases
5. Fix: Addresses review findings

Review (/swarm review <target>)

Deep multi-pass code review:

analyze -> correctness -> security -> tests -> synthesize

1. Analyze: Maps the code structure and data flow
2. Correctness: Reviews logic, error handling, edge cases
3. Security: Checks for vulnerabilities, input validation, auth issues
4. Tests: Evaluates test coverage and quality
5. Synthesize: Prioritizes all findings into actionable list

Refactor (/swarm refactor <target>)

Structured refactoring:

analyze -> plan -> implement -> verify

1. Analyze: Understands current structure, identifies issues
2. Plan: Creates refactoring plan preserving behavior
3. Implement: Executes the refactoring
4. Verify: Confirms behavior is preserved, no regressions

Usage

Commands

/swarm build add a notification system with email and in-app channels
/swarm review the authentication module
/swarm refactor the database query layer
/swarm --worktrees build add rate limiting to the API
/swarm          # lists available pipelines

Natural Language

Just describe what you want and mention "swarm":

Use swarm to build a REST API for user profiles
Run a swarm review on the checkout flow

How It Works

Each pipeline stage runs as a focused agent turn with specific instructions. Results from each stage are passed to the next as context. The agent sees a progress indicator showing which stage is active.

Stages marked as read-only (analyze, review, synthesize) cannot edit files. Only implementation stages (code, fix, implement) can write.

Worktree Mode

Add --worktrees (or pass worktrees=true to the swarm tool) to run every stage as an isolated sub-agent instead of inline turns:

• Each stage runs as its own elyra -p process inside a detached git worktree based on HEAD — your working tree is never touched while the swarm runs.
• Read-only stages are mechanically restricted to read,grep,find,ls tools, not just prompted.
• When all stages complete, the combined changes are checked for conflicts against files that changed in your working tree during the run. If clean, they are applied uncommitted so you can review them; if not, the worktree is kept and the conflicting paths are listed.
• On any failure the worktree is kept for inspection (git worktree remove --force <dir> to discard).
• Outside a git repository, worktree mode degrades gracefully to the classic inline mode.

Requirements: a git repository and the elyra CLI on PATH. Sub-agents start from HEAD, so uncommitted changes in your tree are not visible to them.