convez.ai
AgenteDesenvolvimento WebAvançado
gaowei90098-creator

Orbit Hub — Coordenação de Agentes IA para Desenvolvimento

gaowei90098-creator/orbit-hub

Hub de coordenação para agentes IA trabalhem juntos sem conflitos

Ver no GitHub
InicialPluginScore · de 0 a 100

Plataforma local-first que permite múltiplos agentes de IA (Claude Code, Codex) colaborarem em paralelo no mesmo projeto, compartilhando um quadro de tarefas, sincronização automática de contrato de interface, soft-locks de arquivo e mensageria entre agentes. Elimina conflitos de versionamento e coordenação sem compartilhar chaves de API.

Instalação

$npx convez-ai gaowei90098-creator/orbit-hub

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
2
Forks
1
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Desenvolvimento paralelo com múltiplos agentes de IA no mesmo codebase
  • Sincronização automática de mudanças de interface entre agentes
  • Evitar conflitos de arquivo e reescrita de código entre agentes

Veredito

Orbit resolve um problema real de coordenação entre agentes IA paralelos com arquitetura elegante (hub local + adapters stdio MCP). Solução madura, TypeScript strict, MCP-nativa, mas requer expertise técnica em agentes IA e ecossistema Claude/OpenAI para máximo aproveitamento.

README

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

Orbit makes Claude Code (Anthropic) and Codex (OpenAI) collaborate as a single team on the same machine — a shared task board, an interface contract that syncs itself across agents, file soft-locks, and an agent-to-agent message bus. No model API keys are ever shared — each agent reuses its own CLI login. It turns "two AIs taking turns and overwriting each other" into "two AIs building in parallel and talking before they collide."


📜 What is Orbit

AI coding agents have gotten genuinely good — but they still work alone. The moment you put two of them on the same project (or two teammates each driving their own), the coordination falls apart: they take turns, the shared working tree throws conflicts, and neither agent knows what the other just changed. The agents are state-of-the-art; the collaboration between them is stuck in 1999.

Orbit is the missing coordination layer for AI coding agents. It gives every agent a shared task board + file soft-locks + a self-syncing interface contract + an agent-to-agent message bus + a live dashboard — so multiple agents (and multiple people) can work the same codebase in parallel instead of in turns: divide work atomically, get warned before touching the same file, and renegotiate an interface the instant it changes — without ever sharing a model API key.

Both Claude Code and Codex are MCP clients. Orbit runs one small hub server (state + REST + SSE + live dashboard); each agent launches a tiny stdio MCP adapter that connects to it. The same code runs on localhost for yourself today and over a tunnel for your team tomorrow.

💡 Why it matters

Orbit turns the everyday failure modes of multi-agent work into wins:

Without a coordination layerWith Orbit
Agents take turns — one idles while the other worksThey work in parallel, each on its own task / branch
Shared interfaces drift; you manually re-sync and reworkThe contract syncs itself — change User, everyone sees it instantly
Two agents edit the same file and clobber each otherSoft locks warn before the collision, not after
You're locked into one vendor's agentVendor-neutral — Claude Code, Codex and others share one hub

The payoff is the boring-but-valuable thing real teams want: less idle time, fewer merge conflicts, fewer "wait — you changed the API?" moments. It's collaboration efficiency, not a science project.

💼 What you can build with it

Orbit is coordination infrastructure for any workflow where more than one agent touches the same code:

  • Solo dev, multiple agents. Run Claude Code and Codex at once; hand each a slice of a feature and let them coordinate instead of you babysitting two terminals.
  • Team, mixed tools. Everyone keeps their preferred agent — and their own login & billing. Orbit is the shared room they all work in; nobody is forced onto one vendor.
  • Big task, fan-out. Split a refactor or a feature across several agents in parallel worktrees; Orbit keeps the contract aligned and the files un-clobbered, then hands you one reviewable integration.
  • Human-in-the-loop by default. Nothing merges to your branch without explicit approval — agents propose, you dispose.

Where it's headed. The hub already speaks over a tunnel + token, so the natural next step is cross-machine, cross-team collaboration — invite a teammate's Claude Code, or a partner's Codex, into the same shared contract. The model is straightforward and honest: the core stays open-source under AGPL-3.0, and a commercial license is available for teams that need to embed Orbit in a closed-source product. The wedge is simple and real — the moment anyone runs more than one AI agent, those agents need somewhere to coordinate. Orbit is that somewhere.

✨ What you get

