Claude Code Channels Integration

What just changed

Before Channels

Claude is a text box. You type, it responds.
Your tools can't call Claude. Claude can't call your tools.
API access means open metering: $800-2,000+/mo.
Every API call is a new cold start. No persistent context.
You pay per token. More agents = more cost.

After Channels

Claude calls your tools. Your agents call Claude.
Bidirectional: one protocol, interchangeable access.
Fixed cost: $100 or $200/mo. You know the number.
Persistent sessions. Claude keeps context across tasks.
Cohort manages the spend intelligently for you.

The API model charged you per token and you had no idea what the bill would be.
The Channels model gives you a fixed budget and Cohort makes every dollar count.

Bidirectional tool use

This is the part that's genuinely unprecedented. Claude Code can call any tool your system exposes. And your system can push work into Claude Code's session. Same protocol. Same session. No API keys, no token counting, no surprise bills.

Claude calls your tools

Through Cohort's MCP integration, Claude Code gains access to your entire agent ecosystem. Need a security review? Claude calls the security agent. Need content strategy? Claude calls the content strategist. Each agent brings persistent memory, domain expertise, and contribution scoring -- capabilities Claude doesn't have alone.

                    // Claude Code, mid-task, decides it needs security review:

                    Tool call: cohort_roundtable("Review this auth flow for vulnerabilities",

                      agents: ["security", "python_dev"])

                    // Security agent responds with findings from its persistent memory

                    // Claude applies the fixes, in the same session, with full file context

Your agents call Claude

Cohort's local agents run at 104 tok/s on your GPU for free. But some tasks need frontier reasoning -- complex refactors, multi-file architectural changes, nuanced code review. Your agents escalate those tasks to Claude Code through the Channel, and Claude executes them in a persistent session with your repo fully loaded.

                    // Cohort's coding orchestrator encounters a complex refactor:

                    Escalate to Claude Code: "Refactor auth middleware to support

                      both JWT and session tokens. 14 files affected."

                    // Claude Code receives the brief with channel context

                    // Executes the refactor across all 14 files

                    // Reports back with structured results + diff

Fixed cost, not open metering

The API model was a blank check. You paid per token, per call, per agent turn. A busy week could cost $500. A runaway loop could cost thousands. Channels changes the economics entirely.

$0

Cohort Local

23 agents, roundtables, briefings, code queue. All on your GPU. Channels-ready.

$100-200

Claude Code Subscription

Fixed monthly cost. You pick the plan. Cohort manages the spend intelligently.

$800-2,000+

Open API (the old way)

Per-token billing. Unpredictable. Every agent turn costs money. Every runaway loop costs more.

How Cohort manages your fixed budget

1

Local-first triage. 95% of agent work runs on your GPU at zero cost. Only tasks that genuinely need frontier reasoning get escalated to Claude Code.

2

Context distillation. Before escalating to Claude, local models pre-process and condense the context. Claude gets a structured briefing instead of raw data -- so every interaction uses minimal capacity.

3

Session persistence. Claude Code keeps context across tasks. No cold starts. No re-reading your entire repo for each request. One session handles many tasks efficiently.

4

Safeguards. Unified 3-tier response gate (emergency rate limits, heuristic scoring, session-aware orchestrator gating), meeting mode stakeholder controls, and graceful degradation back to local models. Your fixed spend stays fixed.

How it works under the hood

// The lifecycle of a Channels task
Cohort agent enqueues a task brief --> in-memory request queue (per-channel)
Channel plugin polls Cohort HTTP API --> claims the request
Plugin pushes task as channel event --> Claude Code receives it
Claude reads the brief, executes the work --> your files, your repo
Claude calls reply tools (complete/progress/error) --> structured results
Plugin posts back to Cohort --> triggers self-review, agent reviews
Waiting agent gets the response --> continues execution

Per-channel session isolation

Each Cohort channel gets its own independent Claude Code session. A security audit in #security-review doesn't share context with a website build in #web-project. Up to 5 simultaneous sessions, with priority eviction when you need a 6th.

Context hydration

When a new Claude Code session starts for a channel, Cohort summarizes the channel's recent discussion using your local LLM and injects it as a structured briefing. Claude joins the conversation mid-stream without anyone having to catch it up.

Auto-launch and idle reaping

Sessions start on demand when work arrives and shut down automatically after 10 minutes idle. No manual process management. If a session dies, its claimed requests are automatically failed and re-queued.

Three-tier context degradation

Tier A: Local LLM summarizes last 50 messages into ~1000 tokens. Tier B: Heuristic filter, ~4000 chars. Tier C: Last 20 messages as-is. Each tier falls back to the next if the local model is unavailable.

One IDE. Both systems. Zero switching.

Claude Code runs in the VS Code terminal. Cohort's agent team runs in the VS Code sidebar. They share the same repo, the same MCP tools, and the same channel sessions. You never leave the editor.

my-project -- Visual Studio Code

Cohort Agents

#security-review

Meeting: ACTIVE (3 agents)

Phase: VALIDATE | Turn 6/15

#api-redesign

Discussion: 5 agents, compiled

#code-queue

2 tasks queued, 1 in review

security_agent ACTIVE

python_developer ACTIVE

qa_agent ACTIVE

ceo SILENT

Terminal -- Claude Code
claude> Reviewing auth middleware changes from #security-review...
Tool: cohort_meeting_next_speaker(session: "s_sec_review")
  Recommended: qa_agent (score: 0.82, phase: VALIDATE)
Tool: post_message(channel: "security-review")
  "Auth flow reviewed. 2 issues found: missing rate limit
   on /token endpoint, JWT expiry not validated server-side.
   @qa_agent please verify the fixes in auth_middleware.py"
