Sweet as agent management.
Run your coding agents side by side and see at a glance which one needs you. Claude Code, Codex, Cursor, Pi, Muse, Grok Build, OpenCode and Copilot, across every project and git worktree you have, from one terminal or one desktop window. They keep working when you close it. Native on Windows, no WSL, no tmux. Azure DevOps tasks, branches and pull requests sit beside the agents working on them.
Keys · Commands · Sessions · Configuration · How it works · Windows port · Changelog
Windows 10 1809+ or 11 (x64 or ARM64), in PowerShell 5.1 or 7:
irm https://raw.githubusercontent.com/JayRichh/kete/main/install.ps1 | iexIt puts kete.exe in %LOCALAPPDATA%\kete\bin, with bro.exe beside it (Kete's old name, the same
program), and adds that folder to your user PATH. When the latest release has nothing for your CPU,
it builds from source with cargo install and tells you. Run it again to update.
Desktop app: on x64, install.ps1 installs it too. Open it with kete desktop.
The desktop app goes in per user, with no admin prompt, into %LOCALAPPDATA%\Programs\Kete (from the
release's kete-desktop-x86_64-setup.exe). The installer isn't code signed yet, so Windows
SmartScreen may warn the first time it runs; choose More info, then Run anyway. To skip it,
set KETE_NO_DESKTOP=1 first, or:
& ([scriptblock]::Create((irm https://raw.githubusercontent.com/JayRichh/kete/main/install.ps1))) -NoDesktopUninstall it from Settings → Apps ("Kete"); that leaves kete and your data alone.
macOS and Linux:
curl -fsSL https://raw.githubusercontent.com/JayRichh/kete/main/install.sh | shIt installs kete and bro into ~/.local/bin (set NEBULA_INSTALL_DIR to change that), and
builds with cargo install --git when no release matches. kete upgrade runs it again for you.
You need git and at least one agent CLI on your PATH. Kete runs the agents; it doesn't ship them.
gh is optional and turns on the GitHub pull request and issue views.
On Windows, kete ssh, kete tunnel, kete browser and kete upgrade aren't there yet, and say
so. To update, run the installer again.
Kete used to be called Bro. bro still works, as the same program. The first time kete runs it
moves your data from %LOCALAPPDATA%\bro to %LOCALAPPDATA%\kete (profiles, settings, projects) and
says so once. If Bro's daemon is still running, Kete uses it where it is and moves things after
kete kill or a restart. The installer takes the old bro\bin folder off your PATH and updates its
bro.exe to the new build. Run kete setup terminal to turn your "Bro" Windows Terminal profile
into a "Kete" one.
kete add C:\code\my-app # or, from inside the repo: kete add .
kete # open the TUI; the daemon starts on its own
kete desktop # or the desktop app, on the same sessionsPress p, type a task, Enter. Press Ctrl+N in the box first to give it a worktree of its own.
Press q to leave: the sessions keep running, and kete brings you back to them.
One sprint, start to finish, in kete. Synthetic demo data: the repos, tasks, accounts and pull requests are made up.
1. The grid. A tab per project, a band per worktree with its pull request, the selected session's terminal below.
2. A new task. p opens the quick prompt: project, worktree, harness, model and profile, with the account's usage.
3. The orchestrator. F10 starts one agent that reads the sprint and spawns a worker per task across both repos.
4. A review. The orchestrator opens a worker for you to review: terminal, diff, history and pull request.
5. The board. Shift+K lays every session out in five lanes: Running, Needs you, Review, Ship
and Done. The scope chip in the header says what it shows (all, a repo, a worktree, an account).
6. Accounts. Shift+U shows each account's 5h and weekly use, when it resets, and whether it is signed in.
kete desktop opens Kete in a native window over the same daemon as the TUI, so both show the same
sessions and closing either stops none of them. It follows the OS between the Workshop light and
dark themes; Ctrl+Shift+L cycles system, light and dark.
The screenshots below use synthetic demo data: the repos, people, tasks and pull requests are made up.
The strip across the top counts across all repos: how many sessions need you, are running or are
unread. Under it, one row per repo, the repos with something waiting on you first. Each row holds its
session tree: an orchestrator, the agents it started, and their subagents, indented under it, with
status as a square and a word. A session that needs you carries an ember bar down its left edge.
Shift+K swaps to the board, the same sessions in five lanes (Running, Needs you, Review, Ship and
Done). The scope chip in the header narrows the board, the overview and the counts to a repo, a
worktree or an account, and its x shows everything again. Pick a session to open its live terminal
in a split beside the overview.
Review and ship. Opening a Review card docks its worktree's diff against the base beside the
board, with a verb row: Reply (Space), Open PR or View PR (Alt+P), Merge (Alt+M), Archive
(Alt+A) and Delete worktree (Alt+W), the same keys in both apps. Dropping a Review card on Ship
opens the pull request composer (GitHub through gh, Azure DevOps through its API), and dropping a
Ship card on Done opens the merge confirm. A lane the agent owns (Running, Needs you) refuses a drop
and says why. The same verbs are on every card's menu: Create pull request, Merge pull request, Open
pull request and Focus here, which narrows the scope chip to the card's worktree.
Tasks lists the current sprint's work items under their parent stories, with your open items or
everyone's a click away, and any iteration or team you pick. Start task on one names a branch
from your initials and the title (jari/ledger-csv-export), cuts it into a new worktree from the
default branch, can assign the task to you and set it to Active, and can start an agent there with a
prompt built from the task. The sprint is cached, so it still reads offline.
Branches groups the repo's branches by the person prefix in their names, yours first. Each one
shows whether it is in sync, ahead or behind, local only, remote only or gone, and the task, pull
request and session it belongs to. From a branch: check it out to a worktree, diff it against
main, start a draft pull request, or delete it locally.
New pull request fills Changes from the branch's commits, can ask the branch's session to write the Summary, and links a task you search for by title or id. Policy notes (link a task, add a reviewer) say what is missing before you create it; "n/a" opts out of either. The branch's diff sits beside the form, side by side, inline or as replacements. Pull requests are created as drafts.
Pull requests lists yours and the ones waiting on your review. A pull request shows its task, each branch policy's status, every reviewer's vote and the comment threads. Publish a draft, vote, and reply to a thread from there, and read its changes in the same diff view.
The orchestrator is one agent that watches every repo for you: it reads the other sessions, sends
them follow-ups, starts workers in fresh worktrees and asks you to review them when they are ready.
0 or F10 (or the item above Repos in the rail) opens its view: every session it started, in
any repo, as one tree with a repo and branch chip on each row, beside its chat. With none running,
the same place offers Start orchestrator with a harness, profile, model and effort. The quick
prompt sends it follow-ups while its view is up.
When it asks for a review, a notice says so without taking the focus. Open shows a review sheet
with the session's terminal, its diff, its history and its pull request (the Azure DevOps review
when the repo lives there). On the overview, a session the orchestrator started in another repo
carries a from ◆ Orchestrator chip. See Orchestrator.
Settings (Ctrl+,, or the gear at the bottom of the rail) edits the same config.json as the
terminal app: General, Sessions, Appearance, Agents, Project, Experimental and Hotkeys, plus the
window's own Desktop tab, your agent presets and your profiles. A change reaches a running kete
within a few seconds, and sessions the window starts take the Agents tab's model and effort.
Ctrl+K opens the command palette: jump to any repo, worktree, session or pull request, what needs
you first, or run any action. ? lists what you can do to the focused row, each with its key, and F1 every
key. Right-click a session, card or repo (or press
Shift+F10) for the terminal app's card menu: follow-up, restart, duplicate, move, rename, archive,
delete, run and stop, new terminal, open in editor, new worktree.
The quick prompt along the bottom takes a task, Enter starts it, and Shift+Enter adds a line.
While it has the focus, a row above it picks the model, effort, profile and agent preset, and
whether the session gets a new worktree.
kete ship does what the board's Ship lane does, on the checkout you are in or any worktree Kete
knows with --project <name> and --worktree <branch>. GitHub goes through gh, Azure DevOps
through its API. Git never asks for a sign-in (no prompt, no credential window, ssh in batch mode):
a missing one is an error that says how to sign in.
kete ship status # the forge, branch, base, unpushed commits and the PR
kete ship pr --draft # push and open a draft, title suggested
kete ship merge --method squash --delete-branchThe Tasks, Branches and Pull requests views work on any repo whose git remote is on
dev.azure.com or *.visualstudio.com (HTTPS or SSH). Kete reads the organisation, project and repo
from the remote.
There is nothing to set up. Kete reuses the sign-in you already have: first Git Credential Manager
(the one git fetch uses), then the Azure CLI (az account get-access-token). It asks for no
personal access token, keeps the token in memory only, and never writes it to disk.
When neither has a sign-in, the view says so: run git fetch once in the repo, or az login. When
your organisation asks you to sign in again (MFA, conditional access, an expired login), the view
shows Sign in again, which runs az login (for the organisation's tenant when Kete knows it)
and then reloads.
kete ado does the same from a terminal or an agent, on the repo you are in, or any repo Kete
knows with --project <name> (and --worktree <branch> for one of its worktrees):
kete ado tasks # the sprint's tasks
kete ado start-task 4211 # branch, worktree, task set active, and an agent on it
kete ado prs # your pull requests, and the ones waiting on your review
kete ado pr create --task 4211 # a draft pull request from this branchkete ado pr <id>, vote and reply read and answer one. pr create follows the desktop
composer's rules, never pushes the default branch, and needs --worktree or --source with
--project. It never signs in for you: with no sign-in it says to sign in from the desktop app or
run az login. See Commands.
You start three agents in three terminal tabs. Five minutes later you don't know which one is waiting
on a permission prompt, which one finished, and which one is still thinking. Kete puts a status dot
on each session instead: every session is a card, the cards sit in a band per checkout under a row of
project tabs, and each tab counts its sessions' dots. A red ●1 on a tab tells you where to look.
| A daemon that owns the terminals | Close the TUI and come back tomorrow: the agents never stopped, and their scrollback replays when you attach. On Windows it talks over a per-user named pipe and runs sessions on ConPTY. |
| Status at a glance | Yellow mid-turn, blue finished and unseen, green finished and read, red waiting on you. On every card, and counted on every project tab. |
| A task box | p opens the quick prompt: type the task, Enter, and an agent is on it. Project, worktree, harness, model and profile are each a picker that keeps your text. |
| Real git worktrees | Ctrl+N in the box sends the launch to a fresh git worktree, so two agents never edit the same checkout. |
| A board | Shift+K lays the sessions out in five lanes: Running, Needs you, Review, Ship and Done. Enter on a Review card docks its diff against the base with a verb row, and dropping a card on Ship or Done opens the pull request or merges it. |
| A diff viewer | g shows the worktree's changes side by side, inline or as replacements, with word-level highlights. Stage a change with Ctrl+y or discard it with Ctrl+x. |
| GitHub pull requests and issues | Kete asks gh what's open. v lists pull requests, i lists issues, and either can start an agent on one. |
| Find, grep, browse | f finds a file, F runs git grep, b opens the tree browser, all scoped to the worktree. |
| Themes | Kete Workshop dark (the default) and light, One Dark and One Light, auto to follow the OS, or vscode to take VS Code's palette. |
| Agents that drive Kete back | Ask a session to "do this in a worktree" and it runs kete worktree. "Show me the file" runs kete open. "Start a new session that..." runs kete spawn. |
| Account usage | Shift+U lists every account with its 5h and weekly use, when each resets and whether it is signed in. The quick prompt's profile field and each session card carry the same numbers. |
| One orchestrator chat | F10 starts the one pinned orchestrator agent (pick a harness and profile) or brings it back full-screen, with every other session as a chip across the top in attention order. It lists, reads, messages and starts sessions across projects, and opens a review of any of them: terminal, diff, history and PR. |
| Key | What it does |
|---|---|
p |
quick prompt: type a task, Enter starts an agent (Ctrl+N inside for a new worktree) |
j / k, h / l |
walk the worktree bands, then the cards in one |
Enter, Ctrl+` |
step into the session's terminal, and hand the keys back |
/ |
jump to any project, worktree, session or pull request, what needs you first |
Shift+K |
the board: Running, Needs you, Review, Ship, Done |
Shift+← / Shift+→ |
on the board: the card onto the lane beside it (Review to Ship opens the pull request) |
Alt+P / Alt+M / Alt+A / Alt+W |
in a review: the pull request, merge, archive, delete the worktree |
g |
diff viewer |
f / F / b |
find file, git grep, tree browser |
v / i |
pull requests, issues |
w / Shift+W |
open the worktree's dev server in a browser, or screenshot it |
F10 |
orchestrator chat: start it, open it, and F10 again for the grid |
Shift+U |
accounts: usage bars, resets, login state, switch a profile on or off |
s |
settings, where every key can be rebound |
q |
leave; the sessions keep running |
The full list is in Keys.
| Harness | CLI |
|---|---|
| Claude Code | claude |
| Codex | codex |
| Cursor | cursor-agent |
| Pi | pi |
| Muse | muse |
| OpenCode | opencode |
| Grok Build | grok |
| GitHub Copilot CLI | copilot |
Install the CLI and pick it in the quick prompt's Tab picker. You can add more in config.json;
see Configuration.
Two Claude subscriptions, or a work and a personal Codex login: each one is a profile with its own config dir, and sessions run on whichever you pick.
kete profile add main --harness claude --use-default --default # the login you have
kete profile add max2 --harness claude # a second one
kete profile login max2 # sign it inIn the quick prompt, Ctrl+A steps through the harness's profiles.
Kete reads each account's 5h and weekly use (a Copilot account's monthly allowances) and each
session's context: from Claude's status line, Codex's session logs and Copilot's logs and quota.
Shift+U in the terminal, the rail's Accounts list in the window and kete profile list
show it, with when each window resets and whether the account is signed in. A session's row and card
show its context (ctx 42%) and how often it has compacted. kete profile disable <name> (or the
switch beside it) keeps a profile out of launches that name none.
Account spread (Settings, Sessions) picks the profile for a session that names none: failover
stays on the default until its 5h or weekly use reaches a threshold, then moves to the next enabled
profile; least_used takes the one with the least use; manual (the default) always takes the
default.
For Claude, Kete starts each session with a status line of its own (--settings, nothing written
into your repo). It runs your own statusLine after it, or prints ctx 34% · 5h 21% · wk 3%. It
takes the place of Claude's footer hints; Settings, Sessions, Usage status line turns it off.
See Profiles.
Whakaoho (wake-up) starts an account's 5-hour window at an hour you pick, so it resets earlier in your day: at 05:00 Kete sends one tiny prompt to haiku under that account, with your own subscription. It is off by default and set per account, in the window's rail (Whakaoho), the terminal's accounts overlay (its Wake view) or the command line; a Windows scheduled task runs it with Kete closed. It shows your usual hours from Kete's sessions and suggests the hour that gives the most fresh windows inside them.
kete wake set max2 --at 05:00 # on, every day at 05:00 (or --at suggested)
kete wake status # schedules, next and last wake-ups, the suggestion
kete wake max2 --dry-run # what would happen nowSee Commands.
Every worktree gets its own block of localhost ports (3000, 3010, 3020, ...), handed to its
sessions as PORT, KETE_PORT and KETE_PORT_1... (and the same under BRO_PORT), so two
checkouts' dev servers never fight. A port a session is listening on shows on its worktree's band as
:3010 ●. w opens it in Chrome, Edge or Firefox. See Localhost ports.
File lists and tabs mark each file with its type's icon. They are Nerd Font glyphs, so the terminal needs a Nerd Font; without one, Kete draws a two-letter tag in the same colour.
kete setup terminal --dry-run # what it would do, and the diff of settings.json
kete setup terminal # install JetBrainsMono Nerd Font, add a "Kete" profileIt installs the font for your user only (no admin), and adds a Kete profile to Windows Terminal
that runs kete with Kete's icon, that font and the Kete Workshop colour scheme. A "Bro" profile
from an earlier bro setup terminal becomes the Kete one. It backs settings.json up first and
keeps its comments, and a second run changes nothing.
| Windows | macOS | Linux | |
|---|---|---|---|
| Settings and database | %LOCALAPPDATA%\kete\data |
~/Library/Application Support/dev.kete.kete |
~/.local/share/kete |
| Runtime (pidfile, socket) | %LOCALAPPDATA%\kete\run |
$XDG_RUNTIME_DIR/kete or /tmp/kete-<uid> |
same as macOS |
A project's run and open commands live in .kete.json at the root of the repo. Kete still reads
.bro.json, then .nebula.json, when a checkout has no .kete.json. Environment overrides keep
their NEBULA_* names.
cargo build --release # target/release/kete and target/release/bro (.exe on Windows)
cargo testThe desktop app is its own Cargo workspace under desktop/, kept out of the root one so the core
build never compiles Tauri. It needs Node 20+ and, on Windows, the WebView2 runtime Windows 11 ships:
cd desktop
npm ci
npm run tauri build # desktop/target/release/kete-desktop (.exe on Windows)
# plus, on Windows, bundle/nsis/Kete_<version>_x64-setup.exe
# (elsewhere: npm run tauri build -- --no-bundle)On Windows, npm run e2e in desktop/ drives the built window end to end: tauri-driver over
msedgedriver (matched to the installed WebView2 and fetched from Microsoft into desktop/e2e/.tools),
a real daemon in temp dirs, temp repos, and the Windows suite's scripted fake agent as Claude. It
builds kete, the fake agent and a debug kete-desktop first; npm run e2e:run runs the flows
again without building. Nothing touches your own Kete data.
kete desktop looks for kete-desktop beside kete, then (on Windows) in
%LOCALAPPDATA%\Programs\Kete, then on PATH. The app starts its daemon through kete on your
PATH, so install kete first.
The crates keep their upstream names (nebula-core, nebula-daemon, nebula-tui, nebula) so
rebasing on nebula stays cheap. The rebrand is applied by scripts/rebrand.sh, which is safe to run
again after a rebase.
A kete is a woven flax basket in te reo Māori. This one holds your agents, their work and its scope.
Kete is a fork of nebula by AgentSystemLabs. nebula is © Cody Seibert and released under the MIT license; Kete keeps that license and notice. See LICENSE.
The file icons' associations and colours come from
Material Icon Theme by Philipp
Kief (MIT), and their glyphs from Nerd Fonts (MIT), vendored by
scripts/icons/gen-icons.mjs with Material Icon Theme's license notice in the generated
icons_table.rs. kete setup terminal downloads JetBrainsMono Nerd Font (SIL Open Font License
1.1) from the Nerd Fonts release; Kete does not ship it.