Skip to content
Back to search

tmux-bridge-mcp

Standalone MCP server for cross-pane AI agent communication via tmux. Lets Claude Code, Gemini CLI, Codex, and Kimi CLI talk to each other through tmux panes.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/howardpen9--tmux-bridge-mcp/badge.svg)](/listings/howardpen9--tmux-bridge-mcp)

HTML

<a href="/listings/howardpen9--tmux-bridge-mcp"><img src="/api/listings/howardpen9--tmux-bridge-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Prerequisites:** tmux 3.2+ and Node.js 18+ must be installed.

**One command to configure all your agents:**

npx tmux-bridge-mcp setup

This auto-detects Claude Code, Codex, OpenCode, CodeBuddy, Copilot CLI, Grok Build, Gemini CLI, and Kimi CLI on your machine, then writes the correct MCP config for each one. Done in seconds.

**Verify it works:**

npx tmux-bridge-mcp --help

You should see the version and available commands. Restart your AI agent to activate the new tools.

**See it in action:**

npx tmux-bridge-mcp demo

Opens a 3-pane tmux session and runs a live cross-pane communication demo.

<details> <summary>Manual setup (if you prefer)</summary>

**1. Install tmux**

brew install tmux    # macOS
apt install tmux     # Linux

**2. Add to your agent's MCP config**

{
  "mcpServers": {
    "tmux-bridge": {
      "command": "npx",
      "args": ["-y", "tmux-bridge-mcp"]
    }
  }
}

Restart your agent. It now has 9 MCP tools for cross-pane communication.

