Tool

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.

Works with githubclaudecodexopencodeaider

91
Spark score
out of 100
Updated 13 days ago
Source checked Sep 10, 2026
Version 2.2.0

Add 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

01

Launch Claude, OpenCode, Codex, or any agent CLI in isolated terminal tiles with automatic worktree branching

02

Track agent completion states with visual dock indicators and OS notifications when background agents finish

03

Navigate between terminals using MRU cycling, command palette search, or numbered shortcuts

04

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 source

Reports

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 icon

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.

Kolu running in a browser workspace with the dock, terminal tiles, and code panel visible

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

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 in
website/; 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.