Skip to main content
plugin

parallax · ai4xe — Claude Code plugin: what it does, how to install

The parallax Claude Code plugin turns a wish into a plan with independent review. It discusses the task, hands it off for execution, then audits the result.

MIT ★ 136 updated 2026-11-16

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax
Open on GitHub

What parallax does

parallax guides a task from discussion through planning and a separate plan review to execution in a clean context and a follow-up audit. Start the flow with wish, Parallax, or qstart. Its other skills include qgo, bcheck, gclear, rcheck, and xwrap.

In solo mode, the current session does the work. In team mode, the orchestrator keeps the conversation while an executor runs in a separate session; this starts an additional headless process. After the audit, xwrap prepares a wrap-up and makes a scoped git commit. macOS compatibility has not been tested.

What it helps with

  • align task requirements through one question at a time
  • get an independent plan review before execution
  • hand work to a clean context
  • audit completion claims against the result
  • prepare a wrap-up and scoped git commit

Example prompts for the agent

  • Discuss this wish with me and ask one question at a time until the requirements are aligned.
  • Run /parallax:qstart and prepare a plan for independent review.
  • Hand off the plan for execution, then audit the result separately.

How to install parallax

Plugin marketplace

/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about parallax

How do I install parallax in Claude Code?

Run /plugin marketplace add AI4XE/Parallax, then run /plugin install parallax@parallax.

What does parallax do?

It manages a workflow from discussing a wish to task execution, an independent audit, and a final commit.

How do solo and team modes differ?

In solo, the current session executes the task. In team, the orchestrator keeps the conversation while a separate session handles execution.

Source text

SKILL.md · MIT
![Parallax](assets/banner.svg)

Parallax is a lightweight enhancement layer on top of your coding-agent harness. You own the goal; the agents own the work, context management, and independent acceptance.

Install Parallax, then just wish it. **Make it real.** Say what you want, make a few choices, hand it off — an agent team does the work under independent review and in a clean session, audits the result, and commits it clean.

[中文文档](README.zh-CN.md)

