Agent Orchestration

Visual agent orchestration is the core of Kangentic’s agentic development environment. Instead of juggling terminal windows and manually managing coding-agent sessions, you control everything from a Kanban board.

Supported Agents

Kangentic orchestrates thirteen coding-agent CLIs side-by-side. Claude Code, Codex CLI, Gemini CLI, Grok Build, OpenCode, Qwen Code, and Kimi Code are the most tightly integrated: each has session resume plus a native session history file (or wire-protocol JSONL) that Kangentic parses for live telemetry and hands to the next agent on a handoff. Cursor CLI and GitHub Copilot CLI add session resume plus stream-based telemetry. Antigravity CLI and Factory Droid both resume and write a native session file, but do not stream live telemetry to Kangentic. Aider is simpler still: no session resume, and its chat history is parsed only for cost, though the file itself is readable enough to carry a handoff. Warp (Oz CLI) leaves nothing behind at all. A fourteenth adapter, Ollama, is different in kind: it drives a local LLM as single-turn chat rather than an agentic coder, useful for quick local-model runs inside the board flow.

Agent	Resume	Handoff Source	Default Permission	Notes
Claude Code (Anthropic)	✓	✓	Accept Edits	Resume via --resume <id> with caller-controlled session IDs. Event hooks injected via event-bridge.js. Supports Kangentic’s trust pre-approval dialog and the auto classifier permission mode.
Codex CLI (OpenAI)	✓	✓	Accept Edits	Resume via codex resume <id>, carrying the column’s permission mode, model override, and MCP wiring. Native rollout file (~/.codex/sessions/.../rollout-*.jsonl) parsed for handoff context. Directory trust is pre-approved per spawn directory (Codex keys trust on the repo root with no inheritance, so a worktree per task would otherwise prompt every time).
Gemini CLI (Google)	✓	✓	Accept Edits	Resume via --resume <id>. Reference-counted hooks in .gemini/settings.json. Native chat history (~/.gemini/tmp/<cwd>/chats/session-*.jsonl, .json on older builds) parsed for handoff context. Folder trust is pre-approved per spawn directory, since an untrusted folder disables every configured MCP server.
Cursor CLI	✓	-	Bypass Permissions	Resume via cursor-agent --resume="<id>". Detected as cursor-agent rather than Cursor’s short agent shim, which collides with the one xAI’s Grok CLI installs. Session IDs captured from the init event on Cursor’s --output-format stream-json NDJSON stream. Non-interactive mode is the default so ContextBar can resolve the model pill and resume works reliably. No hooks. Cursor does write a transcript, but Kangentic leaves it unread: its records are untimestamped and its stored text is wrapped in markup, so it cannot back a handoff or a delivery check.
GitHub Copilot CLI	✓	-	Accept Edits	Resume via --resume <uuid> with caller-controlled session IDs. Inline hooks in per-session config.json (preToolUse, postToolUse, agentStop, preCompact). Supports --plan and --yolo.
Grok Build (xAI)	✓	✓	Accept Edits	Deliberately Claude-compatible surface: caller-owned session IDs (--session-id new / --resume <uuid> re-enter), the full Claude-style hook set, and Kangentic permission modes passed through 1:1 via --permission-mode. Session store at ~/.grok/sessions/<cwd>/<id>/ parsed for live telemetry and lifetime usage. Sign in with grok login (a free tier works without signing in).
Antigravity CLI (Google)	✓	✓	Accept Edits	Google’s agy TUI. Resume via --conversation <uuid>, which works cross-directory; the conversation ID is captured from hook payloads. Brain-dir transcript parsed for the Transcript tab - no live telemetry. Shares ~/.gemini with Gemini CLI but keeps its own subtree, trust store, and hook schema. Sign-in is Google Sign-In inside the TUI (no login subcommand).
OpenCode (sst)	✓	✓	Build	Hook-driven activity via a plugin auto-loaded from .opencode/plugins/ (tool.execute.before/after, session.created, session.idle). Native session IDs (ses_<id>). Kangentic MCP injected via OPENCODE_CONFIG_CONTENT so the user’s opencode.json is never modified, and the plugin file is hidden from git through the repository’s local .git/info/exclude rather than by editing your tracked .gitignore. Auth state probed at ~/.local/share/opencode/auth.json. Permission selector exposes OpenCode’s native Plan and Build agents.
Aider	-	✓	Bypass Permissions	Edit-first / fire-and-forget. No session resume (relaunched fresh on re-entry) and no injected hooks. It does write .aider.chat.history.md in the working directory, which Kangentic parses only for session cost, but which a receiving agent can read in full on a handoff.
Qwen Code (Alibaba)	✓	✓	Auto Edit	Soft fork of Gemini CLI. Caller-owned session IDs via --session-id. Hook-based activity (BeforeModel / AfterModel / BeforeToolSelection) with PTY fallback. Worktree trust pre-populated to skip the Gemini-style folder-trust prompt.
Kimi Code (Moonshot AI)	✓	✓	Default	Caller-owned session IDs via --session <uuid>. Wire-protocol v1.9 JSONL at ~/.kimi/sessions/<hash>/<id>/wire.jsonl drives ContextBar (context %, token counts, tool events). --continue for resume-latest. Plan and YOLO modes supported. Auth state surfaced as a warning when ~/.kimi/credentials/ is empty.
Factory Droid	✓	✓	Default	Resume via droid --cwd <cwd> --resume <uuid>. PTY-only activity detection (silence timer + cursor-hide first-output marker). Session UUID captured from ~/.factory/sessions/<cwd-slug>/<id>.jsonl. Live telemetry is intentionally not exposed - run /cost or /context inside the Droid TUI. Autonomy is controlled in-band (Shift+Tab cycles low/medium/high).
Warp (Oz CLI)	-	-	Default	No session resume, no hooks, no native history file. Permissions are managed via Warp agent profiles (--profile), so the permission-mode labels are informational. Detection uses dump-debug-info rather than --version.
Ollama	-	-	Default (Chat)	Local LLMs via ollama run, as single-turn chat rather than an agentic coder: each spawn is one turn. No session resume, no hooks, no trust mechanism, no MCP wiring, no native history. A model argument is mandatory and picked from ollama list; run ollama run <model> in a Command Terminal for free-form multi-turn chat.

