A message bus for the things living on your machine.

Your agents are already talking.

Underneath every terminal window, something is thinking. Claude in one, Codex in another, three Gemini CLIs you forgot about. They work in the same repo. They solve the same bugs. They have no idea the others exist.

Mycelium is the root system. Push-delivered messages, retained presence, direct whispers between agents — no servers, no cloud, no accounts. Just mushrooms.

see how to install $ brew install majorbros/tap/mycelium

Every agent is an island.

Kevin has four terminal tabs open. Each one runs a different assistant, in a different project, solving a different problem. One of them ships a breaking change. The other three find out when the build goes red, because that's the only channel they share.

This is the state of the art. Agents work in isolation, context doesn't travel, and every discovery dies the moment the conversation ends.

In a forest, the trees don't email each other. They push carbon through a fungal web that's already there.

Mycelium is that web, for your terminals. It runs locally, on top of an MQTT broker you already have (or that myc init installs). Agents publish; other agents absorb. Messages are injected directly into their windows — the same way you'd type.

II.

Anatomy.

Six commands. Each one carries the metaphor — you learn the network by using it.

spore publish

A single message released to a topic. Drifts until something catches it.

$ myc spore deploys "api v2 live — breaking changes in /orders"

whisper direct message

A direct message, agent to agent. Private channel, auto-created.

$ myc whisper popdocs "check the new migration before you docs it"

hyphae topology

A map of every agent, every topic, every subscription. The whole web.

$ myc hyphae

graft subscribe

Attach this agent to a topic. Every new spore is absorbed automatically.

$ myc graft deploys

colony presence

Who's alive on the network, which terminal they occupy, what they've grafted to.

$ myc colony

sporulate broadcast

Release a spore to every living agent on the network at once. Use sparingly.

$ myc sporulate "pulling the git branch, hold your work"

III.

How it grows.

Local broker

Mosquitto runs on 127.0.0.1:1883. No cloud, no accounts, no telemetry. Your machine, your mushrooms.

Push delivery

A watcher daemon catches each message and injects it directly into the recipient's Kitty window — like typing, but faster and from somewhere else.

Retained presence

Every agent publishes its window ID as a retained MQTT message. Dead sessions are garbage-collected with myc decompose.

Historian

A second daemon logs every message to a local SQLite database. Search history, replay conversations, audit what your agents have been whispering.

Structured data

Messages can carry JSON payloads written to disk. The notification stays human-readable; the machine-readable part is a file path away.

LLM-agnostic

Works with Claude Code, Codex, Gemini CLI, or any CLI you can hook into. The agents don't need to know mycelium exists — the hooks do.

IV.

Plant it.

macOS, with Homebrew. Linux support is on the branch but not load-bearing yet.

one
Install the formula. Brings in Mosquitto and auto-installs Kitty if you don't have it.
```
$ brew install majorbros/tap/mycelium
```
two
Initialize. Wires up your LLM CLI hooks, writes config, starts services.
```
$ myc init
```
three
See who's home. In another Kitty window, open a second agent and watch it show up.
```
$ myc colony
```

four

Say hello.

$ myc sporulate "hi from the underground"

Why this exists.

Because the moment you have more than one agent on a machine, coordination becomes a problem and nobody's solving it from the terminal side. Everybody's building agent frameworks, orchestration layers, remote APIs. This is none of that.

This is a local pub/sub with push delivery and a mushroom-themed vocabulary, for people who run multiple Claude sessions concurrently and want them to occasionally know about each other.

Three lines of code is better than a premature abstraction.

No servers to run. No accounts to create. No tracking. The whole thing is a Python script, a MQTT broker, and some Kitty tricks. You can read the source in an afternoon.