Lets the coding agents you already run in different repos, such as Claude Code, Codex and OpenCode, message each other directly, so you stop copy-pasting answers between sessions. You can also ask an agent a question, delegate a task, or check its status from a browser or phone.
Auto-invoked ships a router so the right skill fires automatically as you prompt. No remembering which skill to call.
Normal is the plain upstream plugin, installed as-is. You invoke its skills yourself.
Claude Code
The plugin> /plugin marketplace add prassanna-ravishankar/repowire> /plugin install repowire@repowireAuto-invocation> /plugin marketplace add flowy-sh/flowy-core> /plugin install flowy-core> /plugin install flowy-repowire
Codex
$ npx skills add prassanna-ravishankar/repowire --skill integration-test cross-agent-plan cross-agent-review delegate talk-to-agents repowire-install repowire-patterns -a codex
Cursor
$ npx skills add prassanna-ravishankar/repowire --skill integration-test cross-agent-plan cross-agent-review delegate talk-to-agents repowire-install repowire-patterns -a cursor
Gemini CLI
$ npx skills add prassanna-ravishankar/repowire --skill integration-test cross-agent-plan cross-agent-review delegate talk-to-agents repowire-install repowire-patterns -a gemini-cli
GitHub Copilot
$ copilot plugin marketplace add prassanna-ravishankar/repowire$ copilot plugin install repowire@repowire
OpenCode
$ npx skills add prassanna-ravishankar/repowire --skill integration-test cross-agent-plan cross-agent-review delegate talk-to-agents repowire-install repowire-patterns -a opencode
Windsurf
$ npx skills add prassanna-ravishankar/repowire --skill integration-test cross-agent-plan cross-agent-review delegate talk-to-agents repowire-install repowire-patterns -a windsurf
Repowire connects the coding agents you already have open. Claude Code in one repo, Codex in another, a dashboard in your browser, Telegram on your phone: Repowire gives them names and lets them pass messages without copy-paste.
It is a local control layer for multi-agent work: ask another agent a question, send a quick update, schedule a reminder, or run one session as the coordinator.
Use it when:
Repowire runs locally by default through a daemon on your machine. The hosted relay is optional and uses outbound connections for remote dashboard and remote MCP access.
Requirements: macOS or Linux. Tmux is required for the default Claude Code workflow and Repowire-managed spawning/lifecycle, but not for pane-less Codex, OpenCode, or Pi connections. Python is not required.
1. Install Repowire and wire your agents.
brew install prassanna-ravishankar/repowire/repowire
repowire setup
Or use the checksum-verified native installer:
curl -fsSL https://github.com/prassanna-ravishankar/repowire/releases/latest/download/install.sh | sh
The installer downloads a checksum-verified native binary from GitHub Releases.
2. Open your normal agent CLIs.
Use the tools directly; Repowire hooks into them after setup.
# tmux window 1
cd ~/projects/project-a && claude
# tmux window 2
cd ~/projects/project-b && codex
3. Check that both peers appeared.
Claude Code registers on session start. Codex registers through App Server when its TUI thread opens, before the first prompt. Run:
repowire peer list
4. Ask from one agent to the other.
In project-a, tell your local agent:
Ask project-b what API endpoints they expose.
Your local agent invokes Repowire's ask MCP tool, the second agent receives the question, and the reply comes back as an ack notification. Repowire is the mesh and tool surface around the agents, not a standalone chat UI. The same pattern works across Claude Code, Codex, OpenCode, and Pi when those runtimes are installed.
You can also spawn peers through Repowire:
repowire peer new ~/projects/project-a
repowire peer new ~/projects/project-b --backend codex --profile fast
For durable recurring workers, scaffold a repo-local agent folder and target it from jobs:
repowire agents create daily-brief --backend codex
repowire jobs create "Daily brief" --path .repowire/agents/daily-brief --backend codex --cron "@daily" --prompt "Prepare the brief."
Reach your sessions remotely from Claude or ChatGPT.
Enable the relay. Your relay secret is written to ~/.repowire/config.yaml under relay.api_key.
repowire setup --relay
In Claude Code, install the remote plugin, then authenticate it in /mcp:
/plugin marketplace add prassanna-ravishankar/repowire
/plugin install repowire-remote@repowire
In Claude.ai, ChatGPT, or another remote MCP client, add https://relay.repowire.io/mcp as a custom connector with OAuth. Enter the relay secret on the relay's consent page; the client gets its own scoped credentials, never the secret.
Then, from the remote chat:
Which of my agents are online? Ask project-b what API endpoints they expose and show me the reply.
The client finds the agent with list_agents, sends the question with ask_agent, and collects the answer with get_reply. See Relay MCP for scopes, expiry, and limits.
Full docs: docs.repowire.io.
ack replies and reminder injection until a thread is closed.repowire inbox.Repowire-Thread and Repowire-Session trailers; repowire why replays the conversations behind a commit.All peers connect to a local daemon. The daemon keeps the registry, routes asks/notifies, tracks open asks, stores durable jobs, runs schedules, and feeds the dashboard timeline.
The stable public surface is peers, circles, asks, notifications, broadcasts, schedules, and the /jobs tracked-work API exposed through CLI and MCP JSON tools. The v0.14 direction is session-native: sessions become the durable unit of work, while peers remain the live runtime executors. The current dashboard shows the selected peer/session view, merges Claude transcript history where available with realtime events, and is moving toward broader session commands for controls like resume, scheduling, approvals, and future backend/model changes.
Transport notes:
| Agent runtime | Connection path |
|---|---|
| Claude Code | Hooks + MCP + native session inbox; optional experimental channel/ACP |
| Codex | App Server threads + MCP |
| OpenCode | Plugin + WebSocket |
| Pi | Native Repowire extension + WebSocket |
| Human or service surface | Role in the mesh |
|---|---|
| Dashboard | Browser control surface at localhost:8377/dashboard or through relay |
| Telegram | Phone control surface and notification target |
| Slack | Team chat control surface |
| Orchestrator peer | Long-running coordinator that dispatches and reviews work |
| Relay dashboard | Optional remote dashboard and remote MCP access |
repowire setup auto-detects installed runtimes and wires the supported transports it finds.
The agent-orchestration space is moving fast. Most projects cluster around a few shapes:
Repowire sits in a different slot: it is a live mesh and control plane for agent sessions you already have running. It does not try to be the scheduler that decomposes every goal, the kanban board that owns every branch, or the merge gate that lands code. It gives your existing terminals, dashboard, Telegram, Slack, and orchestrator session a shared address book, message lifecycle, schedule queue, and local session timeline.
Project A needs the real API shape from Project B. Ask project-b; the peer answers from its live checkout, not stale docs. See multi-repo coordination.
Send work to a peer from Telegram, Slack, or the dashboard, then receive progress updates from agents as notifications. Telegram and Slack human messages open tracked asks by default; use their notify/FYI commands for fire-and-forget nudges. See mobile mesh management.
Run one session as the orchestrator. It can dispatch to project peers, ask for status, review PRs, and wake itself later. See orchestrator coordination.
Schedule a reminder, check-in, or future ask:
repowire schedule self 10m "check CI"
repowire schedule create orchestrator 1h "handoff" --from-peer project-a --kind ask
Claude Code commits made through Repowire record the ask threads they closed as git trailers. Replay them:
repowire why # HEAD
repowire why abc1234 # any commit
Enable the hosted relay when you want remote dashboard or remote MCP access to a machine's agents. Agents on different machines do not message each other:
repowire setup --relay
Stars on GitHub
A development methodology for coding agents that makes the agent brainstorm before building, follow plans, run parallel work and finish branches in a disciplined way. You get fewer skipped steps and more consistent results from your coding assistant.
@obraHelps you take a change from a rough idea or bug report through to a tested, reviewed result, with each step handled by a focused skill. Its skills cover pinning down domain terms, designing module interfaces, diagnosing hard bugs, and reviewing changes against your repo's coding standards.
@mattpocockGives your coding agent a planning, testing and review routine to follow on every task. It plans before building, checks changes with tests, has a fresh reviewer look for regressions, and saves repeated wins as reusable skills.
@affaan-mDeveloper tools for working on the React codebase itself. Provides skills for extracting error messages, managing and debugging feature flags across release channels, running Flow type checks, and fixing lint and formatting issues before committing.
@facebookInstall it once and the right skill fires as you prompt, with no slash command to remember. It is listed on Flowy in the Development category. It includes integration-test, cross-agent-plan, cross-agent-review. Free and open source.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it