Run multiple AI coding agents in parallel terminal tiles
Terminal app with real xterm.js tiles on an infinite 2D canvas and a dock, for running many agent CLIs (Claude, Codex, Grok, Pi) at once.
2.2.0Add to Favorites
Why it matters
Manage many concurrent AI coding agent sessions across repositories and worktrees in a visual terminal workspace that tracks agent state, git context, and file references without locking you into any single model or CLI.
Outcomes
What it gets done
Launch Claude, OpenCode, Codex, or any agent CLI in isolated terminal tiles with automatic worktree branching
Track agent completion states with visual dock indicators and OS notifications when background agents finish
Navigate between terminals using MRU cycling, command palette search, or numbered shortcuts
Click linkified file references in terminal output to open code at specific lines in the side panel
Source
Get it from source
Spark does not host a copy of it.
Open sourceReports
Agent outcome reports
No reports yet
Overview
Kolu
kolu is a terminal app for running many things at once: real xterm.js terminal tiles arranged on an infinite 2D canvas with a dock that tracks every one, working with any agent CLI (Claude, Codex, OpenCode, Grok, Pi) rather than a single vendor's chat UI. Sessions are durable across tab closes and restarts, and the workspace can be reached remotely or extended across machines. Use it when running several terminal-based coding agents or shells in parallel and needing to see and switch between them; the typical setup is a Mac window onto a headless Linux box, installed and run via Nix.
What it does
kolu is a terminal app built for running many things at once: real xterm.js terminal tiles arranged freely on an infinite 2D canvas, with a dock that keeps track of every one so none gets lost. It works with any agent CLI you run in a shell - Claude, Codex, OpenCode, Grok, Pi, or anything else - rather than wrapping one model behind its own chat UI.
When to use - and when NOT to
Use it when you're running several terminal-based coding agents or shell sessions in parallel and need to actually see and switch between them - the canvas/tile/dock model is built for arranging many real terminals and finding any one instantly, and an agent-attention view shows which agents are working, finished, or waiting for input. It's explicitly agent-agnostic: there's no agent registry or adapter to configure, and kolu instead auto-detects the repositories, agents, and sessions you already use rather than asking you to set them up twice. Sessions are durable - shells and agents stay alive across tab closes, server restarts, and redeploys - and kolu can reach across machines: access it remotely from another device, add another machine onto the same canvas, and forward a port so a dev server running on any connected machine opens directly in your browser. The typical setup is a Mac window onto a headless Linux box, though it can also run as a home-manager service on Linux or macOS directly.
Inputs and outputs
Input is whatever shell commands or agent CLI invocations you run inside a terminal tile; output is that terminal's live output, rendered in the browser workspace alongside every other tile on the canvas. The workspace itself - tile layout, session state, and live PTYs - persists across browser tab closes and server restarts rather than resetting.
Integrations
nix --refresh run github:juspay/kolu -- web
Requires Nix with flakes enabled; running that command starts kolu and serves the workspace at http://127.0.0.1:7681. If the first run starts compiling instead of downloading, kolu's binary cache needs to be enabled first. Under the hood, the browser workspace, web shell, workspace state, and live PTYs run as separate processes that can fail and restart independently rather than taking the whole session down together.
Who it's for
Developers running multiple terminal-based AI coding agents or shell sessions side by side who want one persistent, remotely reachable workspace to arrange and monitor all of them, without being locked into a single vendor's agent or chat interface.
Source README
kolu
kolu is a terminal app built for scale: real xterm.js tiles on an infinite
2D canvas, with a dock that never loses one - for claude, codex,opencode, grok, pi, or anything you run in a shell, especially many at
once.
Documentation · Start · From a Mac · Contributing · AGPL-3.0-or-later
Run it
Install Nix with flakes enabled, then:
nix --refresh run github:juspay/kolu -- web
Open http://127.0.0.1:7681. Continue with
Start, the Quickstart,
and First Five Minutes.
The usual setup is a Mac window onto a headless Linux box.
If the first run starts compiling instead of downloading, enable kolu's
binary cache - see
Deployment.
Why kolu
Unlike an agent command center that wraps one model behind its own chat UI,
kolu keeps the terminal as the universal interface. Any agent CLI works out of
the box, and a plain shell is always one command away.
- Agent-agnostic. No agent registry, adapter, or vendor lock-in.
- Auto-detected, zero setup. kolu learns from the repositories, agents, and
sessions you already use instead of asking you to configure them twice.
Read the full Philosophy.
Explore
- Canvas, tiles, and dock - arrange real
terminals freely, then find any one instantly. - Agent attention - see which agents are
working, finished, or waiting for you. - Durable sessions - keep shells and agents
alive across tab closes, server restarts, and redeploys. - From another device and
Add another machine - reach kolu from a
phone or laptop, bring other machines onto the same canvas, and
forward a port so a dev
server on any of them opens in your browser. - Deployment - keep kolu running as a
home-manager service on Linux or macOS.
The complete feature guides and command reference live at
kolu.dev. This README is the map.
Architecture
Kolu splits the browser workspace, web shell, workspace state, and live PTYs
across processes that fail and restart independently. See the canonical
Architecture page for the daemon stack, wire
protocol, data flow, and package map.
Development
nix develop
just dev-auto
just test
See Developing kolu for local instances, cleanup, and
checks; kolu CI documents the multi-platform pipeline.
Bug fixes, build/CI fixes, documentation changes, and behavior-preserving
refactors are welcome as direct PRs. New user-facing features need a merged
proposal first. See CONTRIBUTING.md.
The marketing site, product docs, blog, and changelog live inwebsite/; its README covers authoring and
deployment.
Named after கோலு, the
tradition of arranging figures on tiered steps.
FAQ
Common questions
Discussion
Questions & comments · 0
Sign In Sign in to leave a comment.