convez.ai
AgenteAutomaçãoAvançado
marcelopaniza

Buses — Orquestração Multi-IA com Mensagens Assinadas

marcelopaniza/buses

Barramento de mensagens assinado para coordenação multi-IA com zero idle tokens

Ver no GitHub
InicialPluginScore · de 0 a 100

Plugin de mensageria cross-IA que permite coordenação autônoma entre Claude, Codex, Gemini e LLMs locais através de um barramento compartilhado. Implementa comunicação tamper-proof com zero idle tokens, perfeito para orquestração de agentes e handoff de tarefas entre sessões sem overhead de API.

Instalação

$npx convez-ai marcelopaniza/buses

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
71%
Último commit
há 5 meses
Versão
v0.8.1
Issues abertas
0
Contribuidores
2

Casos de uso

  • Orquestração autônoma de múltiplas sessões Claude Code em paralelo
  • Handoff de tarefas entre agentes de IA diferentes (ex: deploy automatizado)
  • Coordenação entre AI executando em máquinas diferentes via pasta compartilhada
  • Fila de instruções para próximas sessões sem perda de contexto

Veredito

Solução técnica sofisticada para quem orquestra múltiplos agentes de IA. Bem executada em segurança (mensagens assinadas) e eficiência (zero idle tokens), mas exige conforto com shell/bash e arquitetura de sistemas distribuídos. Prototipagem impressionante — recomendado para casos sérios de multi-agent workflow.

README

A tradução para o português deste README ainda está na fila.

buses

Get your AI windows talking. Across screens, across machines, near-zero tokens.

License Version Works with Messages Tests Bash

0 idle tokens · tamper-proof messages · bash + jq + openssl · 15 test rounds, all green · Claude · Codex · Gemini · any local LLM

About the name — a bus is a named channel (general, deploy-watch, mobile-team, whatever you want). You can spin up as many buses as you need; each session subscribes only to the ones it cares about. Within a bus, messages target all, a specific recipient, or a comma-list of recipients — and @-mentions in the body let one AI tag another by name or short-id, the way you'd @ someone in Slack. Replies, threads, broadcasts, side conversations — all over a folder.

Claude Code gets auto-delivery via the plugin hook. Codex, Gemini, and local-LLM orchestrators get the same auto-delivery by prefixing their model invocation with buses-wrap. See Cross-CLI ridership.

You know how you sometimes open three Claude Code terminals — one for the backend, one for the frontend, one to run tests — and end up copy-pasting between them like a hostage negotiator? buses makes that go away. Your AI sessions can leave each other notes, broadcast updates, and tag each other into specific threads. Everything flows through a folder they all see, and the messages just appear the next time you type into the other window.

Who this is for

  • You run multiple Claude Code terminals on one machine and want them to actually coordinate, not just exist
  • You hop between a laptop and a server and want both AI sides on the same page
  • You're a small team sharing a project and want your AIs to chatter so the humans don't have to repeat themselves
  • You want to leave yourself a queue — "next-future-Claude, when you wake up, here's where I left off"
  • You want agent-to-agent task handoff — Claude on your laptop tells Codex on your server "deploy UAT", Codex deploys, Codex replies "done" → all autonomous, all over a shared folder

A 60-second demo

In the first terminal:

/plugin marketplace add /path/to/buses
/plugin install buses@buses
/buses:start

/buses:start is a guided wizard — it asks you 3 short questions (shared-folder path, your terminal name, which bus to join) and runs the right commands for you.

In a second terminal, on the same or another machine: same three commands. Pick a different name when asked.

Then in terminal A:

/buses:send all <name-of-B> "hey can you check the build log?"

Terminal B sees a 📬 buses: 1 new message(s) from <A> line above Claude's next response, the moment you type anything in there. No polling. No wasted tokens.

What it costs

ActivityTokensWhy
Idle terminal, no traffic0The hook prints empty output → nothing added to context
Receiving a 1-line message~30Just the body + a short framing tag, injected once
Sending a messageone slash-command's worthSame as any /buses:* invocation
Background watcher (desktop pings)0 everIt's a plain bash polling loop, never calls Claude
Autonomous task handoff (buses-react)0 when idle, one wrapped-AI call per drainPolling daemon fires buses-wrap <your-ai> only when unread > 0

That "0 when idle" is the whole point. Most terminals are sitting there waiting for you to type. They cost you nothing. The instant someone has something to say, the message lands in your next prompt's context and Claude tells you.

Full breakdown of every delivery path: docs/COSTS.md.

What's a bus