CapabilityWhat it doesTools
Inter-agent messagingAgents send direct or broadcast messages — "I changed the /users API, update your caller."send_message, get_messages
Shared task boardDivide work; claim tasks atomically (only one agent wins); track status & dependencies.create_task, list_tasks, claim_task, update_task, release_task
File-conflict preventionSoft locks: claim a file before editing it; if a teammate holds it, you're warned with their name instead of clobbering their work.acquire_file_lock, release_file_lock, check_file_locks
Self-syncing contractA versioned shared interface spec. One agent changes the User type → the other is notified and reads the new version automatically. No guessing, no rework.get_contract, update_contract
Shared notesA durable log of decisions everyone can read — why an API looks the way it does.get_shared_notes, append_shared_note
Presence + live dashboardSee who's online, what they're doing; board, messages and locks stream live over SSE.whoami, list_agents + the dashboard

🎬 Real collaboration, for real

This isn't a mockup. Below is a real session between two independent AI clients from two different vendors, coordinated entirely through Orbit. They built orbit-demo — a tiny zero-dependency "user list" app — with every line written by an AI.

Roles aren't fixed. Orbit never decrees "Claude does frontend, Codex does backend." Work is split by task, and any agent can claim any task — front-end, back-end, tests, refactors, docs. The split below is simply how this particular run happened to shake out:

In this runClientVendorClaimed & wrote
Took the UI taskClaude CodeAnthropicpublic/ (list page, sorting, XSS-escaping)
Took the API taskCodex (desktop)OpenAIserver.js (API + static host)

What actually happened, step by step:

  1. Discovery — both agents appear online; list_agents shows what each is working on.
  2. Atomic split — Claude claims the frontend task, Codex claims the backend task. One task, one owner.
  3. Contract v2 — they agree on User { id, name, email } and GET /api/users → User[], written into Orbit's shared contract.
  4. A gap is found — building the list, Claude realizes it needs to sort by sign-up time, but User has no timestamp. It messages Codex.
  5. Contract v2 → v3 ⭐ — Codex agrees, update_contract adds createdAt: string, and broadcasts. Claude reads v3 automatically. Interfaces aligned with zero rework.
  6. Isolated edits — Claude soft-locks public/, Codex soft-locks server.js. No overlap, on the record.
  7. Two commits — Claude commits the frontend, Codex commits the backend.
  8. Integration — green. GET /api/users returns 5 users all carrying createdAt; static MIME types correct; 404 for missing files; and GET /../server.js → 404 because Codex added path-traversal protection on its own initiative.

Two AIs. Two vendors. One running app. Zero collisions, zero shared keys. The full annotated timeline is preserved in the companion orbit-demo project (COLLABORATION.md).

🖥️ Mission Control dashboard

Open http://localhost:4100 — a clean, real-time operations console:

  • Connect agents — copy-paste the exact MCP command for Claude Code, or one-click write the Codex config. Live "2/2 online" status.
  • Launch a mission — type a goal; the hub seeds a task, broadcasts it, and (optionally) auto-dispatches a worker.
  • Watch it happen — online agents, task board, file locks, the collaboration feed, and pending conflicts all stream live over SSE.

The panel registers itself as an Operator agent, so everything you do from the UI is attributed just like an agent action.

🏗️ How it works

            ┌────────────────────────────────────────────────┐
            │  Hub server (one per team)                      │
            │   coordination core (node:sqlite) · REST · SSE  │
            │   + live dashboard                              │
            └───────────────┬─────────────────────────────────┘
              REST/SSE       │   localhost now / tunnel+token later
        ┌───────────────────┼────────────────────┐
   stdio MCP adapter   stdio MCP adapter      browser dashboard
   (Claude Code)        (Codex)               (live)
        │                   │
    Claude Code           Codex

The adapter is a thin proxy: each MCP tool call becomes one REST call to the hub, tagged with the agent's identity. stdio is the transport both Claude Code and Codex support reliably, and it makes networked mode a one-line change (point --hub at a tunnel URL + --token).

🚀 Getting Started

git clone https://github.com/gaowei90098-creator/orbit-hub.git
cd orbit-hub
npm install
npm run build:all          # builds the server + the dashboard
node dist/cli.js start     # hub + dashboard on http://localhost:4100

The start banner prints the exact commands to connect each agent (with correct absolute paths). Then:

Open http://localhost:4100 to watch the dashboard. To see it populated without real agents:

node examples/seed-demo.mjs

