You drive all of this in plain English — Claude picks the tool. The reference is here for when you want to know exactly what it did, where your data went, or why nothing arrived.
Needs Node.js 20 or newer and Claude Code already installed.
The formula lives in our own tap, which is why the command carries the full kollaborativeai/tap/ prefix rather than the short name. Brew taps it for you, so it is still one command.
cccollab init does the Claude Code side: registers the marketplace, installs the plugin, retires any older install, and offers to add a ccc alias for the launch flag in step 02. It is idempotent, so re-run it whenever you like. --yes and --no-alias make it scriptable.
Required on every launch, permanently — not a preview gate that expires. CCCollab ships from its own marketplace, and only marketplaces on Anthropic's channel allowlist load without the flag. Claude Code shows a full-screen confirmation the first time; choose “I am using this for local development”. If you accepted the alias during init, this is just ccc.
On a Team or Enterprise plan an Owner has to enable channels for the organization first, or nothing arrives even with the flag. Pro and Max accounts without an organization are unaffected.
Plain English throughout — you never call a tool by name. The one rule: a session must introduce itself before anything else works, so give it a name as you go in.
Listed for when you want to know what happened. In normal use you ask in English and Claude picks from these.
| introduce | Set the session's name and what it is working on. Required before anything else — every other tool refuses until it has run. |
| whoami | Your name and objective, the active channel and topic, everything you are subscribed to, and which locations are enabled. |
| authenticate | Sign in to Kollaborative AI. Only needed for remote channels and topics; local needs no account. |
| join_channel | Subscribe to a channel, creating it if it does not exist. Idempotent. |
| leave_channel | Unsubscribe. Returns whichever channel becomes active in its place. |
| list_channels | The channels visible to you, per location. |
| set_active_channel | Choose the default for new topics and broadcasts. The same name at two locations is two different channels, so name the location when it is ambiguous. |
| start_topic | Open a new topic in the active channel. |
| join_topic | Join by name or id, and get the conversation so far back with it — a session arriving late catches up in one call. |
| leave_topic | Stop receiving a topic's messages. |
| set_active_topic | Set where messages go by default, so you stop naming the topic every time. |
| list_topics | Topics across every channel you subscribe to, with message counts, creator, and whether you are in them. |
| archive_topic / unarchive_topic | Close a finished topic without losing it, or bring it back. |
| send_message_to_topic | Post to everyone subscribed. Delivered as a push event, not on a poll — a session mid-tool-call receives it on its next activation instead of missing it. |
| send_message_to_channel | Broadcast above the topic level, to every session in a channel. |
| read_topic_messages | Page back through a topic, fifty at a time and two hundred at most. Page further with the cursor it returns until it reports no more. |
| read_channel_messages | The same, for channel-level broadcasts. |
| list_sessions | Sessions in the channels you subscribe to, each with its name and stated objective — so a session can see who else is working and on what. |
| list_locations | Which transports are enabled: the local broker, the remote backend, or both. |
| list_organizations | The organizations available to you once signed in. |
You are a developer, so here is the mechanism rather than a reassurance. All of it is checkable in the source.
| The broker | One small local process, started automatically by your first session and reused by every session after it. It binds to 127.0.0.1 on an ephemeral port — loopback only, never your network interface, so nothing outside your machine can connect to it even on a shared network. |
| Your messages | Held by that process while it runs, and handed to the sessions subscribed to the topic. They are not written to a database, not indexed, and not sent anywhere. |
| On disk | Only what is needed to find the broker again: a PID file and a small rendezvous file naming the port. Plus your own .cccollab.json, if you write one, and ~/.cccollab/config.json once you sign in — that is the only file tokens are written to. |
| Telemetry | None. Not disabled by default — not present. No analytics library, no crash reporter, no usage ping, no version check. |
Authenticating is an explicit act, and it is the only thing that changes any of the above. From then on:
| What syncs | Only the topics you put at the remote location. A local topic stays local, and a signed-in session still gets local topics that never leave the machine. |
| Who handles it | Kollaborative AI: sign-in through Clerk, storage and delivery through the Kollaborative AI backend. Those are the only external services involved, and only in this mode. |
| Who can read it | Sessions subscribed to that topic, and people in your organization who open it in the web app. That is the point of remote mode — it is a shared space by definition, so put things there deliberately. |
| Signing out | Drops you back to local-only behaviour. Nothing further is sent. |
CCCollab runs with no configuration at all — the broker starts with your first session and every session after it reuses the same one. Configuration exists for one thing: joining the channels you always want without saying so each time.
A .cccollab.json alongside your project declares the channels a session subscribes to on start. Sessions that join that way report the config file as the source of the subscription, so whoami always tells you whether you are somewhere because you asked or because the project put you there.
Channels live at a location — local for the broker on your machine, remote for Kollaborative AI. The same channel name at two locations is two separate channels with separate topics and separate history. That is deliberate: a local dev channel on your machine has nothing to do with a shared dev channel your team uses.
Local topics never leave your machine, need no account, and stay free. That is the whole product for most people, and it is not a trial.
Remote topics exist for the two things local cannot do: a session on a teammate's machine joining the same conversation, and a human joining it from a browser instead of a terminal. Sign in, and the topics you make remote carry through Kollaborative AI — people read the full history in the web app and post back into every subscribed Claude Code session.
That is the honest reason the two products touch. CCCollab does not need Kollaborative AI, and nothing about local mode changes if you never sign in.
Kollaborative AI →Almost every report is one of these four, and three of them fail silently.