Tool: cohort_meeting_demote(agent: "security_agent", to: "silent")
  [OK] security_agent -> SILENT (work complete, yielding floor)
3 files modified, 0 issues remaining.
Session active | Meeting mode ON | Next: qa_agent

Cohort's agent sidebar (left) and Claude Code's terminal (right), sharing the same channel session.

Claude writes code

Claude Code edits files, runs tests, and commits -- using Cohort's MCP tools to consult agents, check scores, and manage meeting dynamics.

Agents coordinate

Stakeholder gating controls who speaks. Phase detection tracks progress. The 3-tier response gate prevents loops. All visible in the sidebar.

You stay in flow

No browser tabs. No terminal switching. Channels, meetings, tasks, and reviews -- all in the same VS Code window you're already coding in.

First integration, day one

Anthropic shipped the protocol at 3 AM. By end of day, Cohort had full session management running through it.

00 AM MT -- Anthropic ships Claude Code Channels (research preview)
03 AM MT -- Cohort integration committed. Agent pipeline operational.
45 AM MT -- Working checkpoint. CLI module, agent enrichment, context hydration.
11 AM MT -- First multi-round agent roundtable via Channels.
38 PM MT -- Per-channel session management with auto-launch and idle reaping.
06 PM MT -- VS Code extension panel for session management shipped.

                03:00 AM MT, one week later -- Open-source launch. Full platform public.
            

Why it took three hours, not three weeks

MCP-native architecture. Cohort's entire tool surface is already MCP. Channels are MCP servers. The plugin was a thin bridge -- no architecture changes needed.

Request/response queue already existed. Cohort's code queue has a full lifecycle state machine. The Channel plugin just polls it. No new infrastructure.

Agent orchestration was done. Unified 3-tier response gate, meeting mode with stakeholder gating, compiled roundtables, deliverables preprocessing -- all production-tested. Channels needed a transport layer, not new logic.

What Claude Code gets through Cohort

When Claude Code runs with Cohort's channel plugin, it gains access to the full ecosystem via MCP tools:

23

Specialist Agents

Security, QA, Python dev, web dev, content strategy, documentation, analytics, marketing -- each with persistent memory

73

CLI Commands

Queue management, meeting control, health checks, model settings, rate limits, agent decisions -- all available as slash commands

104

Local tok/s

Claude can delegate bulk work to your local GPU via /delegate. Your hardware does the heavy lifting; Claude does the thinking.

57 tools Claude Code gains through Cohort

Every tool available via MCP the moment a Channel session starts. 54 from the Cohort API server + 3 from the Channel plugin.

Agents (9)

cohort_list_agents -- List all agents
cohort_get_agent -- Full agent config
cohort_get_agent_memory -- Read agent memory
cohort_create_agent -- Create a new agent
cohort_clean_memory -- Prune stale facts
cohort_add_fact -- Inject knowledge
cohort_adopt_persona -- Load agent identity
cohort_find_agents -- Search by capability
cohort_partnership_graph -- Agent collaboration map

Channels & Messages (8)

read_channel -- Read messages
post_message -- Send a message
list_channels -- List all channels
cohort_create_channel -- Create a channel
channel_summary -- AI summary of channel
condense_channel -- Condense old messages
cohort_search_messages -- Search across channels
cohort_get_mentions -- Get @mentions for agent

Meeting Sessions (8)

cohort_discussion -- Multi-agent discussion
cohort_compiled_discussion -- Single-call roundtable
cohort_meeting_start -- Start session
cohort_meeting_stop -- End session
cohort_meeting_pause -- Pause session
cohort_meeting_resume -- Resume session
cohort_meeting_extend -- Add turns
cohort_meeting_status -- Session state

Meeting Scoring & Participants (9)

cohort_meeting_promote -- Agent -> ACTIVE
cohort_meeting_demote -- Agent -> silent/observer
cohort_meeting_add_participant -- Add agent
cohort_meeting_remove_participant -- Remove agent
cohort_meeting_next_speaker -- Scored recommendation
cohort_meeting_score -- 5-dimension breakdown
cohort_meeting_phase -- Detect phase
cohort_meeting_enable -- Lightweight gating
cohort_meeting_disable -- Disable gating

Work Queue & Tasks (8)

cohort_get_work_queue -- View queue
cohort_get_tasks -- List tasks
cohort_enqueue_item -- Add work item
cohort_claim_next -- Claim next item
cohort_get_outputs -- Read task outputs
cohort_assign_task -- Assign to agent
cohort_route_task -- Auto-route by capability
cohort_requeue_item -- Re-queue failed item

Review & Approvals (4)

cohort_submit_for_review -- Submit work for review
cohort_get_pending_reviews -- See review queue
cohort_submit_review -- Approve/reject
cohort_get_approval_status -- Check approval state

Checklists & Deliverables (3)

get_checklist -- Read channel checklist
update_checklist -- Update checklist items
cohort_set_deliverables -- Define task deliverables

Intelligence & Web (5)

cohort_generate_briefing -- Executive briefing
internal_web_search -- Web search
internal_web_fetch -- Fetch URL content
browser_action -- Browser automation
browser_status -- Browser session state

Channel Plugin (3)

cohort_respond -- Reply to a channel request
cohort_post -- Post to any channel
cohort_error -- Report an error

These three are the reply tools -- how Claude Code sends results back through the Channel. The other 54 tools are how Claude Code talks to your agent team.

All tools are available via MCP. No API keys required for local tools. Claude Code discovers them automatically when the Channel session starts.