All fourteen adapters share the same detection pipeline: a user-configured override path (in Settings > Agent > CLI Paths) wins if set, otherwise which() discovers the binary on PATH, and on Windows the --version check is run through a shell so .cmd/.bat shims work. Claude Code additionally checks Homebrew fallback paths (/opt/homebrew/bin/claude, /usr/local/bin/claude, /home/linuxbrew/.linuxbrew/bin/claude) for the macOS Finder-launch case, where Electron doesn’t inherit the shell PATH. Kimi Code adds the uv tool install path (~/.local/share/uv/tools/kimi-cli/bin) for the same reason.

Pick a default agent in the Welcome screen’s detection grid (on first launch) or under Settings > Agent > Default Agent. Only installed CLIs are offered. You can also override the agent per-column (e.g., Claude for Planning, Codex for Executing) so a task moving between columns automatically switches agents. See Per-Column Customization.

When a column has handoff context enabled, Kangentic points the next agent at the previous agent’s native session history file so conversation context carries across even when the agent changes. It passes the real file path rather than a manufactured summary, and the receiving agent reads it directly.

What decides whether a handoff carries context is the outgoing agent, not the incoming one. Ten agents leave a readable native history behind: Claude Code, Codex, Gemini, Grok, Antigravity, OpenCode, Aider, Qwen Code, Kimi Code, and Factory Droid. Cursor, GitHub Copilot, Warp, and Ollama leave nothing Kangentic can hand on, so a task moving out of one of those starts the next agent with a pointer to git log instead of a transcript.

Any agent can be on the receiving end. A task moving into Cursor from Claude Code still hands Cursor the path to Claude’s transcript. Claude additionally gets a note that it can read the prior session through the kangentic_get_session_history MCP tool.

Remote OpenCode sessions

OpenCode running against a remote server has no local history file, so a handoff out of one degrades to Kangentic’s terminal-scrollback fallback rather than the native file.

Kanban-Based Control

Each task card on the board represents a potential or active coding-agent session. The default board columns map to agent states:

Column	Role	What Happens
To Do	Holding area	No agent runs here. Moving a task here kills its session.
Planning	Plan mode	Spawns the configured agent in plan mode. The agent creates a plan, then auto-moves to Executing.
Executing	Auto-spawn	Spawns the configured agent in its default permission mode. The agent works on the task.
Code Review	Auto-spawn	Agent keeps running. Add a message telling it how to review the work.
Testing	Auto-spawn	Agent keeps running. Add a message telling it how to test the work.
Merge	Auto-spawn	Agent keeps running. Add a message telling it how to ship the work.
Done	Archive	Suspends the session (preserving context) and archives the task.

The What Happens column tracks the session, not the conversation: none of these column names reach the agent, and a column only speaks to a running agent through its Message to agent field, which ships empty on every default column. What the Agent Is Told lists exactly what crosses over.

Drag a card between columns to change its state. All columns except To Do and Done are fully customizable - see Settings for per-column options.

Spawning Agents

When you move a task to an active column, Kangentic:

1. Creates a new git worktree for the task (if worktrees are enabled)
2. Launches the configured agent CLI (Claude Code, Codex, Gemini, Cursor CLI, GitHub Copilot CLI, Grok Build, Antigravity CLI, OpenCode, Aider, Qwen Code, Kimi Code, Factory Droid, Warp/Oz CLI, or Ollama) in that worktree
3. Passes your task’s title and description, wrapped in a <task> envelope, plus any attachment paths, as the initial prompt (see What the Agent Is Told)
4. Connects the agent’s I/O to a terminal tab (see Terminal)

