Repowire mesh usage skills: cross-agent review/plan, delegate, patterns, and install/update — backend-agnostic, parameterised on the agent you choose.

GitHub stars
276

Install

/plugin install repowire@repowire

Run it inside Claude Code after adding the marketplace with /plugin marketplace add prassanna-ravishankar/repowire.

Contents

Discovered from source

Skills 5

Cross-agent plan

Ask a peer running a different agent backend to draft (or critique) a plan, so the planning perspective is genuinely independent.

Resolve the planner backend

  1. Explicit argument — if the user named a backend, use it.
  2. Configured default — else:
    repowire config get skills.default_planner_backend
    
    (Empty output means unset.)
  3. Safe fallback — else pick an online peer on a backend different from yours, or ask the user. Never default to your own backend; never hardcode one.

Discover peers/backends: list_peers() (MCP) or repowire peer list (CLI).

Run the planning round

  1. Find (or, with the user's go-ahead, spawn — see delegate) a peer on the chosen backend.
  2. Send the task + constraints and ask for a concrete step-by-step plan.
    • MCP: ask(peer_name, "Draft an implementation plan for: <task + constraints>")
    • Tracked ask is MCP-only (no CLI lifecycle equivalent — repowire peer ask is a synchronous test utility, not this).
  3. ask returns a correlation_id; the peer replies via ack(corr_id, <plan>).
  4. Critique/merge the returned plan with your own; chain follow-ups with ask(reply_to=corr_id, ...).

Keep the brief tight — state the goal, the constraints, and what a good plan must cover, so the cross-agent plan is comparable to your own.

Cross-agent review

Ask a peer running a different agent backend to review your work, so the review is genuinely independent (not the same model checking itself).

Resolve the reviewer backend

Pick the reviewer in this order:

  1. Explicit argument — if the user named a backend (e.g. "review with codex"), use it.
  2. Configured default — else read it:
    repowire config get skills.default_reviewer_backend
    
    (Prints the value, or nothing if unset. --json for the raw value.)
  3. Safe fallback — if still unset, pick any online peer whose backend differs from yours, or ask the user which backend to use. Never default to your own backend — that defeats the purpose. Never hardcode a specific backend.

You can see who is available and on which backend:

  • MCP: list_peers()
  • CLI: repowire peer list

Run the review

  1. Find (or spawn) a peer on the chosen backend.
  2. Send it a review request with the concrete diff/PR/plan to review. Be specific about what to check.
    • MCP: ask(peer_name, "Review this diff for correctness + bugs: <context>")
    • The tracked ask/ack lifecycle is MCP-only — there's no CLI equivalent for a non-blocking ask (repowire peer ask is a synchronous test utility, not this).
  3. ask is non-blocking and returns a correlation_id. The reviewer closes the thread with ack(corr_id, <their review>) — that reply comes back to you.
  4. Apply the review; iterate with ask(reply_to=corr_id, ...) for follow-ups.

If no different-backend peer is available and the user wants one, spawn it (see the delegate skill) — but only with the user's go-ahead.

Delegate a task to a peer

Hand a self-contained task to a peer on a chosen backend and track it via the ask/ack lifecycle.

Resolve the delegate backend

  1. Explicit argument — if the user named a backend, use it.
  2. Configured default — else:
    repowire config get skills.default_delegate_backend
    
  3. Safe fallback — else ask the user which backend to delegate to. Don't hardcode one. (Unlike review/plan, delegation MAY target your own backend — delegating to another claude-code peer is legitimate.)

Choose / create the executor

  1. Prefer an existing peer on the chosen backend (idle if possible):
    • MCP: list_peers() → pick an online peer with the right backend.
    • CLI: repowire peer list.
  2. Spawn only if none exists AND the user is clearly delegating (don't spawn silently). Confirm before spawning:
    • MCP: spawn_peer(path, backend=<chosen>, circle=<skills.default_circle or current>)
    • CLI: repowire peer new ... Default circle: repowire config get skills.default_circle (else your current circle).

Hand off + track

  1. Send a complete, self-contained brief (the peer doesn't share your context):
    • MCP: ask(peer_name, "<full task brief + acceptance criteria>")
    • Tracked delegation is MCP-only (repowire peer ask is a synchronous test utility, not the ask/ack lifecycle). To close from the CLI: repowire peer ack <cid>.
  2. ask returns a correlation_id; the peer reports back via ack(corr_id, ...).
  3. Track to completion; chain follow-ups with ask(reply_to=corr_id, ...).

Use notify_peer (fire-and-forget) only for nudges, not for tracked delegation — delegation needs the ack lifecycle.

Install / update repowire + skills

Bring an agent session up to full repowire capability. This is an install/update helper run from inside an agent — it assumes you can run shell commands. (It is not a magical pre-install bootstrap; the repowire package provides the CLI/hooks.)

1. Ensure repowire is installed

repowire --version    # already installed?

If missing, install the CLI and set up hooks/MCP:

curl -sSfL https://raw.githubusercontent.com/prassanna-ravishankar/repowire/main/install.sh | sh
repowire setup                  # daemon, hooks, MCP, service (the supported path)

repowire setup is the source of truth for daemon/hook/MCP/service install — this skill never replaces it.

2. Install / update the skill pack

The skills live in the repowire repo under skills/. Install the set into your agent's skills directory with the skills CLI (works for any agent, not just Claude):

npx skills add prassanna-ravishankar/repowire        # scans skills/, installs the pack
# or a single skill:
npx skills add https://github.com/prassanna-ravishankar/repowire/tree/main/skills/cross-agent-review

Claude Code users can instead add the plugin marketplace:

/plugin marketplace add prassanna-ravishankar/repowire
/plugin install repowire@repowire

3. Set skill defaults (optional)

Skills resolve a backend as: explicit arg > config default > safe fallback. Set defaults in ~/.repowire/config.yaml:

skills:
  default_reviewer_backend: codex
  default_planner_backend: pi
  default_delegate_backend: codex
  default_circle: default

Read one back with repowire config get skills.default_reviewer_backend.

4. Verify

repowire peer whoami   # you're on the mesh
repowire peer list     # see other agents
repowire doctor        # health + drift checks

If peer whoami / peer list fail, run repowire setup and re-check — don't create an alternate local mesh.

Repowire usage patterns

Repowire is a mesh where AI coding agents (Claude Code, Codex, OpenCode, Pi, …) each get an address and talk to each other. This is a teaching reference; the action skills (cross-agent-review, cross-agent-plan, delegate) apply these patterns. It does not depend on those skills being installed.

Pick the right primitive

WantUseLifecycle
Tracked request that needs a replyask(peer, text) → peer ack(corr_id, reply)Non-blocking; returns correlation_id; reopen with ask(reply_to=...)
Fire-and-forget nudge / statusnotify_peer(peer, text)No reply expected
Message everyone in your circlebroadcast(text)No per-peer lifecycle
Close an inbound askack(corr_id) bare, or ack(corr_id, reply)The only close/reply op for an ask
See who's aroundlist_peers()Returns names, backends, status
Who am Iwhoami()Your peer identity/circle

The tracked ask/ack/notify/broadcast lifecycle is MCP-only — use the mcp__repowire__* tools. There is no honest CLI equivalent for non-blocking ask (the repowire peer ask command is a synchronous testing utility, not the ask/ack lifecycle). For agents without MCP, the CLI offers these real fallbacks: repowire peer list, repowire peer whoami, repowire peer ack <cid>, repowire peer asks (list pending), repowire peer new (spawn).

Rules that bite

  • ask is non-blocking — it returns a correlation_id, not a reply. The reply arrives later as an ack. Don't wait synchronously.
  • ack is the only way to close an inbound ask. Bare ack(corr_id) = "seen, no action"; ack(corr_id, msg) = reply. Unacked asks resurface as reminders.
  • Identity is peer_id; addressing is display_name. Names can collide; pass circle to disambiguate.
  • Cross-agent means a different backend. For an independent review/plan, target a peer whose backend differs from yours (see cross-agent-review/cross-agent-plan).
  • Spawn deliberately. spawn_peer starts a new agent; confirm with the user rather than spawning silently.

Cross-agent workflows

  • Independent review: cross-agent-review (have a different backend review your work).
  • Independent planning: cross-agent-plan.
  • Offload work: delegate (reuse or spawn a peer, hand off, track via ack).

Backends for these are parameterised via repowire config get skills.* defaults, overridable per call — never hardcode a backend.

Sponsors

Details

Marketplace
prassanna-ravishankar/repowire
Source
.
Category
Community

More from prassanna-ravishankar/repowire

All 2