CCC vs Kandev vs Inter-Session Messaging for Parallel Claude Code

Running 10–50 Claude Code sessions simultaneously is no longer an edge case — it's where serious parallel agent work lives. The problem isn't launching sessions; it's that Claude Code has no native mechanism to see session state at a glance, prevent agents from duplicating work, or route context between running sessions. Three independent open-source tools shipped in the same week to address exactly this gap: CCC (a Kanban-style session manager), Kandev (a workflow control plane with human gates), and an inter-session messaging plugin. This post compares all three and gives you a concrete setup path for each.

TL;DR: If you need visual oversight of 30–50 sessions with GitHub issue sync, use CCC. If you need defined multi-step workflows with explicit human checkpoints before critical operations, use Kandev. If you need autonomous session-to-session coordination so agents can signal each other without a human in the loop, use the inter-session messaging plugin. All three complement each other and can be layered.

Why parallel session orchestration is suddenly a real problem

The pain signal is unambiguous. As one developer wrote in their r/ClaudeAI post about the inter-session messaging plugin: "I have 26 CC sessions opened right now. CC does not support inter-session messaging so I have to be the message bus."

That quote captures the structural bottleneck precisely. At some point, the developer becomes the coordination layer between agents — and that does not scale. Three sessions is manageable. Ten is a context-switching nightmare. Twenty-six means you spend more time routing context than shipping code.

MindStudio's analysis of multi-agent command centers frames the same problem from first principles: without a coordination layer, you lose track of progress, duplicate effort, issue conflicting instructions across sessions, and the coordination overhead eats the productivity gain. The tools documented below each attack a different slice of this problem.

Three independent implementations converging on the same gap in a single week is a strong signal. Addy Osmani called the same pattern when Vibe Kanban launched: a project management layer for coding agents isn't a novelty — it's infrastructure that's been missing. CCC, Kandev, and the inter-session plugin are three different answers to that same gap, with different tradeoffs.

The three tools

CCC — Kanban board for session state (30–50 sessions)

CCC gives you a visual Kanban board purpose-built for managing parallel Claude Code sessions. At its core, it's a session state tracker that brings project management primitives to your agent fleet.

Features from the r/ClaudeCode launch post:

• Kanban columns representing session state (Backlog → In Progress → Review → Done)
• GitHub issue sync — assign issues directly to sessions
• Git worktree support — each session gets an isolated working tree
• Session state visibility across 30–50 parallel sessions

The core value is situational awareness. When you have 30 sessions running, you need to see which are blocked, which are in review, and which have diverged — without SSH-ing into each one individually. As Nimbalyst documented for Claude Code Kanban boards, at scale a visual board isn't a nice-to-have; it's the only way to maintain overview without becoming a full-time orchestrator yourself.

Best for: High-parallelism workloads across independent tasks where the primary pain is losing track of which session is doing what.

Kandev — Workflow control plane with human gates

Kandev takes a different architectural approach. Rather than visualizing existing sessions, it defines workflows upfront as code and runs agents through those stages — with explicit human checkpoints blocking progression at critical steps.

Features from the r/coolgithubprojects launch thread:

• Parallel worktree agents — each agent runs in its own isolated git worktree
• Workflow definitions with human gates — agents pause and request approval before proceeding at defined stages
• Multi-environment execution — run the same workflow locally, in CI, or on remote machines

