v4.1.0 · one brain for 6 CLIs

Your agents stop
starting from zero.

Claude Code, Codex, OpenCode, Gemini, Aider, and Qoder read one ai/ directory. They remember your stack, your decisions, and what already failed — so you stop re-explaining every session.

projects initialized

agent CLIs

registered MCP tools

Free

Three commands and your repo is wired up.

Open source. Free activation. Works on your machine.

Start free activation

Pro · $15/mo

Run agents in parallel. Pick up where any of them left off.

Delegation, session handoff, budget tracking, learned patterns.

See what's included
View on GitHub →
agent CLIs•registered MCP tools
1shared source of truth
Nativeagent configs
TieredMCP access
6agent CLIs

Activation-first setup

From install to a verified first task without a long setup loop.

Init

Auto-detect stack, generate configs for every detected CLI, and map the project graph.

Swarm

Delegate goals to the best agent. Claude designs, Codex implements, Aider tests.

Learn

Experience stats show which model works best. Intelligence grows with every task.

Init detects your stack, swarm delegates to the right agent, and experience stats tell you which model performs best. One tool, full lifecycle.

Three commands. Full lifecycle.

0dai — init, swarm, learn
$
$
$
$
Claude CodeCodexGeminiAiderOpenCodeQoderGrok

Works with your favorite AI coding agents

Claude Code
Codex
Gemini
Aider
OpenCode
Qoder

The old way vs the new way

Without 0dai
  • Claude has no idea what Codex shipped yesterday.
  • Codex rewrites the architecture you already agreed on.
  • You paste the same README into three chats.
  • Half your AI bill goes to re-explaining the repo.
With 0dai
  • One shared project memory. Every agent reads it first.
  • Claude plans it, Codex ships it, Gemini reviews it — one thread.
  • Decisions stick. Failed approaches stay flagged.
  • No more "let me explain the codebase again."

What actually changes

Three things you notice on day one. Six things you appreciate by week two.

Shared memory

One place for decisions, stack quirks, and what's already been tried. Every agent reads it before touching your code.

Parallel agents

Claude writes the plan. Codex implements. Gemini reviews. Budget gates keep spend visible before work fans out.

Handoff without re-briefing

Save the session in Claude. Resume in Codex. It knows the goal, the plan, the files — no second tour of the repo.

Stack detection

Next.js, FastAPI, Flutter, Go, monorepos — detected on first run.

MCP on tap

Every agent gets the same project map, commands, and manifests.

Smart routing

Boring refactors go to haiku. Architecture goes to opus. You pay for what the task needs.

Ready-made workflows

Build, test, delegate, status, feedback, review — wired in.

Budget caps

Per-agent and per-tier ceilings. You'll know before it burns through your quota.

Learns from hits and misses

Patterns that worked get reused. Patterns that didn't get flagged — quietly.

Pick your lane

Free stays free. Upgrade when you want parallel agents and shared memory that outlives a single session.

OPEN

Open Source

Free — always

  • All 6 agent CLIs, one config
  • ai/ directory + sync
  • Auto stack detection
  • 49 core MCP tools
  • Ready-made skills
Install it
BILLING

Pro

$15 / month

  • Everything free
  • All 103 registered MCP tools
  • Multiple agents deliberate
  • Tracks what worked, what didn't
  • Role-aware personas
  • Graph viewer in the browser
Go Pro
TEAM

Team

$49 / seat

  • Everything Pro
  • Shared memory across repos
  • Per-team multi-machine sync
  • Collaborative memory layer
  • Planned cloud Knowledge Graph
  • Team dashboard
  • Patterns travel between projects
  • Role-based access
  • Priority support
Try with team

Free activation is explicit. Paid access runs through Wallet Pay when available, with TON fallback.

Install in minutes. Activate before init.

The fastest path is: install the CLI, authenticate and activate Free, run init, verify the layer, then hand it a real task. No detour through a long setup flow.

Go from install to useful output without a dead-end setup step.

terminal — install + first win
$ npm install -g @0dai-dev/cli
$ 0dai auth login && 0dai activate free
$ 0dai init
✓ Detected: Next.js + TypeScript + Postgres
✓ Free activation active · project bound
✓ Generated native configs for every detected CLI
$ 0dai doctor
✓ Health check passed: ai/ layer ready
$ 0dai run 'ship auth'
✓ Routed Claude → design, Codex → implement, Aider → test
✓ First task outcome recorded with budget telemetry

1. Install the CLI

Run npm install -g @0dai-dev/cli from any terminal. Nothing else changes yet.

2. Authenticate + activate

Run 0dai auth login and 0dai activate free once. Open-source installs still use a free activation license.

3. Initialize the repo

Run 0dai init in the project root to detect the stack, bind the project, and fetch native configs from the API.

4. Verify + ship the first task

Use 0dai task run with a real goal so the swarm can route design, code, and tests.

Activation ladder

Install → Activate → Init → Doctor → First task

Compare free vs ProOpen Pro billing

FAQ

How do I upgrade to Pro?

Billing starts from the dashboard, then checkout runs through Wallet Pay when available or TON as fallback.

What's actually free?

CLI, init, sync, doctor, stack detection, supported agent CLIs, free activation, and 49 core MCP tools. Pro adds swarm, session roaming, and all 103 registered mcp tools.

Does my source code leave my machine?

No. We send file names and build manifests (package.json, go.mod, tsconfig) to detect your stack. Source stays local. The free graph is file-backed in your repo; the paid cloud Knowledge Graph substrate is planned separately.

Why not just copy CLAUDE.md around?

CLAUDE.md covers one agent's instructions. 0dai keeps shared memory (graph, outcomes, decisions) that every agent reads, plus native configs for each CLI, plus session roaming between them. Copy-paste gets you maybe 5% of that.

How does paid access work?

Fixed-duration access windows. Wallet Pay when available; TON fallback with proof submission otherwise.