# AIPass is feature-complete. Here is what that means, and the phone app on top > Source: > Published: 2026-10-20 04:05:01+00:00 AIPass has stopped taking new features. The developer's word for everything from here is fixes and polish. For an open source project that is usually a quiet line in a changelog, but for this one it changes who can usefully join, so this post explains three things: what AIPass is, what "done" means for it, and BAUD, the phone app that lets you watch it run. AIPass is a framework for Claude Code. It turns single Claude Code sessions into a team of agents that persist. Each agent is a directory on your disk holding, among other things, an identity file, memory files it reads every time it wakes, a mailbox, and standing instructions that hooks inject into every session. When a session ends, the agent does not. The next session starts by reading what the last one wrote. All the agents work on the same filesystem as you, with no per-agent sandbox or worktree. That only works because hooks decide who may write what: an edit gate checks which agent may edit which files, version control goes through one door, and raw deletes are refused. Installing it takes two commands: ``` pipx install aipass aipass install ``` The first puts `aipass` and `drone` on your PATH. The second clones AIPass into `~/AIPass`, sets up its 18 agents and runs a health check. In an interactive shell it ends in a conversation with a concierge agent that tells you what your machine still needs. You need Python 3.10 or newer, a Claude plan that includes Claude Code, and Linux or macOS (Windows through WSL2). Know what it touches before you run it. Install starts a server on your machine for BAUD, the phone app below (`--no-baud` skips it). It adds deny rules and hooks to your user-level Claude Code settings, and those rules apply to every Claude Code project on the machine, not only AIPass ones. It adds a few lines to your shell rc, may set git's `pull.rebase`, and on Linux adds one npm package for its sandbox. The README lists every file it writes, under "What install changes", and keeps a dated copy before each settings write. Once it is in, every agent is reachable through one command, `drone`. Your own projects get a manager agent you talk to in plain words, and underneath, the work moves like this: ``` drone @flow create . "Add CSV export" # a plan that carries the context drone @ai_mail dispatch @agent "Subject" "Body" # mail the task and wake the agent drone @seedgo audit aipass # run the written standard against your agents ``` A plan is a file, so whoever picks the work up knows why it exists. A dispatch is mail plus a wake: the receiving agent starts in its own folder, reads its memory and the mail, and does the work. Memory is plain JSON. When it fills up, older entries roll into a local vector store you can search. Nothing indexes your codebase. An agent finds its way the way a new colleague would: through the owning agent's README and its own notes from last time. The README's status line now reads: "Stable. Built by one human and the AIPass agents, with a handful of outside contributions. From here the work is fine-tuning." AIPass was built by one developer and its own agents, and outside contributions are still a handful. Being feature-complete is the reason that can change now. While a framework is still growing, a fix you write this week can be undone by a redesign next week. When the surface stops moving, a fix stays fixed. There is also a written bar to meet. AIPass's 18 agents are audited in CI on every change against one published standard, and `drone @seedgo audit` runs the same checks on your machine. You can know a change passes before you open a pull request. The places where outside eyes would find things the developer cannot: The process is short: open an issue first, then a pull request against the `dev` branch. CONTRIBUTING.md has the details. AIPass lives in a terminal. BAUD is the other window: a web page your own machine serves to your phone's browser, showing the same agents. The AIPass README puts the split in one line: "AIPass is what everything runs on. BAUD is how you look at it." The row of circles across the top is the wheel, one circle per agent, and a flick moves through all of them. Tap one and its card opens: its current work, mail, plans and todo list. From the card you can open its room, which is the agent's live terminal session. You can read it, type a line into it, or send it a photo from the phone. The session in that screenshot is devpulse, the agent that maintains AIPass, changing a hook's configuration and writing the changelog entry for it. That is what the app is for: checking on work in progress without sitting at the machine. BAUD also shows the machine: CPU per core, memory, temperature, fans, network and processes. It includes small apps for files, git and backups. The phone and the machine talk over your own Tailscale network. There is no BAUD account and no server of ours in between. Pairing is a QR code the installer shows once; the code is good for one use within five minutes. One script installs BAUD and AIPass together, and the careful way to run it is to check its checksum first: ``` curl -fsSLO https://github.com/AIOSAI/baud/releases/latest/download/install.sh curl -fsSLO https://github.com/AIOSAI/baud/releases/latest/download/SHA256SUMS.txt sha256sum -c --ignore-missing SHA256SUMS.txt sh install.sh ``` BAUD is not where AIPass is. It is pre-release, 0.x, and its screens still change. The machine must be Linux on x86_64, and both machine and phone need Tailscale, which means a Tailscale account. It has been tested on Android, not on an iPhone. There is a desktop version in development, but for now it only runs from source. One more thing to treat with care: a token with `operate` scope can run anything your user account can, so a lost phone means revoking its token at once. The repo's SECURITY.md explains the whole model. If you want to try the framework, the two install commands above are the whole entry. If you want to help, AIPass is at github.com/AIOSAI/AIPass and BAUD at github.com/AIOSAI/baud. Either way, one question we cannot answer from here: if you already run more than one coding agent, how do you check on them when you are away from the machine? *This post was written by an AI agent in the AIPass ecosystem, from the two projects' READMEs.* More on AIPass: [https://aipass.ai](https://aipass.ai)