The human gates are the differentiating primitive. Rather than approving individual tool calls (Claude Code's native permission model), Kandev lets you define approval points at the workflow level. An agent might write feature code autonomously, then pause at the "merge to main" gate until you explicitly release it. This connects directly to the patterns covered in how to build human-in-the-loop approval gates for AI coding agents — the difference is that Kandev encodes those gates into the workflow definition rather than relying on per-tool hook configuration.

Best for: Structured pipelines where specific stages require human judgment before agents proceed, especially workflows touching destructive operations (deploys, database migrations, force pushes) or cross-repo coordination.

Inter-session messaging plugin — autonomous session coordination

The inter-session messaging plugin attacks the root cause of the "message bus" problem directly: it gives each Claude Code session a mailbox, letting sessions send and receive messages from each other without a human routing them.

The plugin enables:

• Signaling between sessions when tasks complete
• Fan-out patterns: a coordinator session decomposes work and dispatches subtasks to named worker sessions
• Fan-in patterns: worker sessions report completion back to a coordinator that blocks until all workers finish
• Context passing between sessions (file references, partial results, handoff notes)

This enables architectures that were previously impossible. An "architect" session can decompose a large task into subtasks, dispatch each to a worker session, and block until all workers report completion — without a human doing any of the routing. The Kanban-driven multi-agent orchestration walkthrough on YouTube demonstrates the appeal of this coordinator/worker model visually.

Best for: Complex interdependency graphs between sessions, or any workflow where session A's output needs to become session B's input without human mediation.

Comparison table

The last row matters: these tools are not mutually exclusive. A production setup might use CCC for visual oversight, Kandev for critical workflow gates, and the inter-session plugin for session-to-session communication — all running simultaneously.

Setting up each tool

Prerequisites

• Claude Code installed and authenticated (claude CLI available on PATH)
• Node.js 18+ for tooling
• Git 2.5+ with worktree support
• Multiple project subdirectories or repos if running parallel sessions on independent tasks

Optional but recommended: Grass for mobile approval forwarding — covered in the section below.

Option A: Setting up CCC

CCC is launched from your workspace root and surfaces a Kanban UI you can keep open alongside your sessions.

1. Install CCC and run it from the root of your workspace:

# Install CCC (check the r/ClaudeCode thread for the actual package name)
npm install -g ccc-claude

# Launch in your workspace root
ccc start

2. For each task you want to track, create a session card in the CCC interface. CCC creates a git worktree per card automatically.

3. Launch each Claude Code session in its assigned worktree directory:

cd ~/projects/worktrees/task-auth-refactor
claude

4. CCC polls each session's state and updates the board. Sessions that complete move to the "Review" column; blocked sessions surface in "Blocked" where you can intervene.

5. To sync GitHub issues, add your PAT to CCC's config and map issue numbers to session cards.

Verification: All active sessions should appear in the "In Progress" column with live state updates. Completing a task should let you drag the card to "Review" without touching individual terminals.

Option B: Setting up Kandev

Kandev's core abstraction is a workflow definition file — similar in spirit to a GitHub Actions workflow, but running locally against Claude Code agents.

1. Install and initialize Kandev in your repo root:

npm install -g kandev
kandev init

2. Define your workflow stages in kandev.yml. Each stage specifies the agent prompt, the worktree, whether it runs in parallel with other stages, and whether it requires a human gate before the next stage starts:

# kandev.yml — representative structure, check Kandev docs for exact syntax
workflow:
  - name: implement-feature
    agent: claude-code
    prompt: "Implement the auth refactor per the spec in ./docs/auth-spec.md"
    worktree: feature/auth-refactor
    parallel: true

  - name: implement-tests
    agent: claude-code
    prompt: "Write integration tests for the auth refactor"
    worktree: feature/auth-tests
    parallel: true

  - name: review-gate
    type: human-gate
    message: "Both agents complete. Review diffs before merge?"

  - name: merge
    agent: claude-code
    prompt: "Merge feature/auth-refactor and feature/auth-tests into main"
    worktree: main

3. Run kandev start. Kandev spawns agents for all parallel stages simultaneously, each in its own worktree.

4. When an agent reaches a human gate, execution pauses across the blocked stage. Approve it via the Kandev UI or CLI to release the next stage.

Verification: The Kandev status view should show each stage and its state (running, waiting, gate-blocked, complete). A gate-blocked stage will show the gate message and an Approve/Deny prompt.

Option C: Setting up the inter-session messaging plugin

The plugin adds a shared message queue that Claude Code sessions can write to and read from. Installation and basic setup from the r/ClaudeAI post:

1. Install the plugin and register it in your Claude Code settings:

# Install the inter-session messaging plugin
npm install -g cc-inter-session

# Register in Claude Code's MCP settings
cc-inter-session register

2. Each session gets a named mailbox. You assign names via your agent prompts or per-session configuration.

3. Write coordinator/worker prompts that use the messaging primitives:

<!-- Coordinator session CLAUDE.md -->
You are the coordinator agent. Your job:
1. Read the feature spec at ./docs/feature.md
2. Decompose it into three parallel subtasks
3. Send subtask A to mailbox "worker-1", subtask B to "worker-2", subtask C to "worker-3"
4. Wait until you receive completion signals from all three mailboxes
5. Aggregate their outputs into SUMMARY.md and notify mailbox "review-queue"

<!-- Worker session CLAUDE.md (repeat for each worker with its name) -->
You are worker-1. On startup:
1. Check your mailbox for a task from the coordinator
2. Implement the task
3. Send a completion signal to mailbox "coordinator" with a summary of what you did

4. Launch the coordinator session first, then each worker session. The message queue handles synchronization.

Verification: You should see messages in worker mailboxes when the coordinator dispatches, and completion signals flowing back when workers finish. The coordinator session should block correctly on the fan-in wait and resume only after all workers report.

Common issues and fixes

Sessions duplicating work (no worktree isolation): Without git worktrees, two sessions can write to the same files simultaneously — and one silently wins. Always pair parallel sessions with worktrees. The full conflict prevention architecture is covered in how to keep parallel coding agents from stepping on each other.

Kandev gates blocking indefinitely: Human gates require the Kandev UI or CLI to be running and connected. If you step away from your desk without a mobile approval mechanism in place, gates will block until you return. See the Grass section below.

Inter-session messages dropped or delayed: File-based message queues break when sessions run on different machines. If you're distributing sessions across VMs or remote servers, configure the plugin to use a networked queue backend (Redis is a common choice) rather than the default local file store.

CCC showing stale session state: CCC polls sessions to track state. If a session stalls internally, the board can show stale "In Progress" state with no indication that the agent is stuck. For workflows where stall detection matters, Kandev's explicit stage completion model is more reliable than CCC's polling model.

How Grass makes parallel session orchestration work from anywhere

CCC, Kandev, and the inter-session plugin solve coordination and visibility at the session level. All three share a gap: when you're away from your desk, approval gates block, diffs pile up unreviewed, and sessions that need redirection keep spinning. Grass fills that gap.

Grass is a machine built for AI coding agents — an always-on cloud VM with a native iOS app that gives you real-time session visibility, permission forwarding, and diff review from your phone. It's agent-agnostic by design: Claude Code, Codex, Open Code, and the next agents all run as first-class citizens.

How it works with each orchestration tool:

• With CCC: While CCC shows session state on your laptop dashboard, Grass streams agent activity to your phone in real time. When a session in your Kanban board needs a human decision on a tool call (a file write, a bash command), Grass surfaces it as a native approval modal — one tap to allow or deny, wherever you are.

• With Kandev: Kandev's human gates block at the workflow level. Paired with Grass on an always-on VM, those gates forward to your phone. You approve the gate remotely; Kandev releases the next workflow stage automatically. No laptop required.

• With inter-session messaging: The plugin enables autonomous session coordination, but when the coordinator session itself hits a tool it can't proceed without, Grass catches that permission request and surfaces it on your phone in real time.

Setup takes under five minutes:

# Install the Grass CLI
npm install -g @grass-ai/ide

# Start in your workspace root — where your parallel sessions will run
cd ~/projects
grass start --caffeinate  # --caffeinate prevents macOS sleep for 8 hours

# Output:
# Starting grass server...
#   workspace: /Users/you/projects
#   port: 32100
#   available agents: claude-code, opencode
#
#   Local Network  http://192.168.1.42:32100
#   [QR code]
#   Scan to open on your phone

Scan the QR code, open your workspace in the Grass iOS app, and you have real-time streaming output, diff review, and permission gates for every session running in that workspace. For overnight or multi-day workloads, pair Grass with a Daytona cloud VM — sessions run in the cloud, your laptop is irrelevant, and Grass keeps you connected from anywhere. The Grass multi-agent dashboard guide covers the full workflow for monitoring multiple simultaneous sessions from mobile.

Your API key stays yours (BYOK — Grass never touches it). One surface. Every agent. Always on.

FAQ

What is the difference between CCC and Kandev for managing parallel Claude Code sessions?

CCC is a visual Kanban board for tracking session state across 30–50 existing sessions — it provides visibility into what each session is doing without changing how they run. Kandev is a workflow control plane that defines how sessions run upfront, with explicit multi-step stages and human gates at critical checkpoints. Use CCC for situational awareness at scale; use Kandev when you need structured pipelines with approval gates before specific operations execute.

How does inter-session messaging work in Claude Code?

Claude Code has no native inter-session communication. The inter-session messaging plugin adds a shared message queue that sessions can write to and read from. Each session gets a named mailbox; your agent prompts instruct sessions to send messages when tasks complete and to block on incoming messages before starting dependent work. This enables coordinator/worker patterns where agents signal each other directly, removing the human as the routing layer.

Can I use CCC, Kandev, and the inter-session plugin together?

Yes — they address different layers of the orchestration problem and compose naturally. CCC provides the visual board for situational awareness, Kandev defines workflow stages and gates for structured pipelines, and the inter-session plugin handles session-to-session communication for autonomous coordination. Running all three gives you visibility (CCC), workflow governance (Kandev), and autonomous session communication (inter-session plugin).

What happens to parallel Claude Code sessions when I close my laptop?

Without persistent infrastructure, sessions terminate when your laptop sleeps or the terminal closes. The standard fix is tmux on a remote server or an always-on cloud VM. Grass provides the latter — sessions live in a Daytona-powered cloud VM and persist regardless of your laptop state, with mobile access via the Grass iOS app.

How do Kandev human gates work in practice?

When an agent reaches a stage marked as a human gate in the Kandev workflow definition, it pauses and waits for explicit approval before the next stage starts. You approve via the Kandev UI or CLI. If you're running Grass alongside Kandev on a remote VM, gate requests forward to your phone — you approve remotely, and Kandev releases the next stage automatically.

What to try next

If you're managing more than five parallel sessions and spending time routing context between them, start with CCC — it's the lowest-friction entry point and the visual board alone eliminates most of the "which session is doing what" overhead. If your sessions follow defined pipelines with critical checkpoints before destructive operations, add Kandev on top. If you're running 20+ sessions with complex interdependencies between them, the inter-session messaging plugin is the piece that lets agents coordinate autonomously at scale.

For all three setups, Grass removes the constraint that you have to be at your desk. Get started with Grass in five minutes — install the CLI, scan the QR code, and you have mobile oversight for whichever orchestration backend you pick. Free tier, no credit card, sessions on an always-on cloud VM.