Agency

A desktop app for running coding agents in parallel, each isolated in its own
git worktree. Watch them live, review what they changed, merge the good ones.

Built with Tauri 2: a Rust backend (crates/) and a React

• Vite frontend (ui/).

What it does

• Runs many agents at once, each in its own git worktree, so they never
  collide over a working tree or a branch.
• Terminal-first. Every agent is a real PTY you can watch, interrupt, and
  type into. Nothing is hidden behind a chat box.
• Bring your own agent. Claude Code, Codex, Cursor, Copilot CLI, OpenCode,
  Gemini CLI, Kimi Code, Crush, Hermes, Pi, DeepSeek Harness. Agency detects
  what is on your PATH.
• Review and merge in the app. Per-worktree diff review, conflict
  resolution, and merge back to your base branch.
• A local issue tracker, plain markdown under .agency/issues/, that agents
  can be dispatched against and can file follow-ups into.
• Loops. Run one agent to convergence with hard attempt, wall-clock and
  token caps, rather than racing many.

Privacy

Agency does no first-party data collection: no analytics, no telemetry, no
account, no vendor backend. There is no server of ours for it to talk to.
Outbound traffic is only what you initiate, and the coding agents are third
party and talk to their own providers.

The one exception is the update check: on launch Agency asks GitHub's public API
for the latest release tag and compares it to the running version. It sends no
identifiers, and it downloads and installs nothing. If a newer version exists,
Agency dots the Settings button and offers a link; you install the new version
yourself, whenever suits you. Turn it off in Settings ▸ Diagnostics ("Check for updates on
launch") and Agency makes no network calls of its own at all.

Installing (beta)

Every release carries a DMG for
macOS and packages for Linux.
getagency.dev/download links the DMG; the
Linux packages are on the release page until the download page carries them.

macOS

1. Download the latest Agency_*.dmg.
2. Open the DMG and drag Agency to Applications.
3. Launch it. The build is signed and notarized, so it opens without a Gatekeeper
   prompt. If macOS says the app is damaged, you have an unsigned local build
   rather than a release DMG.

Linux

Each package comes for x86_64 and arm64; uname -m says which you have. The
.deb spells them amd64 and arm64, the .rpm and the AppImage x86_64 and
aarch64. Install from a terminal, in the folder you downloaded to.

• Debian and Ubuntu: the .deb.

  sudo apt install ./Agency_<version>_amd64.deb
  

  Use apt rather than opening the file in Ubuntu's App Center, which can stall
  at "Installing" on a downloaded package.

• Fedora: the .rpm.

  sudo dnf install ./Agency-<version>-1.x86_64.rpm
  

• Arch, and any other distribution: the AppImage. It carries its own
  libraries and needs only FUSE from the system.

  chmod +x Agency_<version>_amd64.AppImage
  ./Agency_<version>_amd64.AppImage
  

  If it stops with a libfuse error, install your distribution's FUSE package
  (fuse2 or fuse3, whichever the message names), or run it with
  APPIMAGE_EXTRACT_AND_RUN=1 set, which needs no FUSE at all.

  There is no AUR package yet, and the AppImage does not add itself to your
  application menu.

apt and dnf fetch WebKitGTK and the other libraries Agency needs. A newer
package installs over an older one the same way, and sudo apt remove agency or
sudo dnf remove agency takes it out again. The packages are not signed.

First launch

Agency asks you to pick a default agent, then you add a project by pointing it
at a local git repo.

What changed in each release is in CHANGELOG.md.

Requirements

• macOS 11 (Big Sur) or later on Apple Silicon. Release builds are aarch64
  only; there is no Intel or universal build yet.
• Linux with glibc 2.34 or later, on x86_64 or arm64. That is Ubuntu 22.04,
  Debian 12 and anything newer, and current Fedora and Arch.
• Git. If you do not have it, Agency offers to install it: through Homebrew
  or the Command Line Tools on macOS, and through your distribution's package
  manager on Linux, where the desktop asks for your password.
• At least one coding-agent CLI from the list above. Agency offers to install
  a missing one for you; most install via npm install -g, so those need
  Node.
• gh (optional) - needed only for the GitHub import
  and PR flows.

What Linux does less well. The tray shows how many agents are running in its
tooltip, not beside the icon. And Agency cannot tell when you click one of its
notifications on Linux, so the click does not take you to the run it was about.

Reporting problems

Settings ▸ Diagnostics has your exact version, an "Open logs" button, and a link
to file an issue. Attaching the log makes a bug report far easier to act on.

Integrations

Agency launches other people's programs, and installs none of them without you
asking. This is the whole list of what it can reach for.

Coding agents. The eleven CLIs above are third-party software under their
own licences, and each talks to its own provider with your credentials. Agency
finds the ones on your PATH and runs them in a PTY. Pick one that is missing
and it offers that vendor's own install line, then runs it in a terminal you can
watch: npm install -g <package> for most, and the vendor's shell installer for
Cursor (cursor.com) and Kimi Code (code.kimi.com). The exact commands are in
ui/src/agents.ts. Agency never updates an agent itself; it
shows you the command that matches how yours was installed.

gh. Optional, and only for the GitHub import and PR flows. Agency shells out
to the gh you already have, with the login you already gave it.

graphify (knowledge graph). Off by default, enabled per project in Settings
▸ Knowledge graph. It builds a code-knowledge graph with
graphify and gives every agent an MCP
server pointed at it, rebuilt after each clean merge. When the tooling is
missing, Agency shows you the install script before it runs anything:
uv from Astral's own installer, then uv tool install "graphifyy[mcp,openai,anthropic]". Code is indexed locally. Documents
in the corpus are read by the model backend you choose, so a build sends those
to that provider, and nothing is built until you ask for it.

GitHub's releases API, for the update check described under
Privacy. One request at launch, and you can turn it off.

Building from source

Prerequisites

• Rust (stable; built with 1.96). Install via rustup.
• cargo-tauri - cargo install tauri-cli.
• pnpm 11+ and Node 22+. Use pnpm, not npm; the lockfile is pnpm's.
• On macOS, the Xcode Command Line Tools - xcode-select --install.
• On Linux, the WebKitGTK development packages. On Debian and Ubuntu:
  sudo apt install libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev libsoup-3.0-dev pkg-config. Tauri's
  prerequisites page has the
  equivalents for other distributions.

pnpm --dir ui install   # once
./dev.sh                # builds the agency-termd sidecar, then launches the app

Use ./dev.sh, not cargo tauri dev. Tauri's beforeDevCommand starts Vite
only. It does not build the agency-termd daemon, and the app fails at startup
without one. A dev build keeps its own data directory and daemon socket, so it
never disturbs an installed Agency.

Cutting a release, and building the Linux packages yourself, is in
docs/releasing.md.

Repository layout

Project status

Agency is in beta, built and maintained by one person as a working tool. Issues
are welcome and read; responses are best-effort. PRs are considered
case-by-case: see CONTRIBUTING.md before starting anything
substantial, and SECURITY.md for anything sensitive.

Nearly every feature here started as a written design and a task-by-task plan,
and those documents stayed in the repo. docs/ is that record.

License

Apache-2.0, see LICENSE. The name "Agency" is not licensed; see
NOTICE.

The app also contains Rust crates, JavaScript packages and two typefaces written
by other people. THIRD-PARTY.md lists every one of them with
its licence text, and ships inside the app as well, under Settings ▸ About ▸
Third-party notices. It is generated by scripts/third-party.py; CI fails a
pull request that changes a dependency without regenerating it.