The agent starts working immediately. You can watch its progress in real-time or switch to other tasks.

Card Indicators

Task cards show real-time status:

Indicator	Meaning
Pulsing spinner	Agent is actively thinking or running tools
Static icon	Agent is idle - finished, waiting, or needs input
Context bar	Token usage and context window percentage
”Queued” label	Waiting for a concurrent session slot to open

Suspending and Resuming

One of Kangentic’s key capabilities is the ability to suspend and resume agent sessions:

• Suspend - Move a task to Done. The session is saved (conversation/session ID preserved), the agent process stops, and system resources are freed.
• Resume - Unarchive a completed task and drag it to an active column. The agent picks up where it left off with full conversation context. Session resume is supported for Claude Code, Codex, Gemini, Cursor, GitHub Copilot, Grok, Antigravity, OpenCode, Qwen Code, Kimi Code, and Factory Droid. Aider, Warp, and Ollama relaunch fresh on re-entry.

This means you can run more agents than your system can handle simultaneously - just rotate them in and out of active columns.

Tip

Suspending is non-destructive. The agent’s full conversation history, working directory state, and worktree are all preserved. You can resume hours or days later.

Session Queue

When the max concurrent sessions limit is reached, new sessions are queued automatically. Queued tasks show a “Queued” indicator on their card. When a running session exits or is suspended, the next queued session promotes automatically (FIFO order). Queue promotion is reentrancy-safe - if a promotion triggers another session exit, the queue processes correctly without race conditions.

Configure the session limit in Settings under the Behavior tab. You can also set the overflow behavior to queue (default) or reject via the agent.queueOverflow setting - see Configuration Reference.

Concurrent Sessions

Kangentic supports running multiple agents simultaneously. Each agent runs as a separate CLI process with its own:

• Git worktree (isolated file system)
• Terminal session
• Conversation history
• Working state

The Kanban board gives you a clear view of what’s running, what’s queued, and what’s completed.

Board Search and Filtering

The board toolbar (the row with the Board/Backlog toggle) includes a docked search box and Filter button, shared with the Backlog view:

• Search - type to live-filter the visible columns by task title and description. Press Ctrl+F / Cmd+F to focus the search box from anywhere on the board.
• Filter - click to open the filter popover and toggle priority levels (None, Low, Medium, High, Urgent) and labels from the project’s label set.

Active filters show a count badge on the Filter button. Filters combine with the search query - a task must match every active criterion to be visible. Click “Clear all filters” to reset.

For cross-cutting search beyond the current board, press Ctrl+Shift+F / Cmd+Shift+F to open Quick Find. It searches tasks (active and archived), backlog items, session events, and registered projects in one overlay.

Task Descriptions

Write task descriptions the same way you’d prompt Claude Code directly. Be specific:

Fix the race condition in the WebSocket connection handler.
The issue is in src/ws/handler.ts - when two clients connect
simultaneously, the session map can get corrupted.
Add proper locking and write tests for the concurrent case.

The more context you provide, the better the agent will perform. You can also attach files, set priorities, and add labels - see Creating Tasks for details.

Agent-to-Board Integration (MCP)

Kangentic includes a built-in MCP (Model Context Protocol) server that gives agents tools to interact with the board while they work. This is enabled by default.

When an agent discovers follow-up work - bugs, refactoring opportunities, or new features - it can create tasks directly on the board without you manually entering each one. Agents can also search existing tasks to avoid duplicates, read session transcripts, and view board status for context.

The server exposes 63 tools across five groups:

Group	What it covers
Tasks	Create, list, search, find, update, move, reorder, delete, and link PRs for individual tasks
Board	Columns, the backlog, project discovery, usage stats, and unified search
Sessions	Session records, transcripts, activity events and interval history, dev-server port reservations, and handoff context
Browser Automation	Open, close, and drive a task’s embedded Browser pane (navigate, screenshot, click, type, eval)
Diagnostics	Read-only inspection: logs, crashes, process metrics, IPC traffic, worktrees, and SQL

See the MCP Server reference for the full catalogue with a description of every tool.

In v0.15.0 the MCP server was rewritten to use an in-process streamable HTTP transport (replacing the earlier file-based bridge), reducing latency and making command dispatch atomic. Each session is still isolated to its project.

Cross-Project Tool Calls

Added in v0.17.0. Every task, backlog, and session tool accepts an optional project parameter. Pass a project name or path and the tool resolves against that project instead of the calling session’s own project. This lets a task running in Project A look up or create work in Project B without leaving its session. kangentic_get_current_task is intentionally excluded because it resolves the agent’s own CWD/branch, so cross-project lookup makes no sense there.

To disable the MCP server, toggle MCP Server off in Settings or set mcpServer.enabled to false in the config file - see Configuration Reference.

Next steps

Next: Creating Tasks - turn the orchestration model into actual work on the board.

See also:

• Custom Workflows - automate transitions between columns
• Git Worktrees - how Kangentic isolates each agent
• Settings - per-column agent overrides and permission modes