Skip to content
Back to search

airband

MarketplaceWorks with Claude CodeGitHub

Airband for Claude Code: a map of your code, your other chats' records, and skills that use them.

Safety scan

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

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/HarshBaldaniya/airband with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/HarshBaldaniya/airband'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/harshbaldaniya--airband/badge.svg)](/listings/harshbaldaniya--airband)

HTML

<a href="/listings/harshbaldaniya--airband"><img src="/api/listings/harshbaldaniya--airband/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

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

npx airband

That one command finds Claude Code, Codex and Gemini CLI on your computer, sets each one up, and adds the `airband` command. Every settings file it touches is backed up first.

  Airband 0.0.1  setting up your agents

  ✓ Claude Code   tools · skills · auto-sharing
  ✓ Codex         tools · skills · auto-sharing
  ✓ Gemini CLI    tools · auto-sharing
  ✓ airband       the command, in any new terminal

  Done. Restart open agent chats to pick it up.

Then restart your agent chats. Each new chat opens with a line from Airband, shown to you only:

✓ Airband · map of my-app ready (1,284 files) · sharing with “Billing fix” (Codex)
  Another chat worked here in the last 12 hours: “Fix login redirect” (Codex). Say “catch up” to hear what it did.

when another chat's work rides along with your message:

↪ Airband added what “Billing fix” (Codex) did to this message

and after your agent asks Airband something, what it found and what it saved (Claude Code):

↪ Airband: “syncSeats” and the 4 places that use it · about 300 tokens instead of about 9,800 to read the 5 files

The saving is measured, not guessed: the answer's own length against the real size of the files it points to. It shows only when it is a real saving.

In Codex, type `/hooks` once and trust Airband's hook: Codex runs a new hook only after you approve it.

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.

.claude-plugin/marketplace.json · Manifest · 14 lines
  1. {
  2. "name": "airband",
  3. "description": "Airband for Claude Code: a map of your code, your other chats' records, and skills that use them.",
  4. "owner": { "name": "Harsh Baldaniya" },
  5. "plugins": [
  6. {
  7. "name": "airband",
  8. "source": "./",
  9. "description": "Find code through a map of the project, recall what earlier chats did, and catch up on other chats. No AI of its own, no server, no telemetry.",
  10. "category": "development",
  11. "tags": ["code-map", "mcp", "skills"]
  12. }
  13. ]
  14. }
