Drag a card.
An agent starts.

Make a column move do the work. Auto-commands fire on entry with template variables filled from the task, a plan-exit target advances cards automatically when planning ends, and transition actions chain scripts or PRs on the way out. Permission modes travel with the column too: read-only while planning, accept edits while executing.

See which agents are thinking or idle, right on the card, with per-agent activity detection via native hooks where available and PTY fallbacks where not. Desktop notifications fire when an agent needs your attention.

One overlay watches every project on your machine: live and recently finished sessions in cards, a table, or a dense list, each with a glimpse of the agent's latest output. Click through to any task's full detail without switching projects.

Track tokens, cost, and burn rate across every project, agent, model, and effort level. Filter by any time range, watch spend by week or cumulatively, and drill into a per-project ledger with cost share, dollars per million tokens, and top agent.

Each agent runs in its own git worktree: parallel development without branch conflicts. When work is ready, the built-in Changes panel opens a split or inline diff viewer with file tree, a commit graph, and a Markdown preview, one click from the task card.

Close the laptop mid-run and nothing is lost: session data is written incrementally to the local database, so even a hard crash preserves everything up to the moment it died. On relaunch the board comes back as you left it - running agents auto-resume with full context, orphaned sessions are detected and recovered, and sessions you paused on purpose stay paused. Suspend to Done today, resume next week.

Hand work between agents without losing context. When a card moves from a Claude plan column to a Codex execute column, the next agent starts with the full history of what came before. Any agent can receive a handoff; whether context carries depends on the outgoing agent leaving a readable history behind.

One size never fits all: deep models are wasted on rote steps, and cheap ones fall over on hard ones. Route the right model to each stage - Opus at xhigh for Planning, Sonnet for Executing, a different agent entirely for Code Review - and drop effort where the work is easy. Save whole ladders as named Board Profiles a task can ride. Kangentic live-applies changes as cards cross columns: no restart, no manual /model commands, tokens spent where they pay.

Every project carries its own defaults: agent, model, effort, permission mode, base branch, and worktree behavior, separate from machine-wide settings. A searchable settings panel filters every tab by keyword with per-tab match counts, so the option you want is a few keystrokes away.

Stage work in a dedicated backlog before it hits the board. Tag items with custom labels and colors, rank them on a fully-customizable priority scale, and batch-promote a week's worth of work to any column in one move. The tags keep working after promotion: filter the board by label or priority, let agents query them through the MCP tools, and pull items in from your other project boards.

Agents that self-organize. A running session gets MCP tools to create tasks, move cards, add or remove columns, search prior sessions, and queue follow-up work - even steer another task's running agent with a message. A planning agent can hand a backlog to an executing agent without you touching the board.

Press Ctrl+Shift+F / Cmd+Shift+F and one overlay searches everything on your machine: tasks, backlog, session events, projects, and every past agent conversation, by keyword or on-device semantic memory. Land on the exact turn where you solved something before, no API key, and your agents can recall it too through the board's MCP tools.

Every session gets a real terminal: xterm.js with WebGL-accelerated rendering and full scrollback that survives restarts in the local database. Ctrl+V / Cmd+V pastes your clipboard, text or image - an image is saved out and handed to the agent as an explicit readable reference, more reliable than the CLI's own clipboard handling. Beside it, the Activity tab distills raw output into a structured event feed: tool calls with their files, idle moments, task lifecycle - what every agent is doing, without the noise.

Ephemeral, quick-access agent sessions: press Ctrl+Shift+P / Cmd+Shift+P over any board and start typing, no task card needed. Ideal for one-off jobs like filing and reorganizing tasks through the built-in MCP tools. Run up to four at once, tiled side by side with draggable seams, and the layout persists across projects and restarts.

A live telemetry strip under every terminal: model, session cost, token counts, tool calls, elapsed time, and the context-window fraction with a progress track. Claude sessions add rate-limit meters for the five-hour window and weekly quota, reset times a hover away, and the profile, model, and effort pills double as pickers, per task, mid-session.

Point a sandboxed Chromium pane at any URL inside the task dialog, draw annotations, pick DOM elements, and submit the rendered frame plus context to the active agent as a multi-modal prompt. The built-in MCP browser tools work the other way too: agents can screenshot, inspect, and click the same pane themselves, so 'look at this area, make the font bigger' is a working instruction.

Hold your push-to-talk button, talk, release: local speech-to-text drops your words wherever you were typing, the agent's terminal or any field in the app, transcribed on-device with a streaming preview and a refinement pass. The binding (a mouse button by default, any key chord if you prefer), punctuation, language, and auto-submit are all configurable.

Runs entirely on your desktop (Windows, macOS, Linux, and WSL). Your boards, tasks, and transcripts live in a local database, not on a Kangentic server. No OAuth, no wrappers, no API proxies: Kangentic launches the native Claude Code, Codex, Gemini, Cursor, Copilot, Grok, Antigravity, OpenCode, Aider, Qwen Code, Kimi Code, Droid, Warp, and Ollama CLIs you already have, with your own logins and subscriptions. Just the real CLIs, the way each vendor intended.