Jupiter v0.1 Alpha: Where We Are

What Jupiter is

Jupiter is a parallel AI coding agent orchestrator written in Rust. You give it a task, it splits the work across multiple Claude CLI workers that coordinate through shared memory — automatically. No manual copy-pasting between windows, no context loss, no file conflicts.

The core idea: 80% deterministic Rust engine + 20% Claude reasoning. The Rust engine runs continuously at zero token cost. Claude is invoked only when reasoning is needed: planning, coding, error analysis.

What’s working today

Planner engine

The Planner is Jupiter’s brain. Before any worker touches your code, it:

Indexes your codebase — symbols, modules, dependencies
Decomposes tasks — breaks a high-level instruction into worker-sized subtasks
Generates typed briefings — each worker gets a 9-12 KB context package with relevant code, constraints, and owned symbols
Generates contracts — a contracts.md file (~27 KB) with TypeScript interfaces, Rust signatures, and store shapes so workers stay in sync
Detects conflicts — ensures no two workers modify the same code

Parallel workers with shared context

Jupiter workers are Claude CLI processes enhanced with MCP tools. Currently:

Up to 5 parallel workers per task
Each worker gets a typed briefing from the Planner with exclusive symbol ownership
Workers share state via the memory bus — an append-only log every worker can read
Automatic conflict detection via file locking
A dedicated Integration Worker runs last to wire everything together (13/13 components mounted in our test runs)

Validator

After workers finish, the Validator runs static analysis:

Detects console.log stubs, as any casts, unmounted components
Catches fire-and-forget async patterns (invoke() without .then()/.catch())
Finds dead code, hardcoded paths, unused Tauri commands
Enforces the async action → verify → feedback pattern in worker output

MCP ecosystem (documentation & code intelligence)

Jupiter automatically equips workers with tool servers (“moons”) so they can look up docs and navigate code:

Documentation — 3-tier strategy:

Docs Registry (deterministic) — a static registry with ~40 frameworks and ~50 pre-validated doc pages. Injected as STEP 0 in every worker briefing. The worker doesn’t decide what to fetch — it gets exact commands with optimized parameters for each doc site.
Context7 (dynamic) — resolves any library and fetches up-to-date docs on demand. Covers everything the static registry doesn’t.
fetch (manual) — direct URL fetching when workers need a specific page.

Code Intelligence:

mcp-language-server — a single LSP bridge that works with any language (Rust via rust-analyzer, TypeScript via typescript-language-server, Python via pyright, Go via gopls)
Workers get 6 tools: go-to-definition, find-references, diagnostics, hover, rename-symbol, document-symbols
Jupiter auto-detects the project stack and configures the right LSP

GUI

A Tauri v2 + React desktop app for managing sessions visually:

Real-time worker dashboard
Plan review before execution
Prep chat — talk to Claude about the task before Jupiter plans it

Full CLI

jupiter run <task>    — plan and execute with parallel workers
jupiter dash          — real-time TUI dashboard
jupiter status        — current session status
jupiter msg <id> <text> — message a specific worker
jupiter pause/resume/kill <id>
jupiter logs [id]     — worker logs
jupiter validate      — run the validator
jupiter moons         — list active MCP tool servers
jupiter clean         — clean runtime directory

What’s next

Worker QA with E2E testing (top priority)

The biggest gap today: the Validator checks that code compiles and passes static analysis, but it doesn’t launch the app. It can declare “20/20 PASS” on an app that crashes at runtime.

We’re building a QA Worker that will:

Launch the app in dev mode
Generate Playwright tests from acceptance criteria
Simulate a real user: click buttons, drag files, create/delete, search
Verify the UI actually responds after each action
Capture JS and Rust console errors during interaction

This works for anything web-based (Tauri, Electron, web apps) — which covers the vast majority of GUI projects.

Phase-aware MCP injection

Currently LSP is active for all workers. We’re implementing phase-aware injection: LSP only for the Integrator and Validator (who need to navigate existing code), not for Feature workers (who write new code). This saves ~2 GB RAM on large sessions.

Custom moons

Domain-specific tool servers we’re building:

moon-io — Email (IMAP/SMTP) and Calendar (CalDAV)
moon-europa — Telegram messaging
moon-amalthea — Chart and diagram rendering

Further out

Remote workers via SSH + SSE transport
SQLite access, sequential thinking, error tracking (Sentry)
Full documentation and onboarding guides

The repository

Jupiter is currently in private alpha. The codebase is proprietary (Bambu Holding S.r.l.s.) and not yet publicly available. We’ll share access details as we approach a wider release.

Join our Discord to follow the development, get early access, and share feedback.

Thank you

Jupiter is built by a small team that believes AI coding agents can be dramatically better when they coordinate instead of working in isolation. We’re building this in public — honest about what works and what doesn’t yet. If that resonates, we’d love to hear from you.