README.md · README · 547 lines
  1. <h1 align="center">
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="media/airband-wordmark-dark.png">
  4. <img src="media/airband-wordmark-light.png" alt="Airband" width="300">
  5. </picture>
  6. </h1>
  7. <p align="center">
  8. <strong>Connect your Claude Code, Codex and Gemini CLI chats, so each one knows what the others did.</strong>
  9. </p>
  10. <p align="center">
  11. <a href="https://github.com/HarshBaldaniya/airband/actions/workflows/test.yml"><img src="https://github.com/HarshBaldaniya/airband/actions/workflows/test.yml/badge.svg" alt="Tests"></a>
  12. <a href="https://www.npmjs.com/package/airband"><img src="https://img.shields.io/npm/v/airband.svg" alt="npm version"></a>
  13. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License"></a>
  14. <img src="https://img.shields.io/badge/macOS%20%C2%B7%20Windows%20%C2%B7%20Linux-supported-555.svg" alt="macOS, Windows, Linux">
  15. </p>
  16. <p align="center">
  17. <a href="#quick-start">Quick start</a> ·
  18. <a href="#what-you-get">What you get</a> ·
  19. <a href="#how-it-works">How it works</a> ·
  20. <a href="#install">Install</a> ·
  21. <a href="#the-airband-command">Command line</a> ·
  22. <a href="#privacy-and-security">Privacy</a> ·
  23. <a href="#troubleshooting">Troubleshooting</a>
  24. </p>
  25. ---
  26. ## Why Airband
  27. You run several AI coding chats at once: one builds a feature, another writes its tests, a third reviews
  28. the pull request. Each one starts blind to what the others just did, so you copy and paste between them,
  29. or explain the same thing three times.
  30. Airband links those chats. When a chat finishes a reply, every chat connected to it receives a short
  31. note with its next message: what was asked, what was done and which files changed. It also gives every
  32. agent a map of your code, so finding something costs a few hundred tokens instead of a search through
  33. files.
  34. - **Every agent, one place.** Claude Code, Codex and Gemini CLI, side by side in VS Code.
  35. - **Chats that keep each other informed,** at the level of detail you choose.
  36. - **Local by design.** No server, no account, no AI model of its own, and it never reads a login.
  37. ## Quick start
  38. ```bash
  39. npx airband
  40. ```
  41. That one command finds Claude Code, Codex and Gemini CLI on your computer, sets each one up, and
  42. adds the `airband` command. Every settings file it touches is backed up first.
  43. ```text
  44. Airband 0.0.1 setting up your agents
  45. ✓ Claude Code tools · skills · auto-sharing
  46. ✓ Codex tools · skills · auto-sharing
  47. ✓ Gemini CLI tools · auto-sharing
  48. ✓ airband the command, in any new terminal
  49. Done. Restart open agent chats to pick it up.
  50. ```
  51. Then restart your agent chats. Each new chat opens with a line from Airband, shown to you only:
  52. ```text
  53. ✓ Airband · map of my-app ready (1,284 files) · sharing with “Billing fix” (Codex)
  54. Another chat worked here in the last 12 hours: “Fix login redirect” (Codex). Say “catch up” to hear what it did.
  55. ```
  56. when another chat's work rides along with your message:
  57. ```text
  58. ↪ Airband added what “Billing fix” (Codex) did to this message
  59. ```
  60. and after your agent asks Airband something, what it found and what it saved (Claude Code):
  61. ```text
  62. ↪ Airband: “syncSeats” and the 4 places that use it · about 300 tokens instead of about 9,800 to read the 5 files
  63. ```
  64. The saving is measured, not guessed: the answer's own length against the real size of the files
  65. it points to. It shows only when it is a real saving.
  66. In Codex, type `/hooks` once and trust Airband's hook: Codex runs a new hook only after you approve
  67. it.
  68. ## What you get
  69. | | |
  70. |---|---|
  71. | **Tower** | Every chat as a card on one board: its status, model, how full its context is. Drag one card onto another to **connect** them. |
  72. | **Channels** | A connection between two chats, at the level you choose: **Ping** (one line per ask, the default), **Brief** (asked, done, open, files and PRs) or **Full** (the words themselves). One-way or both ways, paused or open. |
  73. | **Flightlog** | A short record of each chat: one line per ask, with what was done, the files, commits and pull requests, and what is still open. |
  74. | **Map** | Your project's parts and files as a board, built by a parser on your computer. Agents query it instead of searching files. TypeScript, JavaScript, Python, Go, Rust, Java, C#, Ruby and PHP. |
  75. | **Commands** | 28 ready-made commands (plan, build, review, pr, tests, specs, recall and more), the same in every agent, plus your own as Markdown files. |
  76. | **Fuel** | Each agent's plan limits as the agent reports them, and tokens per chat. |
  77. | **Writing** | The writing rules agents get, switched on and off; a team file for each project; a file checked on the spot; and what the checks found lately. |
  78. ### What your agents get
  79. Setup gives each agent three tools over MCP (under 400 tokens of definitions in all), the
  80. instructions to use them, and 15 skills they pick up by themselves when a task matches.
  81. | Tool | What an agent does with it |
  82. |---|---|
  83. | `airband_map` | `find` code by name or meaning, ranked, with `path:start-end`; `outline` a file or folder; `graph` who uses what; `check` unused code and stale docs; `diff` what a branch or pull request changed; `in` another project you mapped; or an overview of the project |
  84. | `airband_flightlog` | Read another chat's asks and outcomes, or search every chat, by words, code names, tickets (`ENG-142`), PRs (`#128`) or Figma links |
  85. | `airband_notes` | Read and leave notes for the next chat in this project |
  86. Each skill does a job with what only Airband knows: the map of your code, the records of every
  87. chat, and the notes chats leave. You don't call them. Ask for the job in your own words, and the
  88. agent picks the skill. Only a skill's one-line description sits in each chat. The rest loads when
  89. the skill is used.
  90. | For | Skill | Used when you ask to … |
  91. |---|---|---|
  92. | Developers | `airband-find-code` | find where something is, or what uses it |
  93. | | `airband-impact` | know what a change would break, or whether a rename or delete is safe |
  94. | | `airband-review` | review a PR, a branch, or your own changes before a PR |
  95. | | `airband-debug` | find why something is broken (it first checks whether an earlier chat saw it) |
  96. | | `airband-onboard` | explain a codebase to someone new |
  97. | QA | `airband-test-plan` | plan the tests for a PR or feature, starting with the changes no test reaches |
  98. | Product and leads | `airband-progress` | say where a ticket, feature or PR stands |
  99. | | `airband-ticket` | pick up a ticket, issue, PR or Figma link with what was done on it before |
  100. | | `airband-standup` | write a standup or a weekly update from your chats |
  101. | Finance and founders | `airband-spend` | show the tokens spent by project, agent, ticket and chat |
  102. | Everyone | `airband-recall` | find what was done before, and which chat did it |
  103. | | `airband-catchup` | hear what the other chats did while you were away |
  104. | | `airband-handoff` | leave the work so another chat or agent can continue it |
  105. | | `airband-write-docs` | write a PRD, spec, README or PR description no one can misread |
  106. | | `airband-write-messages` | write a Slack post, email or comment people can act on |
  107. If you have your own skill for the same job (your team's review checklist, say), the agent follows
  108. yours and uses Airband's tools inside it.
  109. The commands are there to run by hand too: `/airband:review` in Claude Code, `/prompts:review` in
  110. Codex, `/review` in Gemini CLI.
  111. ### Reviewing a pull request
  112. `airband_map` with `diff: "#128"` reads the pull request from git without checking it out. In a
  113. terminal, run `airband diff #128`. It lists every function, class and type the PR added, changed,
  114. moved or removed. Each one has `path:start-end`, its callers and the tests that reach it. Removed
  115. code that something still calls is flagged. A number is fetched from `origin` first. A branch name or `main..feature`
  116. works too. With nothing given, it compares this branch with the default one. Code that only the
  117. removed code used is listed as "Left with no caller".
  118. ```text
  119. main...#128 (4f1c2a9e0 → 9b77d03c1): 6 declarations changed in 3 files.
  120. src/billing/seats.ts
  121. removed oldSeatCount function was :12-30 · still used by 1: invoiceLines src/billing/invoice.ts (check these)
  122. changed syncSeats function :40-88 · used by 4: onMemberJoined src/team/members.ts, … · tests: test/seats.test.ts
  123. src/team/members.ts
  124. changed onMemberLeft function :61-79 · used by 2: removeMember src/team/api.ts, … · no test reaches it
  125. ```
  126. With `in: "my-api"` (or `--in my-api`), the same questions go to another project you have mapped.
  127. Name it by its folder. A chat in your app can then look up the API route it calls.
  128. ### Tickets, issues and designs
  129. Each chat's record keeps the tickets and links named in it. These are Linear and Jira ids
  130. (`ENG-142`), GitHub pull requests and issues (`#128`, links), and Figma files and frames. Ask any agent "what did we do
  131. for ENG-142?" and it finds the chats, in any agent, that worked on it. Airband does not connect to
  132. Linear, GitHub or Figma. It remembers what your chats did with them.
  133. ### Writing rules for docs and messages
  134. AI agents now write many of a team's docs and messages. Airband gives them house rules, at the
  135. moment they need them:
  136. | When an agent is asked to … | Airband adds, once per chat |
  137. |---|---|
  138. | write a doc: a PRD, spec, README, guide, PR description or changelog | the **docs rules**: one idea per sentence, active voice, one name for one thing, no hype words, every fact and hedge kept, no lines crediting an AI tool |
  139. | write a message: Slack, email, a PR or ticket comment, an announcement | the **message rules**: the point first, who does what by when, at most 5 items in a list, no empty greetings, no lines crediting an AI tool, a draft before sending |
  140. | reply to you (off by default) | the **reply rules**: the answer or next action first, numbered steps, where things stand, no recap |
  141. The rules are a few lines (about 150 tokens), sent only with an ask that needs them. The full rules
  142. are the `airband-write-docs` and `airband-write-messages` skills. After an agent writes a doc file,
  143. Airband checks the new text. It names long sentences, semicolons, hype words, two-word verbs,
  144. filler, and lines such as "🤖 Generated with …" or "Co-Authored-By: Claude". What agents write goes
  145. out in your name, so it reads as yours. The agent gets the list to fix, and you see one line:
  146. ```text
  147. ↪ Airband checked docs/prd.md: 2 long sentences (lines 14, 31), 1 hype word (line 9)
  148. ```
  149. **Before it goes out.** Before an agent sends a Slack message, an email, a PR description, a
  150. comment or a commit, Airband reads the words. If they break the rules, it holds the send once and
  151. tells the agent what to fix. A commit is held only for a line crediting an AI tool. If the same
  152. words come again unchanged, they go through, so a wording you asked for never gets stuck. This
  153. works in Claude Code and Gemini CLI. In Codex, the rules still come with the ask.
  154. ```text
  155. ↪ Airband held a Slack message to fix first: 2 empty greetings or sign-offs (line 1)
  156. ```
  157. Claude Code adds its own "Co-Authored-By: Claude" line to commits and "Generated with Claude Code"
  158. to PRs, because its built-in instructions tell it to. `airband writing ai-credit off` turns that off
  159. at the source, in Claude Code's own `attribution` setting. Airband backs up the settings file first,
  160. and `ai-credit on` puts back whatever was there.
  161. The **Writing** page in the VS Code extension has a switch for each of these.
  162. ```bash
  163. airband writing # what is on
  164. airband writing replies on # short replies in every chat
  165. airband writing before-send off # don't check messages before they go out
  166. airband writing ai-credit off # Claude Code stops adding its AI-credit lines
  167. airband writing check docs/*.md # check files; exits 1 on findings, for CI
  168. airband writing docs on --project # the team's choice, in .airband.json
  169. ```
  170. **For a team:** `--project` writes `.airband.json` at the project's root. Commit it, and everyone
  171. who uses Airband in that project gets the same rules, in every agent. It can carry the team's own
  172. rules too, and they are added after Airband's:
  173. ```json
  174. {
  175. "writing": {
  176. "docs": true,
  177. "messages": true,
  178. "rules": ["Write British English.", "Name the owner of every action item."]
  179. }
  180. }
  181. ```
  182. The project's file wins over each person's setting. Your own writing skills and instructions win
  183. over both. The docs rules follow the ideas of controlled-language writing (ASD-STE100, Simplified
  184. Technical English). The message rules follow ADHD-friendly writing. Both are Airband's own short
  185. versions.
  186. ### Standups and AI spend
  187. Airband already keeps a record of every chat in every agent, so it can answer two questions no
  188. single agent can:
  189. ```bash
  190. airband standup # what your chats did yesterday and today, per project
  191. airband standup --days 7 # the week, for a weekly update
  192. airband spend # tokens in the last 7 days: by project, agent, ticket and chat
  193. airband spend --days 30 --json
  194. ```
  195. ```text
  196. Since Tue 10 Nov: 3.4B tokens in 17 chats (46k new input, 7.7M output, 3.4B cache reads).
  197. By project
  198. my-app 1.8B 54% 8 chats
  199. my-api 1.6B 46% 6 chats
  200. ```
  201. Ask an agent for "my standup" or "AI spend this month" and it uses these, then writes the update for
  202. you. Tokens are what each agent reported in its own files. Tokens per ticket are an estimate, because
  203. agents report tokens per reply, not per topic.
  204. ## How it works
  205. Airband sits beside your agents. It reads the session files they already write, keeps its own short
  206. records, and reaches each agent through two standard doors every agent has: a **hook** that runs after
  207. each reply, and an **MCP server** with the tools above.
  208. ```mermaid
  209. flowchart LR
  210. AGENTS["Your agents<br/>Claude Code · Codex · Gemini CLI"]
  211. SESSIONS[("Their own<br/>session files")]
  212. subgraph airband["Airband, on your computer"]
  213. HOOK["Hook<br/>runs after each reply"]
  214. MCP["MCP server<br/>map · flightlog · notes"]
  215. HOME[("~/.airband<br/>flightlogs · channels · inboxes · map")]
  216. EXT["VS Code extension<br/>Tower · Fuel · Map · Commands"]
  217. end
  218. AGENTS -->|write| SESSIONS
  219. AGENTS -->|after each reply| HOOK
  220. AGENTS <-->|tools| MCP
  221. HOOK -->|records and delivers| HOME
  222. MCP --- HOME
  223. EXT -->|reads| SESSIONS
  224. EXT --- HOME
  225. ```
  226. ### When two chats are connected
  227. ```mermaid
  228. sequenceDiagram
  229. autonumber
  230. participant A as Chat A (adds rate limiting)
  231. participant H as Airband hook
  232. participant L as ~/.airband
  233. participant B as Chat B (writes the tests)
  234. A->>H: reply finished
  235. H->>L: add A's new asks to its flightlog
  236. H->>L: leave a note in B's inbox (Ping, Brief or Full)
  237. Note over B: later, you send B a message
  238. B->>H: message about to be sent
  239. H->>L: take what is waiting in B's inbox
  240. H-->>B: your message goes in with A's note
  241. ```
  242. The note arrives with the next message you were sending anyway, so it costs no extra turn. The words
  243. are fenced and marked as information from another chat, never as instructions.
  244. ### What `npx airband` does
  245. ```mermaid
  246. flowchart TD
  247. START(["npx airband"]) --> FIND{"Which agents are<br/>on this computer?"}
  248. FIND --> CLAUDE["Claude Code<br/>tools · skills · hook · allow rule"]
  249. FIND --> CODEX["Codex<br/>tools · skills · hook · prompts"]
  250. FIND --> GEMINI["Gemini CLI<br/>tools · hook"]
  251. CLAUDE & CODEX & GEMINI --> BACKUP["Each settings file<br/>backed up before the change"]
  252. BACKUP --> CMD["Adds the airband command<br/>with the same package manager"]
  253. CMD --> DONE(["airband doctor:<br/>Everything works"])
  254. ```
  255. Run it again any time: it changes nothing that is already right, and replaces only Airband's own
  256. entries.
  257. ## Install
  258. ### The command line and every agent
  259. | Package manager | Set up, nothing installed first | Install the command |
  260. |---|---|---|
  261. | npm | `npx airband` | `npm i -g airband` |
  262. | pnpm | `pnpm dlx airband` | `pnpm add -g airband` |
  263. | Yarn | `yarn dlx airband` | `yarn global add airband` (Yarn 1) |
  264. | Bun | `bunx airband` | `bun add -g airband` |
  265. **Requirements:** [Node.js](https://nodejs.org) 20 or newer, and at least one of Claude Code, Codex or
  266. Gemini CLI. Works on macOS (Apple silicon and Intel), Windows 10 and 11, and Linux (x64 and Arm).
  267. Nothing is compiled for your computer.
  268. ### VS Code extension
  269. The Tower, Fuel, the Map and Commands live in the extension. It is not on the Marketplace yet;
  270. install it from source:
  271. ```bash
  272. git clone https://github.com/HarshBaldaniya/airband.git
  273. cd airband
  274. npm install
  275. npm run install:vscode
  276. ```
  277. Then reload VS Code (**Developer: Reload Window**). Needs VS Code 1.95 or newer.
  278. ### Claude Code plugin
  279. ```text
  280. /plugin install airband --marketplace HarshBaldaniya/airband
  281. ```
  282. ### Gemini CLI extension
  283. ```bash
  284. gemini extensions install https://github.com/HarshBaldaniya/airband --auto-update
  285. ```
  286. ## The airband command
  287. | Command | What it does |
  288. |---|---|
  289. | `airband` | Show what each agent has, and set up anything missing |
  290. | `airband doctor` | Check that everything works, with the exact fix for anything that doesn't |
  291. | `airband update` | Move to the newest version and refresh every agent (`--check` only looks) |
  292. | `airband remove` | Take Airband out of every agent (`--purge` also deletes its data) |
  293. | `airband notices off` | Hide Airband's lines in your agent's window (`on` shows them again) |
  294. | `airband find "rate limiter"` | Where something is in your code; also `outline`, `graph`, `overview` |
  295. | `airband diff #128` | What a pull request or branch changed: functions, their callers, the tests |
  296. | `airband standup` | What your chats did since yesterday, in every project (`--days 7` for a week) |
  297. | `airband spend` | Tokens spent by project, agent, ticket and chat (`--days 30`) |
  298. | `airband writing` | The writing rules agents get; `writing check <file>` checks a doc |
  299. | `airband changelog` | What changed in this version (`--all` for every version) |
  300. | `airband about` | Version, system, where it is installed, and the links |
  301. | `airband bug` | Open a GitHub issue with your version and system filled in |
  302. | `airband help <command>` | Options and examples for any command |
  303. `status`, `doctor`, `version` and `about` take `--json`. Setup takes `--agents claude,codex`,
  304. `--no-sharing`, `--no-command`, `--completion` and `--verbose`.
  305. <details>
  306. <summary><strong>Tab completion</strong></summary>
  307. Setup asks once whether to turn it on for zsh, bash or fish. For PowerShell, add
  308. `airband completion powershell | Out-String | Invoke-Expression` to your `$PROFILE`.
  309. `airband remove` takes it out again.
  310. </details>
  311. <details>
  312. <summary><strong>Updates</strong></summary>
  313. Airband checks npm for a newer version at most once a day and says so in one line; it never updates
  314. by itself. The check is off in CI, and with `AIRBAND_NO_UPDATE_CHECK=1` or `NO_UPDATE_NOTIFIER=1`.
  315. </details>
  316. <details>
  317. <summary><strong>The Map without VS Code</strong></summary>
  318. For CI and cloud agents:
  319. ```bash
  320. airband find "rate limiter" # ranked matches, path:start-end
  321. airband outline src/api/limits.ts # one level of a file or folder
  322. airband graph RateLimiter # who uses it, what it uses
  323. airband diff #128 # what a PR changed, who calls it, which tests reach it
  324. airband check docs # exits 1 when a doc names code that is gone
  325. ```
  326. `--in <folder>` points it at another project, and so does the name of one already mapped
  327. (`--in my-api`). The parsers for TypeScript, JavaScript and Python are
  328. built in; Go, Rust, Java, C#, Ruby and PHP are downloaded once, the first time a project has them,
  329. and used only if they match a fingerprint built into Airband.
  330. </details>
  331. ## Configuration
  332. Settings live under **Settings → Extensions → Airband**:
  333. | Setting | Default | What it does |
  334. |---|---|---|
  335. | `airband.contextSize` | `"standard"` | How much of a chat another chat receives when they are first connected: `compact` (~2k tokens), `standard` (~6k) or `full` (~15k). The rest is always in its flightlog. |
  336. | `airband.autoDeliver` | `false` | Give waiting updates to a chat as soon as it finishes, at the cost of an extra turn. Off: they wait for your next message, at no extra cost. |
  337. | `airband.codeMap.enabled` | `true` | Keep a Map of each open folder (about 1 MB for a large project). |
  338. | `airband.notices` | `true` | Show Airband's line when a chat starts and when other chats' work is added to your message. Shown to you only; no tokens. |
  339. | `airband.writing.docs` | `true` | Add the docs writing rules when a chat is asked for a doc, and check docs agents write. |
  340. | `airband.writing.messages` | `true` | Add the message writing rules when a chat is asked for a message. |
  341. | `airband.writing.beforeSend` | `true` | Check a message, PR or commit before an agent sends it, and hold it once to fix. |
  342. | `airband.writing.replies` | `false` | Ask every chat for short replies you can act on. |
  343. | `airband.backupFolder` | `""` | A folder to copy flightlogs and your own commands to every half hour, for example in iCloud Drive or Dropbox. |
  344. Without VS Code, the same choices are commands: `airband notices off`, `airband writing replies on`.
  345. A project's `.airband.json` sets the writing rules for everyone who works in it.
  346. <details>
  347. <summary><strong>Keyboard shortcuts</strong></summary>
  348. | Keys | Where | Action |
  349. |---|---|---|
  350. | `T` `U` `M` `C` `E` | Everywhere | Tower, Fuel, Map, Commands, Writing |
  351. | `/` | Tower, Map, Commands | Find a chat, a file or a command |
  352. | `N` | Tower | New Claude chat |
  353. | `1` `2` `3` `4` | Tower | Arrange by channel, time, agent, folder |
  354. | `0` | Tower, Map | Fit everything in view |
  355. | `F` | Tower, Fuel | Focus mode |
  356. | `Esc` | Everywhere | Close, clear or step back |
  357. Press `?` on any page for the full list.
  358. </details>
  359. ## Privacy and security
  360. - **Nothing is sent anywhere by Airband.** It reads the session files your agents already write and
  361. keeps its own data in `~/.airband`, readable only by you. No server, no account, no telemetry.
  362. - **Online for two things only:** a daily npm version check, and a language parser the first time a
  363. project needs one. `AIRBAND_OFFLINE=1` turns both off.
  364. - **Secrets stay out.** API keys, tokens and private keys pasted into a chat are removed before
  365. anything is recorded, shared or returned by a tool.
  366. - **Shared text is data, not orders.** What one chat sends another is fenced with a random tag and
  367. marked as information, so words in it can't pass for your instructions.
  368. - **No logins.** Airband never reads a login, token or key file.
  369. - **Standups, spend and the writing check stay on your computer.** They read the records Airband
  370. already keeps and the files agents write. Nothing is uploaded.
  371. - **Changes only Airband's own entries** in each agent's settings, after a backup; `airband remove`
  372. takes them all out again.
  373. What one chat shares with another becomes part of the receiving chat, so it goes to that agent's
  374. provider like anything else you type there. To report a vulnerability, see [SECURITY.md](SECURITY.md).
  375. ## Troubleshooting
  376. <details>
  377. <summary><strong>Start here: <code>airband doctor</code></strong></summary>
  378. It checks Node.js, Airband's files, and for each agent the tools, the skills and auto-sharing, and
  379. prints the exact fix for anything that isn't right.
  380. </details>
  381. <details>
  382. <summary><strong>A connected chat doesn't receive updates</strong></summary>
  383. Updates arrive with the chat's **next** message, not instantly (unless `airband.autoDeliver` is on).
  384. Check that auto-sharing is on with `airband doctor`. In Codex, type `/hooks` once and trust Airband's
  385. hook.
  386. </details>
  387. <details>
  388. <summary><strong>The Map is empty or out of date</strong></summary>
  389. Run **Airband: Read the code again for the map** in VS Code, or `airband map` in a terminal. The folder
  390. needs code in one of the supported languages.
  391. </details>
  392. <details>
  393. <summary><strong>Plan limits don't show for an agent</strong></summary>
  394. Fuel shows only what each agent reports. Codex's limits come from its chat records, so they appear
  395. after you have used Codex.
  396. </details>
  397. <details>
  398. <summary><strong>Moving from Crosstalk</strong></summary>
  399. Airband was called Crosstalk. `npx airband` moves a Crosstalk setup over by itself: its data, each
  400. agent's tools, hooks, skills and commands, Tab completion, and the old `crosstalk` command.
  401. </details>
  402. ## FAQ
  403. **Does it cost tokens?** Notes between chats are short (Ping is one line per ask) and travel with
  404. messages you were sending anyway. The agent tools add under 400 tokens of definitions.
  405. **Which agents are supported?** Claude Code, Codex and Gemini CLI.
  406. **Does it work in Cursor or Windsurf?** They are built on VS Code, so the extension should; they are not
  407. tested yet. Reports are welcome.
  408. **Do I need VS Code?** No. `npx airband` sets up the agents, the sharing and the tools on its own; the
  409. extension adds the boards.
  410. ## Contributing
  411. Issues and pull requests are welcome. [CONTRIBUTING.md](CONTRIBUTING.md) covers setup, how the code is
  412. laid out and how releases work.
  413. ```bash
  414. npm install
  415. npm run typecheck
  416. npm test # never touches your real ~/.airband, ~/.claude, ~/.codex or ~/.gemini
  417. ```
  418. ## License
  419. [MIT](LICENSE) © Harsh Baldaniya.
  420. Airband depends on packages under their own licenses; one, the Claude Agent SDK, is under Anthropic's
  421. terms. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
  422. Claude, Codex and Gemini are trademarks of their owners. Airband is an independent project, not
  423. affiliated with or endorsed by them.

Ratings and comments

Sign in to rate this skill.

Sign in

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