Channels. Each bus is a topic — all, team, deploy-watch, whatever you want. A session that wants to listen to that channel joins it. The session that created the bus is its driver (admin); everyone else is a rider. Drivers can lock, kick, and clean up.

Sessions identify themselves with a UUID and a friendly name. The name is yours to pick (atlas-main, loop-deploy, phone-tunnel) and is just a label — your real identity is your UUID plus an Ed25519 keypair generated locally on first init.

Install

Install on each machine and point them to the shared folder.

/plugin marketplace add /path/to/buses
/plugin install buses@buses
/buses:start

Requirements

  • bash 4.0+ (macOS default is 3.2 — brew install bash if you care)
  • jq, find, awk, sed, openssl 1.1.1+ (for Ed25519)
  • A folder writable by every machine that should join
  • Optional: notify-send (Linux) or terminal-notifier/osascript (macOS) for desktop pings

Commands

The everyday ones:

CommandWhat it does
/buses:startGuided first-time setup. Asks the right questions, runs the right commands. Start here.
/buses:init <path>Manual version. Set the shared folder for this terminal, generate keys.
/buses:name <name>Name this terminal so others can address you.
/buses:create <bus>Create a new bus. You become its driver.
/buses:join <bus>Subscribe to a bus (auto-creates if missing).
/buses:leave <bus>Unsubscribe and remove your presence.
/buses:send <bus> <to> <msg>Send to a name, UUID, all, or a comma-list. Body can @-mention riders to tag them in.
/buses:readManually fetch new messages. (You don't normally need this — the hook does it.)
/buses:statusThis terminal's config + subscriptions + unread counts.
/buses:listAll buses on the shared folder.
/buses:members <bus> (or /buses:riders)Roster with driver + banned annotations.

Driver, watcher, maintenance, and garbage-collection commands → docs/COMMANDS.md.

Profiles

Some setups want canned defaults — a stock name, a stock subscription list, a role marker. Pass --profile <name> to /buses:init:

/buses:init /path/to/share --profile hermes

Each preset lives in presets/<name>.json and can set:

KeyTypeEffect
default_namestringSets /buses:name after init.
rolestringWrites a role field into config.json (visible to other riders).
auto_subscribestring[]Calls /buses:join on each bus after init.

Shipped profiles: hermes (name=jose, role=hermes, auto-subscribes to all) — intended for a human-facing PM/AI-bridge session. Add your own by dropping a JSON file into presets/.

Cross-CLI ridership (Codex, Gemini, local LLMs, plain shells)

Anything that can run bash + jq + openssl can ride a bus alongside your Claude terminals.

Auto-delivery matrix

RuntimeWhen messages reach the modelHow
Claude Code (with this plugin)On your next promptUserPromptSubmit hook injects unread messages as additionalContext
Any AI CLI, interactive (Codex / Gemini / Ollama / llama.cpp / …)On your next invocationPrefix with bin/buses-wrap — it delivers the inbox via argv placeholder, stdin pipe, or stderr heads-up
Any AI CLI, autonomous (background task handoff)On message arrival (polling)bin/buses-react <your-ai-cmd> — daemon polls; on unread, fires the wrapped AI with a directive prompt that refuses destructive ops
Your own custom orchestratorDIY — one function callShell out to bin/buses read --inject from your pre-turn code

The transport is universal; auto-delivery into the model is a per-runtime integration. Pick buses-wrap when there's a human at the keyboard, buses-react when there isn't.

Quick orientation:

  • bin/buses — CLI-agnostic dispatcher. Same init / name / send / read / … subcommands as the slash commands, callable from any shell.
  • bin/buses-wrap <your-ai-cmd> — interactive shim. Wrap a model invocation; the inbox is delivered however it fits.
  • bin/buses-react <your-ai-cmd> — autonomous polling daemon. Fires the wrapped AI when new messages arrive. Single-instance gated, rate-limited, destructive ops refused.
  • bin/buses read --inject — the raw primitive for building your own orchestrator.

Full reference (every mode, identity resolution for non-Claude shells, the --inject nonce format, security caveats around {BUSES_INBOX} placement): docs/CROSS-CLI.md.

Identity & security

Every message is Ed25519-signed over (id, bus, from, to, ts, body). Identity is per-terminal; private keys live in ~/.config/buses/sessions/<id>/identity.key at mode 0600 and never leave the machine. Bus directories are mode 0700. Driver privileges (lock / kick / transfer) are cooperative — an insider with raw write access to the share can bypass them; the real unforgeability comes from the signatures.

Full threat model, hardening list, migration policy, and how to report a vulnerability: SECURITY.md.

More documentation

Ver o original no GitHub

Bom para

Relacionados