Parallely CLI
CLI for parallel agents: splits a task into sections, runs Codex, Claude Code or OpenCode together and merges into one branch
- 118 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- Runs several coding agents at once; they write to the repository and commit automatically.
- Spends subscription or API tokens across several streams at once.
Install
- Works in
Manual install
bun install -g @michaelthemay/parallelyThe command from the Install from npm section. Installation goes through Bun.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- Runs several coding agents at once; they write to the repository and commit automatically.
- Spends subscription or API tokens across several streams at once.
This is third-party code. Review the repository files before installing.
What it does
Parallely treats a large feature the way a tech lead treats a sprint: it is broken into independent sections and each gets its own agent. The user defines the seams, meaning which files each section owns, and the tool checks for overlap. Then it runs agents concurrently in a shared git worktree and auto-commits changes onto one integration branch. Codex, Claude Code and OpenCode work as backends. A plan can be written by hand through `parallely init` (it creates `.parallely/plan/` with a template) or delegated to AI: `parallely plan "Build a REST API with auth, CRUD endpoints, and tests"`. The `parallely run` command launches the agents. A fullscreen interface shows progress, output and token spend for each agent, and the pipeline moves through parse, setup, forge, merge and done. A skill in `skill/SKILL.md` lets an agent drive it.
Who it is for. Developers who drive coding agents one at a time and want to speed up a big task with parallel sections.
Good fit when
- A feature splits into independent parts with clear file boundaries.
- You want one window showing what each agent does and how many tokens it spent.
- All agent output should land on one branch without manual merges.
- AI splits the task and you edit the finished plan.
Not a fit when
- Sections depend heavily on each other and change the same files.
- Codex, Claude Code or OpenCode is not installed.
- Each step needs real-time human review.
Example request
Split the REST API implementation into three sections for auth, CRUD and tests and run them in parallel through Claude Code.Limitations
The tool runs on the Bun runtime and installs with `bun install -g`; a plain npm install is not recommended (it needs the `--install-strategy=nested` strategy to avoid a multiple React runtimes error). Agents must be installed separately: Codex, Claude Code or OpenCode. Several agents write to a shared worktree at once and spend tokens of your subscription or API. Overlap detection protects section boundaries, but plan errors can still produce conflicts at the merge stage. The license is MIT.
How to disable. Remove the package with `bun remove -g @michaelthemay/parallely`. Delete branches, worktrees and the `.parallely/` folder in the project by hand.
FAQ
How do I install Parallely?
Run `bun install -g @michaelthemay/parallely`. Avoid npm, since the tool runs on Bun.
Which agents are supported?
Codex, Claude Code and OpenCode as backends. Install them beforehand, for example `npm install -g @anthropic-ai/claude-code`.
How do I create a plan?
With `parallely init`, or let AI write it through `parallely plan "<description>"`. Each section gets a file scope and acceptance criteria.
What happens to changes?
They are auto-committed to a shared integration branch within a shared git worktree.
What does the interface show?
Each agent's progress, its output and token spend, and the run summary.
Discussion
No questions or reviews yet.
Related
CLI toolsmulti-agents runs a team of coding agents on a task and measures whether it beat a single agent and what it cost.
An OpenCode plugin that runs a team of parallel agents with separate sessions, a shared task board and messaging
Run a cluster of agents in one repository: each gets its own worktree, a file claims board and messaging between agents.
A memory and coordination layer for coding agents: specs and issues live in git while agents work in parallel
The squads CLI runs teams of agents defined in markdown files in git: a lead briefs, workers act, a verifier checks.
A workspace for parallel Claude Code and Codex tasks, with separate Git worktrees, terminals and change review
README in short
A Bun project with a terminal interface. You define section boundaries and the tool enforces them and merges the result into one branch.
README badge
Original SKILL.md
# Parallely Plan Creation Skill You are creating an **Parallely execution plan** — a set of markdown files that will each be executed in parallel by an independent AI coding agent in its own git worktree. ## Output format Create a directory of numbered markdown files. Each file = one agent = one parallel task. ``` .parallely/plan/ ├── 01-section-name.md ├── 02-section-name.md ├── 03-section-name.md └── ... ``` ## File format Each `.md` file has YAML-like frontmatter and a markdown body: ```markdown --- title: Human-readable Section Title files: - src/path/to/files/** - src/specific-file.ts acceptance: - First acceptance criterion - Second acceptance criterion --- # Section Title Full implementation instructions here. Be specific and detailed. The agent will receive this as its complete prompt. ``` ### Frontmatter fields | Field | Required | Description | |-------|----------|-------------| | `title` | Yes | Short human-readable name | | `files` | Recommended | Glob patterns of files this section will touch (used for overlap detection) | | `acceptance` | Recommended | Concrete acceptance criteria | ### Body The markdown body is the agent's complete prompt. Include: - What to build/change and why - Technical approach and constraints