Your AI does the work.
You make the calls.
PaiR ships a CLI and integrated terminals. Your AI agents use them to create, update, and close issues while you watch - live.
Launch agents, monitor sessions, get notified when they need you.
One install, everything included - CLI + desktop app + integrated terminals.
Your data stays on your machine. No account, no cloud.
Works with any AI agent - Claude Code, Codex, Gemini CLI...
A desktop app for developers who use AI coding assistants.
Whether it's your first AI session or several agents running in parallel, PaiR keeps you in the loop: the agent proposes, you decide, it works in the open - and it reminds you to take care of yourself.
The transition to AI autonomy should be progressive. Start with pair programming: one human, one AI, full visibility. As trust builds, delegate more. PaiR grows with you: from your first prompt to multi-agent orchestration, you always see what's going on and stay in control. The agent proposes, you decide; it works in real terminals you can watch, and checks in before anything that matters.
- An epic and its tasks, ready to go
- One command starts a supervised team
- Supervisor: your single point of contact
- Coder: implements the ticket
- Every agent runs in its own terminal
- Every step tracked, every decision logged
- Review: an independent check of the code
- Review is testing and checking the code
- Codex joins, even from another vendor
- Docs aligned, nothing committed yet
- Codex asks the supervisor directly
- Ready to merge: you have the final word
- You approve: the supervisor commits and closes
Why PaiR?
Bugs, features, tasks, specs, campaigns, down to the ideas you want to keep: everything in one place. Your second brain as a developer. PaiR centralizes your work, syncs with GitHub and GitLab, and tracks what your AI agents are doing in real time.
An open CLI - your integration point
The pair CLI is the engine. AI agents use it, but so can your scripts. Connect Redmine, Jira, or any tool in your workflow - a few lines of scripting is all it takes. Hooks, real-time events, and AGENTS.md give AI agents full autonomy out of the box.
Grows with you
Start simple: one agent, one issue, full visibility. As you get comfortable, monitor multiple sessions and cable your agents together so they message each other across codebases. And when you want to go further, an early-preview orchestration engine lets a team of agents (coder, reviewer, supervisor) hand off a single issue automatically while you keep the final say on the merge. PaiR scales from your first prompt to full orchestration, at your own pace.
Long-term memory
Not just an issue tracker: your tasks, bugs, specs and campaigns live here, along with the ideas and reflections you want to keep. Your agent's own memory lasts a session; PaiR consolidates it all for the long run, a durable through-line for you and your agents to pick the thread back up with full context.
Local-first, your space
Your own workspace - bugs you found, ideas you had, tasks you're exploring - all private, all local. No account, no cloud, no telemetry. Sync with your team's GitHub or GitLab when you're ready to share.
Git-synced
Issues live in your repo as JSONL, synced by git on their own orphan branch: switch branches, your tickets stay the same. Every team member and every AI agent sees the same state. No external database to manage.
A journey of discovery with AI
This timeline traces how I came to grips with working alongside AI agents since January 2026, and how PaiR grew out of it. It is just one path among many: if you recognize yourself in it, or if it inspires you, it has done its job.
January 2026
The spark
The spark comes from Beads, by Steve Yegge: a local issue tracker designed to be read and written by AI agents rather than living in a centralized tool. I build an app around it, and a month of very fast iterations teaches me what an agent really needs.
Late February 2026
Starting over
The limits show (one project at a time, no real-time updates), and above all I no longer want to chase a third-party tool's updates. PaiR is born with its own engine and CLI: a self-contained environment that moves at my own pace.
March 2026
The terminal moves into the app
Agents no longer run next to the tool but inside it. Several projects open side by side, each with its own sessions.
April 2026
Issues follow the code
Tracking lives in the git repository, on its own branch: it travels with the project and is shared like it.
May - July 2026
Working together
PaiR instances discover each other on the local network, pair up and exchange messages.
August 2026
Sessions talk to each other
A cable links two agent sessions, and one can call on the other. The agents I build PaiR with now use them to coordinate with each other.
September 2026
Orchestrate, then consolidate
A first multi-agent orchestration (experimental preview), and an opening to agents beyond Claude. Then time to consolidate: an audit, and a refactoring that strengthens security and refines the architecture, so the next ideas find their place instead of making the code grow without a plan.
Today
An everyday tool
Eight months later, a product built with method, and a tool I use every day that keeps evolving along with my professional projects, to serve them better.
Features
Everything you need to manage issues with AI, right from your machine.
Multi-project dashboard
Aggregate issues from all your projects in a single window with real-time updates.
Built-in CLI
Create, update, close issues, manage dependencies, labels, and comments from the terminal.
A ready-made harness
PaiR ships its own harness for Claude Code: slash commands to create, run, review, commit and close an issue, plus a quality audit. The Python scripts behind them run the tests, the build and the closing steps outside the model, and work with any agent: it spends its tokens on the work, not the plumbing. Installed with PaiR, set up by the agent on first use (requires Python).
AI-native
Claude Code, Codex, Mistral or others: your agents talk to each other through a shared channel, even from a sandbox. Agents with hooks also show their activity live, with attention alerts and an events panel.
Integrated terminals
Launch an AI agent straight from an issue and watch it work in a real terminal. Run several sessions per project in split view, with visual and sound notifications that pull you back exactly when the agent needs you. Optional tmux mode for persistent sessions that survive restarts, one tmux attach away from any terminal.
Real-time notifications
CLI mutations and AI events are pushed instantly to the app via Unix socket (polling on Windows).
Takes care of you
Sound alerts when AI agents need you, Pomodoro timer for focused work cycles with regular breaks. PaiR helps you stay in the zone without burning out.
AI Text Transform
Transform text in any input field using AI. Reformulate, translate, or summarize - works with any Claude subscription.
Git-synced issues
Issues live in .pair/ inside your repo, synced on a dedicated orphan branch: the same tickets from any branch of the project, for humans and AI agents alike.
Epics & dependencies
Organize work with parent/child hierarchy and blocks/blocked-by relationships. Visualize what's blocking progress.
Attachments & preview
Attach images, PDFs, and markdown files to issues. Preview, print, and download them directly in the app.
Full-text search
FTS5-powered search across titles, descriptions, and notes. Find any issue instantly.
Activity journal, long-term memory
Every project keeps a durable record: issues created, changes, decisions. Where the agent's own memory ends with the session, the journal, issues and comments persist, readable by you and your agents.
Cross-project cables
Cable two agent sessions together, even across projects, and they message each other directly. The graph view shows every live connection and animates as messages flow - you see who's talking to whom in real time.
Multi-agent orchestration (preview)
An early-preview engine where a team of agent roles (coder, reviewer, supervisor) takes a single issue and hands the work off automatically, each on a model sized for its job. Every role gets its own session, side by side, and an agent from another vendor, such as Codex, can join the conversation. You approve the merge gate and stay the final decision-maker. Experimental and evolving.
Sync & integrate
GitHub and GitLab sync built in. Need Redmine, Jira, or something custom? The pair CLI is your API - ask your AI agent to build the bridge for you.
Built-in documentation
In-app docs covering the full interface, CLI usage, and AI integration. Plus an auto-generated AGENTS.md per project for AI agents.
Bilingual interface
Full English and French support. Switch languages instantly from the app or the website.
Local & private
No cloud, no account, no telemetry. Your data stays on your machine; peer messaging, when you use it, stays on your local network.
Secure by default
Peers are identified by their certificate, pinned once you approve them, and repeated failed attempts are blocked. Any message injected into a terminal session is sanitized, and the app's local socket is reserved to your user.
A day with PaiR
Run your AI agents in PaiR's terminals and keep control, from the first prompt to a whole team.
First time? 3 steps.
pair initin your projectClick Play, the AI sizes up the work
PaiRClick Play on any issue - PaiR opens a terminal, launches Claude Code, and the agent reads the ticket first. A quick fix? It gets to work. A bigger job? It explains why a team of agents would do better and asks you before launching an orchestration. Your call, either way.
Monitor everything live
PaiRPin terminal tabs side by side to watch multiple AI sessions at once. When an agent needs your attention, its tab flashes red with a sound alert - no context switching needed. When a team is at work, the graph shows who's talking to whom.
Keep the overview
PaiRSwitch to the dashboard to see the big picture - reprioritize, check what's done and what's next. All your projects, one glance.
Review, commit, move on
Terminal + PaiRYou review the diff and commit; the issue closes with a comment explaining what was done and why - on to the next.
End of day, everything's tracked
PaiRBugs, features, tasks - all visible and prioritized in PaiR. The activity journal captures every decision and change - readable by you and your agents. Tomorrow, they pick up right where you left off.
Download PaiR
Version 0.46.0 - Free, no account required. Your data stays local.
PaiR is free and distributed outside the App Store, without Apple's paid signing program. As a result, macOS trusts it less than a signed app: the few commands below lift those restrictions.
On first launch
macOS blocks apps downloaded outside the App Store. On first install only, open a terminal and run:
xattr -cr /Applications/PaiR.appAfter each update: local network access (macOS 27 and later)
Since macOS 27, the "Local Network" permission is granted to a specific app, identified by its signature. Without an Apple certificate, each update gives PaiR a new signature: to macOS it is a different app, and the permission is lost. This only matters if you work with machines on your network (internal Git server, NAS...).
Symptom: from a PaiR terminal, a machine on your network answers "No route to host", while the Internet works and the same command succeeds in Terminal.app.
Turning the switch off and on again in System Settings > Privacy & Security > Local Network is not enough. The fix is to sign the app yourself with a certificate that does not change:
- Once: open Keychain Access, menu Keychain Access > Certificate Assistant > Create a Certificate. Name it "PaiR SelfSigned", identity type "Self-Signed Root", certificate type "Code Signing".
- After each update, with PaiR closed, run in Terminal.app:
codesign --force --deep -s "PaiR SelfSigned" /Applications/PaiR.app - Relaunch PaiR. If macOS asks for local network access (normally only the very first time), accept: the permission then carries over from one update to the next, as long as the app is re-signed with the same certificate.
This step will go away once PaiR is signed with an Apple certificate.
PaiR is free and distributed without a paid code-signing certificate. As a result, your browser and Windows trust it less than a signed app: they may block the download, then the launch. Here is how to lift those restrictions:
- If your browser blocks the download: click "Keep" or "Keep anyway" in the download bar.
- If Windows SmartScreen blocks the app: click "More info" then "Run anyway".
On a company computer, IT may disable these buttons: installing then requires their approval.
FAQ
Common questions about PaiR. Curious about something? Check below - or just ask your AI agent to visit this page. Who better to explain?
Everything is stored locally in a .pair/ directory inside your project. It uses SQLite for the database and JSONL for git-friendly exports. Nothing is sent to any cloud: the only exchanges are with the peers you pair with on your local network, if you choose to.
Yes, PaiR is completely free. No account required, no limits, no telemetry.
PaiR is free to use with no restrictions, but the source code is not publicly available. There is no account, no telemetry, and no usage limits.
Yes, PaiR works 100% offline. Everything runs locally on your machine. An internet connection is only needed to check for updates.
PaiR is available for macOS (Apple Silicon and Intel), Linux (.deb for amd64 and arm64), and Windows.
AI agents use the pair CLI to create, update, and close issues. PaiR detects their activity in real time thanks to a hook system - each time the agent acts, PaiR is notified instantly. Launch your agents from PaiR's integrated terminals (click Play on an issue) and follow every session as it works.
Just open your project in PaiR - an AGENTS.md file is generated automatically. When Claude Code reads it, it discovers PaiR and offers to install the notification hooks. Once set up, every Claude Code action triggers a notification in PaiR - sound alerts, visual flash, and live activity tracking. No manual configuration needed. It also installs PaiR's slash commands (/pair-create-issue, /pair-run-issue, /pair-close-issue...) and their Python helper scripts, so your whole issue workflow is one command away. Python must be installed on your system.
Yes: Codex, Mistral or any other agent. PaiR gives them a shared channel to message each other, even when an agent runs in a sandbox that blocks the usual routes. To also see what an agent is doing live, it needs hooks, a way to report its actions: Claude Code and Codex already have them, and PaiR plugs into them.
Yes. PaiR includes integrated terminals - click Play on any issue to open a terminal tab and launch Claude Code automatically. Pin multiple tabs for a split view and monitor several sessions in parallel. When an agent needs your attention, its tab turns red with a sound alert. Enable tmux mode for persistent sessions that survive app restarts - the session badge copies the tmux attach command, so you can join a session from any terminal.
Yes. Each project has its own .pair/ directory where issues are stored. The desktop app gives you a unified dashboard across all your projects. You can also cable agent sessions together - even across projects - so they message each other directly.
Cable two sessions together: in the graph view, pull a cable from a session's output point to another session, or run pair cable add. Once cabled, they exchange journal messages in real time (pair journal --push --to), and the graph animates each message along the cable so you see who's talking to whom.
Yes, as an early preview. PaiR includes an experimental orchestration engine where a team of agent roles (coder, reviewer, supervisor) takes a single issue and hands the work off between them automatically. You stay in control of the key moment: the merge is a human gate you approve or reject, and a control panel lets you watch each role live. You can also simply ask your agent to run an issue as an orchestration, or solo: it drives it through the pair CLI. It is still being designed, so expect rough edges.
Download the latest version from this page and replace the existing application. Your data is stored separately in .pair/ directories and will be preserved across updates.
Yes. PaiR started as Beads Task-Issue Tracker, an open-source desktop frontend built on top of Beads - the open-source AI-native issue tracker created by Steve Yegge. As the project evolved, it became its own product with its own CLI, engine, and features - PaiR. The current version no longer reads Beads files. If you still have a Beads project to bring over, install a release up to v0.39: it performs the one-way import (bd < 0.5 and br, SQLite + JSONL) without ever touching the original .beads/ folder.