Aubia, beta 0.1 pre-launch: your AI agents review each other, on every output, from one model family to the next.
The dawn of multi-agent code.
Claude implements, Codex reviews, Mistral tests. You arbitrate, Aubia executes.
The AI agents Aubia runs and cross-reviews: Claude Code, Codex CLI, Mistral Vibe
- Claude Code
- Codex CLI
- Mistral Vibe
- Cursorsoon
- Antigravity CLIsoon
- Ollamasoon
Preview
Multiple agents, one interface.
From multi-provider synthesis to supervised execution, everything goes through the same view. You see who is doing what and who reviewed whom.
Preview of the Opinions to Executable Plan Mode: three AI agents (claude-sonnet-5, gpt-5.6-terra, mistral-medium-3.5) analyze encrypted token storage in parallel. Each column presents a distinct opinion with a code snippet: Laravel Crypt Eloquent cast, custom readonly DTO with EncryptedString cast, or OS keychain via NativePHP SecureStorage. The Synthesis column summarizes two convergences (AES-256-GCM, never serialize in plaintext), one divergence on storage, and proposes an Executable Plan with 4 numbered tasks ready for approval.
Opinions to Executable Plan Mode
Three agents answer the same prompt. Aubia turns their answers into an Executable Plan, convergences up front and divergences marked, which you approve or adjust.
Laravel Crypt via Eloquent cast.
use Illuminate\Support\Facades\Crypt;
protected $casts = [
'token' => EncryptedString::class,
];Readonly DTO with EncryptedString cast.
final readonly class TokenData
{
public function __construct(
public string $token,
public string $provider,
) {}
public static function fromArray(array $data): self
{
return new self(
token: Crypt::decryptString($data['token']),
provider: $data['provider'],
);
}
}NativePHP SecureStorage, OS keychain only.
use Native\Laravel\SecureStorage;
SecureStorage::put('provider.'.$id, $token);
$token = SecureStorage::get('provider.'.$id);- · AES-256-GCM required
- · Never plaintext in logs or serialization
- · Storage: Eloquent cast / DTO / keychain
- 1Create Providers/Casts/EncryptedString
- 2Refactor StoreProviderToken Action
- 3Cast ProviderConfig::$token
- 4Pest: EncryptedTokenTest
Preview of the cross-review: the implementation agent (claude) refactors StoreProviderToken into a final readonly class with a TokenData DTO. Diff +28 lines, -4 lines on 1 file in 47 seconds. The reviewer agent (codex) marks the status needs_changes and flags two issues: missing DB transaction around save() which may leave an orphaned state, and forgetting to emit the ProviderConfigured event needed to invalidate cached configs. Iteration 2 of 3 sent to claude.
Automatic cross-review
A model from another family reviews every implementation. The agent iterates until agreement, or escalates the disagreement for arbitration.
- Missing DB transaction around save(): risk of orphaned state.
- Emit ProviderConfigured to invalidate cached configs.
Preview of Kanban board: 6 active sessions spread across three columns. In progress: claude on EncryptedString cast, codex on Cast ProviderConfig. In review: the StoreProviderToken card (claude → codex) marked needs_changes. Done: Wire shadcn Dialog, Provider migration, Saloon GitHub. Window footer: drag to sort · providers-encryption · main.
Kanban view
Each AI agent advances on its task, in parallel. Drag a card to approve a review, send it back to the backlog, or mark it as blocked.
EncryptedString cast
Cast ProviderConfig
StoreProviderToken
Wire shadcn Dialog
Provider migration
Saloon GitHub
Features
What Aubia adds to your AI agents.
Aubia is a desktop application that runs multiple AI coding agents on your code, in parallel, and makes them cross-review and challenge each other.
Opinions to Executable Plan Mode
Submit a technical decision to multiple models at once. Each argues its position, and Aubia turns their answers into an Executable Plan: convergences first, disagreements isolated for your arbitration. You decide, without writing a line.
An automatic cross-review loop
One agent implements, another reviews. They exchange the diff until convergence: you set the number of iterations, Aubia orchestrates the handoffs.
Multiple AI agents, in parallel
Multiple agents run simultaneously on the same Git repository, each in its own isolated git worktree. Claude, Codex and Mistral analyze the same problem without stepping on each other.
One pipeline, multiple providers
Aubia drives Claude Code, Codex CLI and Mistral Vibe in the same pipeline. Tomorrow Antigravity CLI, local Ollama and your favorite providers. Plug in your own API keys (BYOK), no vendor lock-in.
Kanban + per-agent terminal
All your sessions in a single view. Kanban for the global state, integrated terminal for agents currently running.
Vision
Why Aubia exists.
Four convictions drive Aubia's technical choices, from the first commit to the features still to come, and a single one sums them up: AI-generated code deserves a second reading, which cannot come from the agent that wrote it.
A single model is a single blind spot.
A model does not audit its own biases. As long as the same agent implements then reviews, errors loop back. The second reading comes from another model family, hence from another angle: one agent implements, another reviews, and that is cross-review.
One prompt, multiple opinions, one Executable Plan.
A senior dev consults before deciding. AI agents should work the same way, and your role becomes arbitration: multiple proposals, one direction you choose.
A pipeline that works once must work a thousand times.
A sequence of agents that solves a problem well is an asset. It must be saveable, versionable, shareable, replayable on other projects. A well-crafted prompt is worth as much as a well-written function.
Your code stays on your machine.
Aubia runs locally, BYOK: your API keys, encrypted in the OS keychain. No Aubia server ever sees your sources, and no mandatory intermediary sits between your code and your providers.
Roadmap
Version 1.0 is built before your eyes.
From beta 0.1 to 1.0, each 0.x version unlocks a feature. You install Aubia once, and updates arrive with no migration to run.
Cross-review as a multi-step DAG
After beta 0.1, cross-review extends to graphs of arbitrary AI agents. Claude implements, Codex and Mistral review in parallel, Gemini arbitrates the disagreements, a final AI agent merges. Every step and every branch stay under your control.
Visual pipeline editor
Branches, conditions, fan-out/fan-in. Build arbitrary pipelines with the mouse.
Manual plan editor
Write an Executable Plan directly, without going through Opinions to Executable Plan Mode. Automatic cross-review per task.
Reusable prompts
Your favorite templates, versioned and shareable.
100% local inference
Llama, Qwen, Gemma via Ollama, with MLX acceleration on Apple Silicon.
Multi-machine sync
Themes, shortcuts, configs and templates follow your machines: personal, work, backup laptop.
MCP integration
Aubia becomes a tool inside Cursor, Zed, Claude Desktop. An agent callable as an MCP tool.
CI auto-fix
Pipeline that fails, an agent retrieves the logs, fixes, restarts. Notification after 3 attempts.
Budgets and cost alerts
Track what your pipelines cost, by provider and by project. Alerts before overrun.
Gemini provider
Google Gemini joins the providers via Antigravity CLI. One more model family for your cross-reviews.
Mobile companion
Track your sessions from your phone. Launch at the office, resume on the couch.
The other orchestrators run your AI agents. Aubia cross-reviews them, synthesizes them, composes them into shareable pipelines.
Request early accessCreator's letter
A project that refuses to bet on a single model.
I've always been passionate about new technologies, and web development in particular: it lets you deliver your work directly to users. To me, every line of code is an expression of craft. It's in that spirit that I designed GlobalExam's information system from scratch, then CEGELEM's.
Everything shifted in February 2025, with the first preview of Claude Code. Codex CLI followed shortly after, and very quickly, having to switch between them constantly felt wasteful: two model families at hand, one viewpoint at a time.
Over time, one thing became obvious. The easiest way to miss an error is to be the one who wrote it. And it holds just as true for an agent: an agentic tool tied to a single provider is a dead end. Claude misses details Codex catches at first glance, and Codex sees an implementation through that Claude would have questioned. In a mono-provider pipeline, the same biases end up reviewing the code at every step, and errors slip silently from one agent to the next.
Aubia grew out of that frustration of not being able to make multiple LLM families work together, in the same session. At first, I built this project to help me with my own daily tasks. But if this need drives me enough to pour that much energy into it, I'm probably not the only one who feels it.
It reminds me of multi-cloud for infrastructure: multi-provider plays the exact same role for agentic workflows. Betting everything on one ecosystem means inheriting its access policy, pricing, quotas and roadmap. By contrast, Aubia makes the model families cross-review each other: a bug Claude introduces, Codex catches. An architecture Codex accepts, Claude challenges. A second reading, by another family of models.
My bet: your AI agents review each other, whichever provider they run on. So let's set out together, because your feedback will shape what comes next.
Talk soon,
FAQ
Frequently asked questions
What developers ask before joining the waitlist.
Nowhere. Aubia is a desktop application: the agents run locally and no Aubia server ever sees your source code.
You plug in your own API keys (BYOK). They are encrypted in your OS keychain, and Aubia never resells tokens.
If you already run Claude Code, Codex CLI or Mistral every day and ship more AI-generated code than you can review line by line, yes. Aubia sits on top of the agents you already use, as a cross-review layer: you keep your subscriptions and your keys, and Aubia adds review across model families plus arbitration.
The beta is free, with no time limit. You only pay for your own API usage at your providers, with your own keys (BYOK).
No. Claude Code, Codex CLI and Mistral stay your agents: Aubia drives them as providers, puts them in cross-review and lets you arbitrate.
One agent implements, a model from another family reviews. The two exchange the diff until convergence, with a maximum of 3 iterations. If a disagreement persists, you arbitrate.
You submit a technical decision to several models in parallel. Each argues its position, Aubia synthesizes the convergences, isolates the disagreements and generates an Executable Plan that you approve or adjust.
Each agent session runs in its own isolated git worktree. Claude, Codex and Mistral move forward in parallel on the same repository without stepping on each other.
Beta 0.1 is planned for the third quarter of 2026, first on macOS Apple Silicon. Linux and Windows support will follow with 1.0.
Sign up on the waitlist: a confirmation email is sent to you, and nothing is final until you click the link it carries. Once confirmed, you get the priority invitation as soon as beta 0.1 opens.
Ready to have your AI agents review each other?
Join the waitlist and get the priority invitation as soon as the beta opens.
From beta 0.1 on
- macOS
- Windowssoon
- Linuxsoon
Multilingual
- Français
- English
- Español
- Deutsch
- Italiano
- Português
- 中文soon
- Русскийsoon
- العربيةsoon
- 日本語soon