convez.ai
MCP ServerAutomaçãoAvançado
sashabogi

Trantor — Orquestrador de Crews de IA

sashabogi/trantor

Hub de orquestração para crews de IA com Advisor, board e economia

Ver no GitHub
InicialPluginScore · de 0 a 100

MCP Server que transforma Claude Code em arquiteto de projetos, orquestrando múltiplos agentes de IA (Claude, Codex, Gemini, Kimi, DeepSeek) como crews coordenadas. Inclui board Kanban em tempo real, gate de testes, estimativas de custo e roteamento inteligente de tarefas via Advisor.

Instalação

$npx convez-ai sashabogi/trantor

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
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 1 dia
Versão
app-v0.3.198
Issues abertas
0
Contribuidores
1

Casos de uso

  • Orquestrar múltiplos modelos de IA para projetos complexos
  • Supervisar e rastrear execução de tarefas em tempo real com Kanban
  • Estimar custos e otimizar uso de APIs antes de executar
  • Implementar pipelines de desenvolvimento assistido com gate de testes
  • Balancear trabalho entre agentes solo, calls inline e crews completas

Veredito

Trantor é um orquestrador sofisticado e maduro (37/37 testes passando) para quem precisa coordenar múltiplos agentes de IA em fluxos reais de desenvolvimento. A arquitetura é sólida — Doctor para diagnóstico, Advisor para roteamento inteligente, e board visual para controle — mas exige familiaridade com CLIs e APIs de múltiplos provedores.

README

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

████████╗██████╗  █████╗ ███╗   ██╗████████╗ ██████╗ ██████╗
╚══██╔══╝██╔══██╗██╔══██╗████╗  ██║╚══██╔══╝██╔═══██╗██╔══██╗
   ██║   ██████╔╝███████║██╔██╗ ██║   ██║   ██║   ██║██████╔╝
   ██║   ██╔══██╗██╔══██║██║╚██╗██║   ██║   ██║   ██║██╔══██╗
   ██║   ██║  ██║██║  ██║██║ ╚████║   ██║   ╚██████╔╝██║  ██║
   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝

The hub-world for AI agent crews.

One Advisor decides how your work runs — solo, cheap inline calls, or a live crew of Claude Code, Codex, Gemini, Kimi & DeepSeek in their own terminal windows — routed by your actual plans, supervised on a live board, learning from every failure.

License: MIT Node Agents Tests


Install

npm install -g trantor
trantor setup        # hub becomes an always-on service + config + wires your AI CLIs + doctor

Then give Claude Code (the orchestrator) the plugin:

claude plugin marketplace add sashabogi/trantor
claude plugin install trantor

That's it. (Prefer source? git clone https://github.com/sashabogi/trantor && cd trantor && npm install && bash deploy/setup.sh — identical result.)

What to expect on first run

trantor setup ends with the doctor — an honest map of where you stand:

TRANTOR DOCTOR

core
  ✓ node 22.x
  ✓ hub up at http://127.0.0.1:4477
claude (the orchestrator)
  ✗ plugin not installed
      → claude plugin marketplace add sashabogi/trantor && claude plugin install trantor
crew CLIs (install any subset — seats follow the work)
  ✓ codex: wired to the bus
  ✗ codex: NOT authenticated — it will join the bus but fail on its first turn
      → codex   (sign in with your ChatGPT account on first run)
  – kimi: not installed (optional)
the brain
  ✗ quota profile not set → trantor profile set claude=max codex=plus deepseek=api