[![Claude Code](https://img.shields.io/badge/Claude_Code-Install-6B4FBB?logo=anthropic&logoColor=white)](#claude-code)
[![DeepSeek Harness](https://img.shields.io/badge/DeepSeek_Harness-Install-4D6BFE?logo=deepseek&logoColor=white)](#deepseek-harness)
[![VS Code Copilot](https://img.shields.io/badge/VS_Code_Copilot-Install-0098FF?logo=githubcopilot&logoColor=white)](https://marketplace.visualstudio.com/items?itemName=ai4e.parallax-github-copilot)
[![License](https://img.shields.io/github/license/AI4XE/Parallax)](LICENSE)
[![GitHub stars](https://img.shields.io/github/stars/AI4XE/Parallax)](https://github.com/AI4XE/Parallax)

## Three steps

> **Plugin trigger words**: `wish` · `Parallax` · `qstart`

1. **Wish** — say what you would like, as casually as you like. You do not need to have it figured out; add more in several messages and say "that's all" when you are done.
2. **Choose** — the agent researches first, then aligns with you one question at a time; you just pick.
3. **Hand off** — the agent team takes it from there: plan → independent review → new-session execution → independent audit → scoped commit → wrap-up.

> **Two modes**
> - **solo** (default): you work directly with the execution session; the current session is the executor. Suited to everyday use.
> - **team**: your conversation always stays with the orchestrator while the executor runs in its own session. Suited to large and very long tasks.

> **Automatic context management**
> - **At task start**: once the plan passes review, execution continues in a new session.
> - **Long-running tasks** (team tier): context is handed off automatically at about 60%, keeping the AI clear-headed with no interruption to the task.

https://github.com/user-attachments/assets/c85a9a89-2afa-44b0-a4f5-bf6db1db3001

## Platform support

- **Claude Code** — Linux ✓ · Windows (WSL) ✓ · macOS ?
- **DeepSeek Harness** — Linux ✓ · Windows ✓ · macOS ?
- **GitHub Copilot (VS Code)** — Windows ✓ · Linux ? · macOS ?. **Currently solo only.**

`?` means the code is written for compatibility and portability, but has not been actually tested; please open an issue with what you see.

## Install

### Claude Code

- **Option 1: Installer** (recommended):
  ```bash
  git clone https://github.com/AI4XE/Parallax.git
  bash Parallax/install.sh /path/to/your-project
  ```
- **Option 2: Manual copy**: copy each folder from `platforms/claude-code/skills/` into `<your-project>/.claude/skills/`.
- **Option 3: Claude Code plugin marketplace**: `/plugin marketplace add AI4XE/Parallax`, then `/plugin install parallax`. Slash commands get namespaced (`/parallax:qstart`); natural-language triggering (e.g. "qstart") still finds them.

**Note**: the team track starts an additional, separate headless executor process; the orchestrator manages and reclaims it.

> **Tip**: running Claude Code inside `tmux` together with a plugin is the most compatible setup; you can also use tools such as [cc-connect](https://github.com/chenhg5/cc-connect) to connect the session to a chat app for remote follow-up.

### DeepSeek Harness

- **Option 1: Plugin from npm** (preferred — no copying, re-run to upgrade):
  In the DSH web UI: **Plugins → Add plugin → enter `parallax-dsh`** (the plugin list can take ~30 s to load; choose the npm registry), install it, toggle the plugin **on**, then restart the profile. Or from the CLI:
  ```bash
  dsh plugin --profile <profile> add parallax-dsh
  ```
  Requires the Node runtime supplied by dsh and pnpm visible on the `dsh` process PATH (e.g. via corepack); restart the profile after installing. Remove with `dsh plugin --profile <profile> remove parallax-dsh`. **Zero extra setup**: the bundle registers the skills and the native handoff hook and applies `subagent.maxDepth: 3`; do not edit rules, profiles, patches or permission settings for handoff.
- **Option 2: Build the bundle from this repository**:
  ```bash
  git clone https://github.com/AI4XE/Parallax.git
  node Parallax/platforms/deepseek-harness/bundle/build.mjs
  dsh plugin --profile <profile> add "file:<absolute path to Parallax>/platforms/deepseek-harness/bundle"
  ```
  Windows can run both commands natively; quote paths containing spaces. The installed bundle behaves exactly like the npm install (full native handoff, zero extra setup).

Skills-only copying (`install.sh --platform deepseek-harness`) is **not a supported install**: it provides the skill text only, with no native handoff or team support.

**Note**: Parallax also runs under DeepSeek Harness's `workspace-write` permissions.

Then, in a DSH session with your project as the working directory, just say: `qstart` (or `wish` / `Parallax`).

### Copilot

- **Option 1: Marketplace** (recommended): search **Parallax for Copilot** in the VS Code Marketplace (publisher `ai4e`) and install it.
- **Option 2: Project install** via installer:
  ```bash
  git clone https://github.com/AI4XE/Parallax.git
  bash Parallax/install.sh --platform copilot /path/to/your-project
  ```
- **Option 3: Manual copy**: copy `platforms/copilot/{skills,agents,instructions}` into `.github/`. Do not overwrite an existing `copilot-instructions.md` — merge it.

**Note**:

1. On first run, run **Developer: Reload Window** once (skills and agents are discovered on reload).
2. Recommended: set the chat permission mode to **Allow all** (or Autopilot) — setting key `chat.defaultConfiguration` — so cross-session hand-off and subagent reviews run without approval prompts. The default Manual mode also works; you approve each tool type once per session.

## Skills

Parallax turns "please build this" into a self-advancing, self-reviewing loop:

| Skill | Role |
|---|---|
| **qstart** | Discussion entry: requirements → research → one-question-at-a-time alignment → complete overview. |
| **qgo** | Hand-off: re-checks the discussion, writes the plan, passes the **bcheck** gate (score ≥ 4/5), then a clean-context agent executes autonomously → **rcheck** audit → scoped commit. |
| **bcheck** | Independent adversarial review of the plan *before* execution. The doer never grades their own homework. |
| **gclear** | Saves a distilled brief and hands it to clean model context, with delivery verification; the platform adapter supplies the native mechanism. |
| **rcheck** | Independent reconciliation audit *after* execution: every "done" claim is verified against reality. |
| **xwrap** | Wrap-up: obvious-problem report, todo update, wrapup doc, smart scoped git commit. |
| **wish** | One-line wish entry (许愿创造 / 许愿编程) that forwards to **qstart**. |

One line: **qstart** (align the wish) → **qgo** (release; plan gated by bcheck → clean-context execution → rcheck audit → commit) → **xwrap** (wrap up).

Two collaboration modes: planning and execution live in different sessions and hand off automatically; **solo** has no orchestrator and the execution session carries the work to the end; in **team**, the execution stage is run jointly by the orchestrator and an independent executor. `ver` / `nover` select versioned vs non-versioned tasks.

How the hand-off works on each harness:

- **Claude Code**: `gclear` drives `/clear` and verifies the injection against the session transcript; the team track runs a headless stream-json executor in its own process, started and watched by the bundled driver. The CLI `tmux` requirement below still applies to `gclear`'s detached launcher.
- **DeepSeek Harness**: the full bundle provides `parallax_handoff`, which replaces model-visible history with a concise handoff at a native safe step. The SID, agent, append-only user transcript, Web tab/composer and child ownership stay intact, and work resumes automatically. In solo you keep talking directly to the executor; in team the original window stays the orchestrator and manages native child executors via `list_agents` / `send_message` / `interrupt_agent`. The bundle sets `subagent.maxDepth: 3`, so an executor can spawn its own independent reviewers.

## Tested versions

- Claude Code **2.1.322**, **2.1.140**
- DeepSeek Harness (dsh) **0.2.2-rc.1**
- VS Code **1.146.0** with bundled GitHub Copilot Chat **0.74.0**

## Philosophy

- **The harness is a key part.** Real quality comes from agent collaboration under harness constraints — not from a magic prompt.
- **Three steps, one hand-off.** Wish → choose → hand off. You own the goal and the boundaries; the agents execute, manage context, and independently verify and cross-review, so you steer instead of supervising every step.
- **The loop.** Input → analysis → plan → execution → acceptance → delivery. Every step gets independent review, scoring, and iteration — the one doing the work and the one checking are different entities with isolated contexts.
- **Three pillars**: phase isolation (strategy vs tactics) · adversarial acceptance (anti-sycophancy: the reviewer's job is to break it) · TDD (see it fail before you see it pass).

> **Name**: from Greek *parallaxis* — para- "beside" + allassein "to change". Viewed from beside, the position shifts: change the viewpoint and what you see changes. Self-review from inside cannot; an outside look can.

## Compatibility

- **Git**: recommended — the workflow uses Git roots, scoped commits, and hand-off checkpoints; `qstart` runs one cheap `git --version` during research and asks once whether to install it if missing (it does not block).
- **Claude Code**: Linux · macOS · Windows WSL. Bash 4+, Python ≥ 3.11 (stdlib only; no third-party packages), `tmux` for the CLI hand-off launcher.
- **DeepSeek Harness**: **Runtime uses only dsh's Node and injected native services** — no Python, Bash, zstd CLI, tmux or patched harness.
- **GitHub Copilot**: pure Markdown skills, zero runtime dependencies. Solo only.

## Configuration

Everything works with zero configuration. Optional knobs, each a tiny local file (kept across upgrades by the installer):

- `skills/bcheck/skill.conf`, `skills/rcheck/skill.conf` — `review_model=` : model for the independent review subagent. Empty = session default (never up- or down-shifted).
- Claude Code only: `skills/gclear/gclear.conf` — `MODEL_ALIASES=""` : space-separated `alias=full-id` pairs for `gclear --model`; plus timeout/retry tuning keys.
- Default reply language per skill (trigger-message language and spoken requests override it): Claude Code reads the `display_lang` frontmatter key; DeepSeek Harness reads `metadata.display_lang`.

## Upgrading

Re-run the installer (`bash install.sh [--platform <p>] <project>`) — it swaps skills atomically and keeps your local `*.conf` files. Claude Code plugin installs: `/plugin update parallax`. DeepSeek Harness bundle installs: re-run `node platforms/deepseek-harness/bundle/build.mjs`, then `dsh plugin --profile <profile> add "file:<bundle path>"` and restart that profile. Each skill versions itself in its `SKILL.md` frontmatter.

## Contact

Questions or feedback: open an issue or email [[email protected]](mailto:[email protected]).

---

MIT — see [LICENSE](LICENSE).

© AI4XE · MIT · AI4XE/Parallax

Similar plugins

All plugins for Agent setup: memory, context, orchestration →

parallax by other authors comes first.

parallax clomia The parallax plugin for Claude Code runs an advisor in an isolated context to find missed requirements and continue complex tasks until they are finished. ★ 14repo stars just-keep-swimming cyber-qais just-keep-swimming — a Claude Code plugin that runs multi-phase plans, coordinates parallel agents, and preserves a live board across context compression and sessions. ★ 5repo stars standup thedotmack standup is a Claude Code skill that compares Git worktrees, branches, or selected PRs through a shared agent discussion. It produces a consolidation plan without merging changes. CX Codex +1 3,800installs ai-team-orchestration official github ai-team-orchestration is a GitHub Copilot skill that coordinates project work across agents for planning, implementation, and optional QA. It activates when starting a project, dividing up work, or resuming a session from saved context. CX Codex +1 381installs grok-delegate amElnagdy The grok-delegate skill for Claude Code, Codex, and Cursor sends coding tasks to the Grok Build CLI. You review the resulting diff and decide what to commit. CX Codex +1 4,600installs ralplan Yeachan-Heo ralplan — a skill for iterative planning: Planner drafts a plan, Architect reviews architecture, Critic evaluates quality. The loop repeats until consensus is reached. CX Codex +1 1,300installs proletariat-cli chrismcdermut proletariat-cli wires the prlt orchestrator into your agent: tickets, boards, workspaces and several workers from one CLI. Useful once a single chat stops keeping up with the backlog. CX Codex +1 ★ 36repo stars

From the same set19

The whole set →
xwrap xwrap is a Claude Code skill that checks a repository, updates task lists, and records a development wrap-up. Invoke it with xwrap or wrap up. CX Codex +1 ★ 136repo stars rcheck This Claude Code skill reconciles a complex task’s implementation with its plan and summary. It runs after multi-step work, before the result is reported, or on an explicit rcheck request. CX Codex +1 ★ 136repo stars xwrap This Claude Code skill checks a repository, updates task tracking, and writes a wrap-up report. Invoke it with xwrap or a request to wrap up the task. CX Codex +1 ★ 136repo stars bcheck bcheck — a skill for Claude Code that independently reviews analyses and development plans. Run it after a document is prepared or when a review is requested. CX Codex +1 ★ 136repo stars bcheck This Claude Code and Codex skill sends analyses and plans for an independent review. It runs after a document is prepared, before the user gets a response, or when asked for bcheck. CX Codex +1 ★ 136repo stars bcheck The bcheck Claude Code skill independently reviews root-cause analyses and development plans. Run it after a document is ready and before reporting back, or when a plan review is requested. CX Codex +1 ★ 136repo stars qgo This Claude Code skill turns a task discussion into a plan and hands it to an autonomous executor. It starts on qgo or an explicit Q hand-off in the discussion. CX Codex +1 ★ 136repo stars qgo This Claude Code skill turns an agreed discussion into a reviewed plan and hands development to an autonomous executor. It starts when the user confirms the direction and says qgo or explicitly hands off the work. CX Codex +1 ★ 136repo stars

Project sponsors

Companies that keep this analytics open