</details>

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 506 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # tmux-bridge-mcp
  2. **English** | [简体中文](README.zh-CN.md)
  3. ![tmux-bridge-mcp](docs/images/hero-banner.png)
  4. A standalone MCP server that lets AI agents (Claude Code, Gemini CLI, Codex, Kimi CLI) communicate with each other through tmux panes. It talks directly to tmux -- no external dependencies beyond tmux itself.
  5. ## 🖥️ What is tmux?
  6. [tmux](https://github.com/tmux/tmux) is a **terminal multiplexer** -- it lets you split one terminal window into multiple **panes**, each running its own process independently. Think of it as "tabs on steroids" for your terminal.
  7. ![What is tmux](docs/images/what-is-tmux.png)
  8. ```
  9. +-------------------------------+
  10. | Pane 1 | Pane 2 |
  11. | Claude Code | Codex |
  12. | writing code | reviewing |
  13. | | |
  14. +---------------+---------------+
  15. | Pane 3 | Pane 4 |
  16. | Gemini CLI | tail -f logs |
  17. | researching | monitoring |
  18. +-------------------------------+
  19. ```
  20. Each pane is a full terminal. You can have Claude Code running in one, Codex in another, Gemini in a third -- all visible at the same time, all on the same machine.
  21. **The problem:** these panes can't talk to each other. An agent in Pane 1 has no idea what's happening in Pane 2.
  22. ![The Problem](docs/images/the-problem.png)
  23. **tmux-bridge fixes this.** It gives every agent the ability to read, type, and send messages into any other pane.
  24. ![The Solution](docs/images/the-solution.png)
  25. ## ⚡ What can you do with tmux-bridge?
  26. Once installed, your AI agents can:
  27. | Action | How | Example |
  28. |--------|-----|---------|
  29. | **See what another agent is doing** | `tmux_read` | Read the last 20 lines of Codex's pane |
  30. | **Send a task to another agent** | `tmux_message` + `tmux_keys` | Tell Claude to review a file |
  31. | **Coordinate multi-agent workflows** | Chain tool calls | Gemini researches -> Claude implements -> Codex reviews |
  32. | **Monitor processes** | `tmux_read` on a shell pane | Watch build logs, test output, server status |
  33. | **Label panes by role** | `tmux_name` | Name panes "claude", "codex", "gemini" for easy targeting |
  34. All of this happens through standard MCP tool calls -- your agent doesn't need to learn any new syntax. If it supports MCP, it already knows how.
  35. ## 🤖 Supported Agents
  36. ![Supported Agents](docs/images/supported-agents.png)
  37. ### Tested and documented
  38. | Agent | Connection | Setup path |
  39. |-------|------------|------------|
  40. | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | Native MCP (stdio) | `claude mcp add -s user` / `~/.claude.json` |
  41. | [Codex CLI](https://github.com/openai/codex) | Native MCP (stdio) | `codex mcp add` |
  42. | [OpenCode](https://opencode.ai) | Native MCP (stdio) | `~/.config/opencode/opencode.json(c)` (`mcp` key) |
  43. | [CodeBuddy](https://www.codebuddy.ai) | Native MCP (stdio) | `codebuddy mcp add -s user` / `~/.codebuddy/.mcp.json` |
  44. | [GitHub Copilot CLI](https://docs.github.com/en/copilot/how-tos/copilot-cli) | Native MCP (stdio) | `copilot mcp add` / `~/.copilot/mcp-config.json` |
  45. | [Grok Build](https://docs.x.ai/build/overview) | Native MCP (stdio) | `grok mcp add -s user` / `~/.grok/config.toml` |
  46. | [Gemini CLI](https://github.com/google-gemini/gemini-cli) | Native MCP (stdio) | `~/.gemini/settings.json` |
  47. | [Kimi CLI](https://github.com/MoonshotAI/kimi-cli) v1.26+ | Native MCP (`kimi mcp add`) | `kimi mcp add` |
  48. | [Kimi CLI](https://github.com/MoonshotAI/kimi-cli) older | Legacy wrapper (`kimi-tmux`) | wrapper binary |
  49. ### Should work (any MCP-compatible agent)
  50. | Agent | Notes |
  51. |-------|-------|
  52. | [Cursor](https://cursor.sh) | Supports MCP servers in settings |
  53. | [Windsurf (Codeium)](https://codeium.com/windsurf) | MCP server support |
  54. | [Aider](https://aider.chat) | Community MCP support |
  55. | [Continue.dev](https://continue.dev) | MCP server support |
  56. | [Cline](https://github.com/cline/cline) | VS Code extension with MCP |
  57. | [Roo Code](https://github.com/RooVetGit/Roo-Code) | Fork of Cline with MCP |
  58. | Any shell script or process | Read pane output with `tmux_read`, no MCP needed |
  59. tmux-bridge works with **any agent that supports MCP over stdio**. If your agent isn't listed, try adding the MCP config -- it will likely just work.
  60. ## 💡 Why
  61. When you run multiple AI agents in separate terminals, they work in isolation. You end up copy-pasting context between them, manually relaying questions and answers, or losing track of what each agent is doing.
  62. tmux-bridge solves this by giving every agent the ability to **read, type, and send messages into any other terminal pane** -- programmatically, through standard MCP tool calls.
  63. **Use cases:**
  64. - **Code review pipeline** -- Claude Code writes code in one pane, Codex reviews it in another, results flow back automatically
  65. - **Multi-model reasoning** -- ask Gemini for research, feed the findings to Claude, let Codex verify the implementation
  66. - **Parallel workflows** -- multiple Claude Code instances each handling a different part of a large task, coordinating through pane messages
  67. - **Monitoring** -- an agent reads log output from a `tail -f` pane and reacts to errors in real time
  68. **What you need:**
  69. | Requirement | Why |
  70. |-------------|-----|
  71. | **tmux** | The terminal multiplexer that hosts your panes -- this is the communication channel |
  72. | **Node.js 18+** | Runs the MCP server |
  73. | **At least one MCP-compatible agent** | Claude Code, Codex, OpenCode, CodeBuddy, Copilot CLI, Grok Build, Gemini CLI, or Kimi CLI v1.26+ |
  74. If you already use tmux to run multiple agents side by side, tmux-bridge just makes them aware of each other.
  75. ### 😩 Without tmux-bridge
  76. You're running Claude Code in one pane, Codex in another. Claude finishes writing a function and you want Codex to review it. Here's what actually happens:
  77. 1. You read Claude's output. Scroll up. Copy the relevant part.
  78. 2. Switch to Codex's pane. Paste it in. Type "review this code."
  79. 3. Codex gives feedback. You copy that.
  80. 4. Switch back to Claude. Paste Codex's feedback. "Fix these issues."
  81. 5. Repeat for every round of review.
  82. **You are the message bus.** Every interaction flows through your clipboard. You're not writing code anymore -- you're routing context between agents. With 3+ agents running, this becomes unmanageable within minutes.
  83. ### 🤔 Why not LangChain / CrewAI / A2A?
  84. | Approach | What it asks you to do | tmux-bridge difference |
  85. |----------|----------------------|----------------------|
  86. | **LangChain / CrewAI / AutoGen** | Rewrite your workflow inside their framework. Your agents must be Python objects in their orchestration layer. | You keep using Claude Code, Codex, Gemini CLI as-is. No framework, no SDK, no rewrite. |
  87. | **Google A2A Protocol** | Wait for agents to adopt a new protocol spec. Designed for distributed, networked agents. | Works today with any MCP agent. No protocol adoption needed. |
  88. | **Custom WebSocket / HTTP glue** | Build and maintain your own IPC layer. Handle serialization, discovery, error handling. | Zero infrastructure. tmux is the transport -- it's already running. |
  89. | **Shared files / pipes** | Roll your own convention. Each agent needs custom tooling to read/write. | Standard MCP tools. Any agent that speaks MCP gets cross-pane superpowers instantly. |
  90. **The key insight:** you don't need a multi-agent *framework*. You need your existing agents to *see each other*. tmux-bridge adds exactly that -- a thin MCP layer over tmux -- and nothing more.
  91. ## 🚀 Quick Start
  92. **Prerequisites:** tmux 3.2+ and Node.js 18+ must be installed.
  93. **One command to configure all your agents:**
  94. ```bash
  95. npx tmux-bridge-mcp setup
  96. ```
  97. This auto-detects Claude Code, Codex, OpenCode, CodeBuddy, Copilot CLI, Grok Build, Gemini CLI, and Kimi CLI on your machine, then writes the correct MCP config for each one. Done in seconds.
  98. **Verify it works:**
  99. ```bash
  100. npx tmux-bridge-mcp --help
  101. ```
  102. You should see the version and available commands. Restart your AI agent to activate the new tools.
  103. **See it in action:**
  104. ```bash
  105. npx tmux-bridge-mcp demo
  106. ```
  107. Opens a 3-pane tmux session and runs a live cross-pane communication demo.
  108. <details>
  109. <summary>Manual setup (if you prefer)</summary>
  110. **1. Install tmux**
  111. ```bash
  112. brew install tmux # macOS
  113. apt install tmux # Linux
  114. ```
  115. **2. Add to your agent's MCP config**
  116. ```json
  117. {
  118. "mcpServers": {
  119. "tmux-bridge": {
  120. "command": "npx",
  121. "args": ["-y", "tmux-bridge-mcp"]
  122. }
  123. }
  124. }
  125. ```
  126. Restart your agent. It now has 9 MCP tools for cross-pane communication.
  127. </details>
  128. ## 🔄 Updating
  129. ```bash
  130. # If installed globally
  131. npm update -g tmux-bridge-mcp
  132. # If using npx (auto-updates, but to force latest)
  133. npx tmux-bridge-mcp@latest
  134. # Check your current version
  135. npx tmux-bridge-mcp --version
  136. ```
  137. After updating, restart your agents to pick up the new version. If you use `npx` in your MCP config, it caches the package — run `npx --yes tmux-bridge-mcp@latest` once to pull the latest, then your agents will use it on next startup.
  138. ## 🏗️ How It Works
  139. ![Layered Architecture](docs/images/layered-architecture.png)
  140. tmux-bridge runs as an MCP server over stdio. It calls tmux directly (`capture-pane`, `send-keys`, `list-panes`, etc.) -- no intermediate CLI layer.
  141. ```
  142. MCP path (Gemini, Claude Code, Codex, any MCP client):
  143. +--------------+ MCP/stdio +---------------+ tmux API +--------------+
  144. | MCP Agent |<----------->| tmux-bridge |<---------->| tmux panes |
  145. +--------------+ | MCP server | +--------------+
  146. +---------------+
  147. CLI path (Kimi):
  148. +--------------+ --print +---------------+ tmux API +--------------+
  149. | Kimi CLI |<----------->| kimi-tmux |<---------->| tmux panes |
  150. +--------------+ tool parse | adapter | +--------------+
  151. +---------------+
  152. ```
  153. ![Architecture](docs/images/architecture.png)
  154. All cross-pane interactions follow the **read-act-read** workflow:
  155. ![Read-Act-Read Workflow](docs/images/read-act-read.png)
  156. | Step | Action | Purpose |
  157. |------|--------|---------|
  158. | 1 | `tmux_read` | Read target pane (satisfies read guard) |
  159. | 2 | `tmux_message` / `tmux_type` | Type your message or command |
  160. | 3 | `tmux_read` | Verify text landed correctly |
  161. | 4 | `tmux_keys` | Press Enter to submit |
  162. | -- | STOP | Don't poll. The other agent replies directly into your pane. |
  163. The read guard is enforced at the MCP layer: `tmux_type`, `tmux_message`, and `tmux_keys` will fail unless you call `tmux_read` on the target pane first.
  164. ## ⚙️ Setup Per Agent
  165. ### Gemini CLI (native MCP)
  166. Add to `~/.gemini/settings.json`:
  167. ```json
  168. {
  169. "mcpServers": {
  170. "tmux-bridge": {
  171. "command": "npx",
  172. "args": ["tmux-bridge-mcp"]
  173. }
  174. }
  175. }
  176. ```
  177. ### Claude Code (native MCP)
  178. Add to your project's `.mcp.json` or global MCP config:
  179. ```json
  180. {
  181. "mcpServers": {
  182. "tmux-bridge": {
  183. "command": "npx",
  184. "args": ["tmux-bridge-mcp"]
  185. }
  186. }
  187. }
  188. ```
  189. ### Codex (native MCP)
  190. Add to your MCP config following the Codex MCP setup docs:
  191. ```json
  192. {
  193. "mcpServers": {
  194. "tmux-bridge": {
  195. "command": "npx",
  196. "args": ["tmux-bridge-mcp"]
  197. }
  198. }
  199. }
  200. ```
  201. ### OpenCode
  202. `opencode mcp add` is interactive. `tmux-bridge-mcp setup` writes directly to
  203. `~/.config/opencode/opencode.json` (or `.jsonc`):
  204. ```json
  205. {
  206. "mcp": {
  207. "tmux-bridge": {
  208. "type": "local",
  209. "command": ["npx", "-y", "tmux-bridge-mcp"],
  210. "enabled": true
  211. }
  212. }
  213. }
  214. ```
  215. ### CodeBuddy (Tencent)
  216. ```bash
  217. codebuddy mcp add -s user tmux-bridge -- npx -y tmux-bridge-mcp
  218. ```
  219. Fallback config path: `~/.codebuddy/.mcp.json` (standard `mcpServers` JSON).
  220. ### GitHub Copilot CLI
  221. ```bash
  222. copilot mcp add tmux-bridge -- npx -y tmux-bridge-mcp
  223. ```
  224. Fallback config path: `~/.copilot/mcp-config.json`:
  225. ```json
  226. {
  227. "mcpServers": {
  228. "tmux-bridge": {
  229. "type": "local",
  230. "command": "npx",
  231. "args": ["-y", "tmux-bridge-mcp"],
  232. "tools": ["*"]
  233. }
  234. }
  235. }
  236. ```
  237. ### Grok Build
  238. ```bash
  239. grok mcp add -s user tmux-bridge -- npx -y tmux-bridge-mcp
  240. ```
  241. Fallback TOML in `~/.grok/config.toml`:
  242. ```toml
  243. [mcp_servers.tmux-bridge]
  244. command = "npx"
  245. args = [
  246. "-y",
  247. "tmux-bridge-mcp",
  248. ]
  249. enabled = true
  250. ```
  251. ### Kimi CLI
  252. ```bash
  253. # Check your Kimi version
  254. kimi --version
  255. # v1.26+ → use native MCP (recommended)
  256. # older → use kimi-tmux wrapper
  257. ```
  258. **Native MCP (recommended, v1.26+):**
  259. ```bash
  260. kimi mcp add tmux-bridge -- npx tmux-bridge-mcp
  261. ```
  262. Once added, Kimi uses all tmux-bridge tools directly -- no adapter needed.
  263. **Legacy wrapper (older versions):**
  264. For Kimi CLI versions without native MCP, `kimi-tmux` bridges the gap by injecting the system instruction as a prompt, running Kimi in `--print` mode, parsing tool-call blocks from output, and executing them via tmux.
  265. ```bash
  266. kimi-tmux "list all tmux panes"
  267. kimi-tmux "ask the agent in codex pane to review src/auth.ts"
  268. kimi-tmux "read what claude is working on"
  269. kimi-tmux --rounds 3 "send a message to gemini and wait for the result"
  270. ```
  271. ![Kimi CLI Bridging](docs/images/kimi-bridging.png)
  272. ## 🔧 Tools Reference
  273. | Tool | Description |
  274. |------|-------------|
  275. | `tmux_list` | List all panes with target ID, process, label, and working directory |
  276. | `tmux_read` | Read last N lines from a pane (satisfies read guard) |
  277. | `tmux_type` | Type text into a pane without pressing Enter (requires prior read) |
  278. | `tmux_message` | Send message with auto-prepended sender info (requires prior read) |
  279. | `tmux_keys` | Send special keys -- Enter, Escape, C-c, etc. (requires prior read) |
  280. | `tmux_name` | Label a pane for easy targeting (e.g., "claude", "gemini") |
  281. | `tmux_resolve` | Look up pane ID by label |
  282. | `tmux_id` | Print current pane's tmux ID |
  283. | `tmux_doctor` | Diagnose tmux connectivity issues |
  284. Targets can be a pane ID (`%0`), session:window.pane (`main:0.1`), or a label (`claude`).
  285. ## 📖 Examples
  286. ### Ask Claude to review a file (from Gemini)
  287. ```
  288. tmux_list()
  289. tmux_read(target="claude", lines=20)
  290. tmux_message(target="claude", text="Please review src/auth.ts for security issues")
  291. tmux_read(target="claude", lines=5)
  292. tmux_keys(target="claude", keys=["Enter"])
  293. ```
  294. ### Multi-agent coordination (from Kimi)
  295. ```bash
  296. kimi-tmux "tell the claude pane to run the test suite"
  297. kimi-tmux "ask gemini to summarize the test results in claude's pane"
  298. ```
  299. ### Multi-agent layout
  300. ```
  301. +-----------------------------------------------------------+
  302. | tmux session |
  303. | |
  304. | +------------+ +------------+ +----------+ +-----------+ |
  305. | | Claude Code | | Codex | | Gemini | | Kimi | |
  306. | | (MCP) | | (MCP) | | (MCP) | |(kimi-tmux)| |
  307. | | | | | | | | | |
  308. | | label: | | label: | | label: | | label: | |
  309. | | claude | | codex | | gemini | | kimi | |
  310. | +-----+------+ +-----+------+ +----+-----+ +-----+-----+ |
  311. | +---------------+-----------+--------------+ |
  312. | tmux-bridge (direct tmux IPC, no deps) |
  313. +-----------------------------------------------------------+
  314. ```
  315. ## 🌐 Environment Variables
  316. | Variable | Description | Default |
  317. |----------|-------------|---------|
  318. | `TMUX_BRIDGE_SOCKET` | Override tmux server socket path | Auto-detected from `$TMUX` |
  319. | `KIMI_PATH` | Path to `kimi` binary (kimi-tmux only) | `kimi` (in PATH) |
  320. ## 🔒 Security Model
  321. tmux-bridge is designed for **local development on a single machine**. It assumes all connected MCP agents are trusted:
  322. - Any agent can read from or write to **any pane** in the tmux server — there is no per-pane access control.
  323. - The **read guard** (must `tmux_read` before `tmux_type`/`tmux_keys`) is a sequencing aid to prevent blind typing. It is **not a security boundary**.
  324. - Pane labels set via `tmux_name` are **not authenticated** — any agent can label or relabel any pane.
  325. - There is no encryption or authentication between agents. Communication happens through tmux's own IPC (Unix socket).
  326. **Do not use tmux-bridge in multi-tenant environments** or expose the tmux socket over a network. It is built for the common case: one developer running multiple AI agents side by side on their own machine.
  327. ## 📝 System Instruction
  328. For agents that support custom system prompts, use `system-instruction/smux-skill.md`. It teaches the read-act-read workflow and documents all available MCP tools.
  329. ## 🔗 Related Projects
  330. | Project | Approach | Focus |
  331. |---------|----------|-------|
  332. | [smux](https://github.com/ShawnPana/smux) | tmux skill + bash CLI | Agent-agnostic tmux setup |
  333. | [agent-bridge](https://github.com/raysonmeng/agent-bridge) | WebSocket daemon + MCP plugin | Claude Code <-> Codex |
  334. | **tmux-bridge-mcp** (this) | Standalone MCP server + direct tmux | Any agent, zero deps beyond tmux |
  335. ### smux vs tmux-bridge-mcp
  336. | Dimension | smux | tmux-bridge-mcp (this) |
  337. |-----------|------|------------------------|
  338. | 🔌 **How agents connect** | Agent runs bash commands (`tmux-bridge read/type/keys`) | Agent uses MCP tool calls (`tmux_read/tmux_type/tmux_keys`) |
  339. | 🚀 **Agent onboarding** | Install skill or inject system prompt to teach bash commands | Add MCP config JSON -- agent auto-discovers 9 tools |
  340. | 📦 **Prerequisites** | `curl \| bash` installs tmux + tmux.conf + CLI script | Just tmux + Node.js, `npx` to run |
  341. | ⚙️ **tmux configuration** | Ships full tmux.conf (keybindings, mouse, status bar) | Doesn't touch tmux.conf -- no config conflicts |
  342. | 🛡️ **Read guard** | Bash CLI layer (`/tmp` file lock) | MCP server layer (`/tmp` file lock, same concept) |
  343. | 💻 **Language** | Bash (~300 LOC) | TypeScript (~600 LOC) |
  344. | 📥 **Install** | `curl \| bash`, writes to `~/.smux/` | `npm install -g` or `npx` |
  345. | 🤝 **Agent compatibility** | Any agent that can run bash (needs skill/prompt) | Any agent with MCP support (standard protocol) |
  346. 👉 **When to use smux:** You want a complete tmux setup (keybindings, mouse support, status bar) and your agents support the skills system or you're comfortable injecting system prompts.
  347. 👉 **When to use tmux-bridge-mcp:** You want a drop-in MCP server that works with any MCP-compatible agent out of the box, without touching your tmux configuration.
  348. ### tmux-bridge (`/tmb`) vs Claude Code Native (subagent + `/codex` + `/gemini`)
  349. | Dimension | tmux-bridge | Claude Code Native |
  350. |-----------|-------------|-------------------|
  351. | **Context isolation** | Each pane has its own full conversation context, persists across interactions | subagent spawns fresh each time, gone when it finishes |
  352. | **Persistence** | Pane stays alive, accumulates conversation history | Fire-and-forget, must re-provide context next time |
  353. | **Parallelism** | Truly independent processes, no interference | Agent tool can parallelize, but shares billing/rate limits |
  354. | **Model diversity** | Each pane can run a different CLI (Codex, Gemini, Kimi) | `/codex` `/gemini` can do this too -- not a real differentiator |
  355. | **Communication overhead** | Goes through tmux read/send, has latency, messages may get truncated | Native tool calls, structured returns, high reliability |
  356. | **Result integration** | You must read pane output, parse, and synthesize manually | subagent returns structured results directly, ready to use |
  357. | **Operational complexity** | Extra layer of tmux management (labels, pane IDs) | One tool call, done |
  358. | **Cost** | Each pane consumes its own token budget independently | subagent shares the same session's token pool |
  359. **Verdict**
  360. tmux-bridge's real advantage comes down to one thing: **persistent context**. If you need an agent that remembers the last 30 turns of conversation and keeps following up on the same task, a tmux pane can do that -- a subagent cannot.
  361. But for most tasks, native is better:
  362. - Communication is more reliable (no tmux buffer truncation)
  363. - Results are structured -- no need to parse terminal output
  364. - Simpler to operate, one less layer of abstraction
  365. **Practical guidance:**
  366. - **Short-lived, one-off tasks** → native subagent / `/codex` / `/gemini`
  367. - **Long-running sessions that need accumulated context** (e.g., a reviewer continuously following the same PR) → tmux-bridge adds real value
  368. - A multi-pane multi-role layout only pays off if each role genuinely needs cross-conversation state -- otherwise the overhead outweighs the benefit
  369. ## 📄 License
  370. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.