PACT Plugin
A Claude Code plugin: an orchestrator and 12 specialists run Prepare, Architect, Code, Test with memory and a session journal
- 73 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The plugin runs several agents with permission to write files and run commands and asks to broaden permissions on directories under ~/.claude
- A multi-agent process spends noticeably more tokens than a regular session
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add plugins/pact-pluginDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The plugin runs several agents with permission to write files and run commands and asks to broaden permissions on directories under ~/.claude
- A multi-agent process spends noticeably more tokens than a regular session
This is third-party code. Review the repository files before installing.
What it does
PACT turns one Claude Code session into a team of specialists. An orchestrator and twelve agents (researcher, architect, backend and frontend coders, database and DevOps engineers, auditor, tester and others) go through the Prepare, Architect, Code, Test cycle. Each specialist gets a fresh context window. This uses the experimental Claude Code Agent Teams, which must be enabled in `settings.json`. The `/PACT:orchestrate` command runs the full process for a new feature, and `/PACT:comPACT` drives one specialist for quick fixes, for example `/PACT:comPACT backend Fix the authentication bug`. Other commands are `/PACT:plan-mode` without code, `/PACT:rePACT` for a nested cycle, `/PACT:imPACT` for a blocker and `/PACT:peer-review` for commit and review. The auditor runs alongside coders and follows `git diff` without messaging them, to catch architecture drift before testing. Memory is a local SQLite database with vector embeddings and links, and decisions and lessons persist across sessions. The session journal records every phase, handoff and commit and survives context compaction and task garbage collection. Task complexity is scored on novelty, scope, uncertainty and cost of error, and simple ones get a light process. Irreversible actions such as merge and force push require a question through `AskUserQuestion`. `/PACT:telegram-setup` enables Telegram notifications and replies.
Who it is for. Developers on Claude Code who need a structured process for complex features with research, design, code and tests instead of one long session.
Good fit when
- A new feature, for example JWT authentication, needs research, architecture, implementation and tests in turn
- Context gets lost mid-task and you want memory across sessions and a journal that survives compaction
- A small database or frontend fix should go to one specialist without the full process
- Before merging you want review by several agents and confirmation of irreversible actions
Not a fit when
- You need one short edit in one file: a multi-agent process spends many tokens
- Agent Teams cannot be enabled in your environment: without them the plugin does not spawn specialists
- You need to work on Windows: support is stated only for macOS and Linux
Example request
/PACT:orchestrate Build user authentication with JWTLimitations
It needs Claude Code, enabled Agent Teams (`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` and `CLAUDE_CODE_ENABLE_TODO_TOOLS` in the `env` of `settings.json`), Python 3.12 or newer for memory and hooks, and macOS or Linux. Windows support is not stated yet. Agent Teams in Claude Code are experimental and have known limits around session resumption and shutdown.
The plugin asks for broader permissions on the `~/.claude/teams`, `~/.claude/pact-sessions` and `~/.claude/agent-memory` directories. Each specialist works in its own context, and the full process costs noticeably more tokens than a regular session. The last commit is from November 10, 2026 and the license is MIT.
How to disable. Run `/plugin uninstall PACT@pact-plugin`, remove `"agent": "PACT:pact-orchestrator"` from the project `.claude/settings.json` and the `pact` symlink from your PATH. Delete the Agent Teams permissions and variables from `settings.json` by hand, and the `~/.claude/pact-memory` and `~/.claude/pact-sessions` directories too.
FAQ
How do I install PACT in Claude Code?
First enable Agent Teams in the `env` of `settings.json`, then run `/plugin marketplace add Synaptic-Labs-AI/PACT-Plugin` and `/plugin install PACT@pact-plugin`. Then set up the orchestrator by copying `CLAUDE.md` from the plugin cache.
What does PACT stand for?
It is the Prepare, Architect, Code, Test cycle: research, design, implementation and testing. Specialists go through it in turn, and task complexity sets the depth of the process.
How do I start a session with the orchestrator right away?
With `claude --agent PACT:pact-orchestrator` or an `"agent": "PACT:pact-orchestrator"` entry in the project `.claude/settings.json`. For a global launch there is the `pact-plugin/bin/pact` script, linked into PATH.
When do I use comPACT and when orchestrate?
`/PACT:comPACT` suits quick fixes by one specialist, for example `/PACT:comPACT database Add index to users.email column`. New features and complex tasks need `/PACT:orchestrate`.
What if specialists will not spawn?
Check that both variables are set in `env`: without Agent Teams the commands cannot create specialists, and without the task tools the spawn is blocked with a separate error. The plugin README has a section on it.
Discussion
No questions or reviews yet.
Related
PluginsMulti-agent orchestration for Claude Code: teams, roles, autopilot and task routing across skills and subagents
A Claude Code plugin that hands coding tasks to Codex agents, monitors them and verifies the results independently
Workflows for Claude Code: /do, /omo, /bmad-pilot and more commands, with Codex, Gemini or OpenCode writing the code through codeagent-wrapper
claude-mods adds 112 skills, 3 agents and 3 commands to Claude Code: stacks, agent operation, defense, session continuity.
A collection of 14 portable skills for long agent runs: work planning, live app QA, search across past sessions and a phone call
An operating layer for Claude Code and Codex: one /do entry point, project memory across sessions, safety hooks, cost telemetry and parallel agents
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| PACT Plugin (this card) | no | 73 | |
| BMad Method | no | 55,338 | a method of roles with document templates, while this one runs specialists as Agent Teams with memory and a session journal |
| AI Agents Orchestrator | no | 101 | an orchestrator for a set of agents, while this one adds the PACT cycle, concurrent audit and confirmation of irreversible actions |
README in short
The description presents PACT as a fix for chaotic coding: research and planning come before code and each agent has a fresh context. It then covers installation, enabling Agent Teams, the command table, memory and journal features and the orchestrator safety and integrity principles.