Dev without building: npm run dev (hub via tsx) and npm --prefix dashboard run dev (dashboard with HMR).

🔄 The workflow that turns "linear" into "parallel"

  1. Isolate — each agent works in its own git worktree/branch (Orbit can auto-create one per run).
  2. Divide — list_tasks → claim_task (atomic; no two agents take the same task).
  3. Don't collide — acquire_file_lock before editing; if it's held, coordinate instead of overwriting.
  4. Stay compatible — change a shared interface? update_contract + send_message; the other side syncs automatically.
  5. Converge — update_task done, release locks, then a reviewable integration candidate — merged to your branch only on your approval.

🛡️ Security by design

Orbit is a coordinator, not a model proxy. The boundaries are deliberate:

  • No API keys, ever. Orbit never asks for or stores a model API key. Each agent reuses its own CLI's existing login (Claude Code's OAuth, codex login).
  • Orbit never runs inference. It only moves tasks, contracts, locks and messages. Your prompts and code never pass through a model Orbit controls.
  • Credentials are never read. Environment detection runs only official CLI commands (--version, login status) — it never touches your keychain or token files.
  • No silent merges. Integration produces a reviewable candidate; merging to your target branch needs explicit human approval, with automatic rollback on failure.
  • Local-first. Binds 127.0.0.1 by default. Networking is opt-in — add HUB_TOKEN + a tunnel only when you decide to.

🌐 Networked mode (multiple people)

The hub and adapters are identical to local mode — you only add a token and expose the port.

HUB_TOKEN=$(openssl rand -hex 16) node dist/cli.js start

Then expose port 4100 (pick one):

  • Tailscale (recommended): tailscale serve 4100 → share the MagicDNS URL.
  • ngrok: ngrok http 4100 → share the https URL.
  • LAN: start with --host 0.0.0.0 and share http://<your-lan-ip>:4100.

Each teammate points their adapter at it:

... mcp --name "Bob-Claude" --harness claude-code --hub https://<tunnel-url> --token <TOKEN>

Every /api request and the SSE stream require the bearer token when HUB_TOKEN is set; /healthz stays public.

🧩 MCP tools at a glance

GroupTools
Identity & presencewhoami, list_agents
Task boardcreate_task, list_tasks, claim_task, update_task, release_task
File locksacquire_file_lock, release_file_lock, check_file_locks
Shared contractget_contract, update_contract
Messagingsend_message, get_messages
Shared notesget_shared_notes, append_shared_note
Intent & conflictsdeclare_intent, withdraw_intent, check_conflicts

🧪 Development

npm test            # 123 tests: core logic, drivers, worktrees, state machine, coordinator, integration, REST, MCP e2e
npm run test:cov    # coverage
npm run typecheck   # strict TypeScript, no emit
src/core/     coordination logic (store, agents, messages, tasks, locks, notes, contracts, missions) — pure, unit-tested
src/drivers/  per-vendor adapters (Claude Code / Codex): detect · build start/resume · parse events
src/hub/      Express REST + SSE + run-manager + coordinator + integration-manager + static dashboard
src/cli.ts    `orbit start` and `orbit mcp`  (`agent-hub` remains a compatibility alias)
dashboard/    Vite + React single-page live dashboard

Built on the Model Context Protocol (@modelcontextprotocol/sdk), Express 5, and Node's built-in node:sqlite (no native build step).

🗺️ Roadmap

  • Phase 1–4 — environment detection, worktree isolation, mission state machine, contract sync, integration & approval
  • Codex desktop-app detection + launch-path consistency
  • Dashboard UI polish
  • Phase 5 — LAN / remote agents: invite other people's Claude Code and Codex into the same hub
  • Phase 6 — richer mission planning & multi-team coordination

📜 License

Orbit is licensed under the GNU AGPL-3.0. © 2026 gaowei90098.

This is a deliberate, strong-copyleft choice. In plain terms:

  • ✅ You may use, study, modify, and share Orbit freely.
  • ⚠️ If you distribute a modified version — or run a modified version as a network service — you must release your full source under AGPL-3.0 too, and you must keep the original copyright and attribution.
  • ❌ You may not take Orbit, tweak it, and ship it as a closed-source product or proprietary SaaS. That's exactly what AGPL is built to prevent.

In other words: build on Orbit all you like — but you can't fence it off and call it yours. Improvements flow back to the community. For a commercial license that lifts the copyleft obligation, contact the author.


Ver o original no GitHub

Bom para

Relacionados