Fix the → lines (each CLI's own sign-in happens once, in that CLI) and re-run trantor doctor until it's clean.

Provider API keys (e.g. DEEPSEEK_API_KEY) live in one file: ~/.agent-bus/.env — the crew runners source it automatically.

Your first build

Open Claude Code in the project you want built and say it in plain words:

fire up the crew — build me a 2-player asteroids game with power-ups

Any phrasing works ("build it with the crew", "build this with trantor"), or invoke the skill directly: /trantor:crew. Claude becomes the architect: it cuts the work into difficulty-tagged packages, asks the Advisor, and shows you the routing table with a real-money estimate before spending anything. You say go — terminal windows open, the board fills, and you watch it live:

trantor ui

No crew CLIs installed yet? It still works — the Advisor routes the work solo or to cheap inline scrooge calls instead of seats. Seats follow the work and what's actually installed.

Running low on context mid-build? Say /trantor:handoff — a fresh session in the same project takes over with a full window (and a PreCompact hook does this automatically).

What happens when you fire up a crew

  1. The Advisor moment. Your Claude cuts the work into difficulty-tagged packages, calls relay_advise, and shows you the full picture before spending anything: mode (solo | scrooge | crew | hybrid), a routing table with a reason per package, why that many seats ("seats follow the work, not the install list"), and a real-money estimate with quota-pool accounting. You say go.
  2. Windows open. trantor up codex gemini kimi deepseek:deepseek-v4-pro spawns one titled terminal window per agent (agent:model pins a model), serialized and then verified on the bus — the launcher ends with "crew verified" or names the no-shows loudly. The orchestrator never gets a green lie.
  3. Work flows over the bus. Contracts arrive as messages; each agent owns its own files; coordination happens in <280-char messages you can read on the dashboard. Crew members live under a runner: the CLI works one turn and exits, the runner long-polls the bus for free (it's also the heartbeat) and resumes the CLI — with full context — when the next message lands. Idle agents cost zero tokens and never die.
  4. The board tells the truth. Cards flow todo → doing → testing → done — testing is a real gate (tests/typecheck run there); failures turn the card pulsing red until the orchestrator bounces them back; demoted cards wear an "↩ bounced" mark with full history.
  5. It learns. Failures become lessons (relay_lesson), stored on the hub and injected into every future crew's prompts — global or per-CLI. Your crew gets smarter every run.

The dashboard — trantor ui

A live command center at http://127.0.0.1:4477, grouped by project:

  • BOARD view — Kanban with the testing gate, difficulty + model badges per card, agent chips with provider logos, live status, and quota-pool tags.
  • FLOW view — the same work as an n8n-style dependency graph: parallel streams fanning out and converging into integration, edges lighting up as work flows (green = done feeding forward, animated blue = active), red ↩n loops where work bounced back. Drag nodes to rearrange, ⌘+scroll / pinch to zoom, FIT/AUTO controls. Pick per project; your choice sticks.
  • Per-project conversation lanes — watch agents negotiate interfaces in context — plus a global live feed, and a composer so you can message the bus (or any single agent).
  • 🪙 economics pill — live Scrooge ledger: real spend, savings vs frontier pricing.

The brain — plan-aware economics

Trantor's economics engine (Scrooge — installed automatically by trantor setup) knows model capabilities, per-1M costs, and keeps the ledger; Trantor turns that into decisions:

  • Declare your plans once: trantor profile set claude=max codex=plus gemini=tier kimi=coding-plan deepseek=api
  • The Advisor routes by your economics: API-billed orchestrator → offload everything; $20-tier plan → the crew is the only way a real build fits; max-tier → context horizon decides. Quota pooling: one build spread across your separate subscription buckets — measured example: a five-vendor 3D game build, API-equivalent $200–600, actual spend $2.29.
  • Fractal delegation (relay_scrooge): the architect and crew members push stateless grunt work to cheap models, with ledger receipts.

Context handoff — sessions that never hit the wall

A PreCompact hook writes a rich handoff before Claude Code compacts; a fresh session in the same project takes over with a brand-new full context window. Works manually from any agent via relay_handoff. Optional macOS auto-prompt (autoHandoffPrompt in ~/.agent-bus/config.json) offers to open the fresh session for you, with a timeout.

Why crews never exhaust the orchestrator: bus messages are by reference (~70 tokens), work products stay in each agent's own context — the orchestrator burns at coordination rate, not work rate.

The tools (MCP — every agent on the bus gets these)

ToolWhat it does
relay_advise(task, packages, horizon?)The Advisor — mode + reasoned per-package routing + cost estimate + ready-to-use card args
relay_send(to, text) / relay_inbox / relay_wait(t)Live messaging: direct, read-new, long-poll wake
relay_peers / relay_status(text) / relay_whoamiPresence: who's alive (honest, heartbeat-backed), doing what
relay_project_brief(text)The project's what/why on the dashboard
relay_task_add(title, …, difficulty, model, deps)Cards with difficulty/model badges + DAG edges for the flow view
relay_task_move(id, status)todo → doing → testing → done (the gate), failed, blocked
relay_boardThe project's full board, as text
relay_scrooge(prompt, task?, difficulty?)Fractal cheap-model delegation, with the ledger receipt
relay_lesson(text, scope?)Record a failure lesson — auto-injected into all future crews
relay_handoff(summary)Full-window session succession

The CLI

trantor setup | doctor | connect | profile | up <agents…> | down | ui | advise | hub | watch

trantor up notes: agent:model pins a model (deepseek:deepseek-v4-pro); spawns are verified on the bus with one retry; geometry auto-detects the screen you're working on (CREW_RECT="X,Y,W,H" to override); trantor down kills crew processes via their ttys and closes windows without macOS "Terminate?" dialogs.

Works with any MCP agent

Claude Code, Codex CLI, Gemini CLI, Kimi Code CLI, OpenCode (DeepSeek) are wired by trantor connect automatically (idempotent, backed-up, never overwrites your customizations). Anything else that speaks MCP: point it at mcp.mjs with RELAY_AGENT=<brand> — loading the server auto-registers the session, so presence works before the model says a word.

How it works

 Claude (architect/plugin)   codex ─ runner   gemini ─ runner   kimi ─ runner   deepseek ─ runner
        │ advise/contracts        │ one turn, exit; runner long-polls (free) + resumes with context
        └───────────┬─────────────┴──────────────┴────────────────┴────────────────┘
                    ▼
              hub.mjs  ←— plain HTTP + SSE · presence/messages/board/lessons/economics
              (Node built-ins only · state in ~/.agent-bus/bus.json · loopback by default)
                    ▲
              dashboard (ui.html) · BOARD/FLOW · conversation lanes · 🪙 ledger

Config: RELAY_URL env → ~/.agent-bus/config.json → http://127.0.0.1:4477. Identity: RELAY_SESSION → RELAY_AGENT:<project-folder> → <hostname>:<project-folder>.

Local-first and safe: the hub binds loopback; no accounts, no cloud, no exposure. An always-on/remote hub (private tailnet, or public with auth) is on the roadmap — never expose the hub publicly without auth.

Heritage note: Trantor grew out of agent-bus. As of v0.17 the plugin and skills are named trantor (formerly agent-bus — if you installed before v0.17: claude plugin uninstall agent-bus && claude plugin marketplace update && claude plugin install trantor). The relay_* tool names and the ~/.agent-bus state dir remain until a later release.

Honest limits

  • You can't interrupt an agent mid-turn; messages land when its current turn ends (idle agents wake instantly via their runner).
  • Window spawning is macOS (Terminal.app); on Linux the launcher prints per-agent commands to run in your own terminals. Hub/MCP/dashboard are cross-platform.
  • The hub is deliberately tiny (in-memory + JSON file) — a coordination bus, not a message queue.
  • Each CLI's sign-in is its own (ChatGPT, Google, Kimi accounts) — the doctor detects state and names the fix, but can't log in for you.

Tests

npm test    # unit + 37 protocol-level scenario drills with mock agents (no LLMs, seconds, $0):
            # honest presence, spawn no-shows, the testing gate, bounce trails, lessons,
            # advisor decisions across plan tiers, deps validation, virgin-machine doctor

License

MIT © 2026 Sasha Bogojevic · Built with Claude Code · Brain by Scrooge

Ver o original no GitHub

Bom para

Relacionados