Each developer runs Claude Code or Codex in their own clone. Pulse coordinates work through shared claims, dependencies and planned files, then takes each item through tests, review and security audit to integration. Regular checked results complete automatically; manual final approval is an option.
pulse map. The agent walks you through structured discovery: who the users are, what job they need done, which assumptions could sink the idea. 34 innovation methods are at hand before a single line of code.
Run your first business analysis →Pulse reads the code and writes down what it finds: the decisions already made, the features already there, each with its source. Projects on the Digital Innovation Agents plugin, the predecessor of Pulse, move over the same way.
Run /pulse-realign →Alice starts pulse go on her laptop. Bob starts it in his clone on another machine. Both runners use the same board: they claim items, start agents in separate worktrees, and compare planned files with the work the team already holds. Each person has their own agent slots, permissions, and subscriptions.
Work becomes visible during scoping: /pulse-ba and /pulse-re register drafts before implementation starts. Specs and Plans live on item branches. GitHub hosts the item board and a shared Git branch for confirmed claims and progress. Local actions are saved before background synchronization, with no additional coordination service for your team to operate.
The map shows each person's items, runner phases, and last heartbeat. Detailed tool activity stays in the local clone. Shared revisions serialize competing claims. Planned file reservations reduce overlap, but actual changes can still conflict. Parallel work explains those boundaries and how to hand work over.
| Part | What it gives you |
|---|---|
| Operating model | A rhythm for teams where each person works with several agents: three tempos (hourly, daily, every two weeks), a conscious filter that decides what becomes work, roles as hats. |
| Collaboration | A shared board across people and machines, an ordered queue, pulse go to run local agents against it, and pulse map to see the team's work. |
| Digital Innovation Agents | The method: one command per step from a raw idea to reviewed code. Business analysis, requirements, plan, build with the spec tests first, review, security audit. |
Pulse runs in Claude Code and Codex, in the terminal and in the VS Code extension; support for GitHub Copilot will follow. You need Python 3.9 or newer, the GitHub CLI gh 2.94 or newer, and a GitHub repository. In Claude Code:
claude plugin marketplace add https://github.com/pssah4/pulse.git
claude plugin install pulse@pssah4-skillsIn the Codex CLI:
codex plugin marketplace add pssah4/pulse
codex plugin add pulse@pssah4-skillsThen run /pulse in your project (in Codex, trust the Pulse hooks when Codex asks at its first start, under /hooks in the CLI or one by one on the Hooks page of the IDE extension's settings, and call it $pulse:pulse): it sets Pulse up where it is missing and says what comes next. The VS Code extensions, updates, and removal: Installation.
Business analyses, epics, features and Plans are Markdown files versioned with the code. Each item keeps its spec, Plan and implementation on one published branch. Valid specs permit planning; valid Plans permit building when dependencies and file reservations allow it. Existing Plans and unfinished work are preserved when a run resumes.
The pulse commands manage the shared state; nobody edits it by hand. pulse status --json reads a local view. GitHub holds the item catalog and relationships; a shared Git branch holds claims, results and integration state. Local actions enter a durable outbox and gain team authority only after synchronization confirms them. Pulse closes an item after proving its result reached the shared base. Where things live has the details.
Pulse uses GitHub for item types and relationships. Shared Pulse state coordinates who may write and what may integrate when several people each run several agents on one repository.
| Step | What happens |
|---|---|
| Register | Draft records expose analysis and specification work before code is written |
| Select | The ordered queue considers published specs and Plans, dependencies and files already reserved by the team |
| Execute | Each person's runner claims items and starts Claude Code or Codex in local worktrees |
| Verify | The runner executes project tests, review and security audit, then publishes the checked result |
| Integrate | Final approval binds the exact result and base, automatically by default or under a chosen manual policy; Pulse merges with project hooks |
Pulse fits teams that want this workflow across their own machines and are willing to maintain specs and plans. For one person working on one item at a time, issues and branches may be enough. For messaging, shared infrastructure leases, or a configurable skill pipeline, other tools may fit better. Choosing a coordination tool compares those uses with sources and a review date.
The steps run forward within the authorized task and loop back when the work teaches something new. A red gate gets one fix round, followed by tests. Green review or audit evidence may carry to a new commit only when its Git tree is identical; changed contents require both checks again. pulse go processes the queue. Add a free-text objective directly, such as pulse go finish Epic 4 and investigate the UI problem, to add that work through the same visible item workflow. Explicit scope restrictions bound the run. A start without a terminal uses a managed process. Regular checked results integrate automatically by default; a person may select manual final approval of the exact head and base. Each command has a guide; /pulse tells you where you stand and what comes next.
pulse status instead of reading a backlog file.