chati-dev
v4.4.1
Published
AI-Powered Multi-Agent Orchestration System - Structured vibe coding for Full Stack Development
Maintainers
ogabrielalonsoReadme
What is Chati.dev?
Chati.dev is a system that turns AI into a structured development team. Instead of chatting with a single AI that forgets everything between sessions, you get specialized agents - each with a clear role - working together through a defined pipeline.
You describe what you want to build. The agents handle requirements, architecture, planning, coding, testing, and deployment - in order, with quality gates between each phase.
You → DISCOVER → PLAN → BUILD → DEPLOY → Done
"what" "how" "code" "ship"Every decision is saved. Every artifact is validated. If you close your laptop and come back tomorrow, the system picks up exactly where you left off.
Why Chati.dev?
The Problem
AI-assisted development today has three critical issues:
- Context Loss - AI forgets decisions across sessions, leading to inconsistent implementations
- Planning Gaps - Jumping straight to code without structured requirements leads to rework
- Vendor Lock-in - Most AI dev tools only work with one provider, limiting flexibility
The Solution
Chati.dev introduces Agent-Driven Development: a pipeline where each agent owns a specific phase, produces validated artifacts, and hands off context to the next agent. The system ensures context is never lost, knowledge persists across sessions, and you can use any supported AI provider.
Quick Start
Prerequisites
- Node.js >= 20.0.0 (download)
- An AI CLI - at least one of:
- Claude Code (recommended)
- Gemini CLI
- Codex CLI
1. Install in your project
Open a terminal in your project directory:
npx chati-dev initThe wizard guides you through 4 steps:
| Step | What it asks | |------|-------------| | Language | English, Portuguese, Spanish, or French | | Project Type | Greenfield (new) or Brownfield (existing) | | AI Provider | Claude, Gemini, or Codex - auto-configures optimal models per agent | | Confirm | Review summary and proceed |
2. Activate the orchestrator
Open your AI CLI in the same project directory, then type:
| CLI | Command | Notes |
|-----|---------|-------|
| Claude Code | /chati | Slash command (native) |
| Gemini CLI | /chati | TOML custom command |
| Codex CLI | $chati | Skill invocation (Codex uses $ for skills, not /) |
The orchestrator loads your session, detects where you left off, and routes you to the right agent. You stay inside the system until you explicitly exit.
Codex CLI note: You can also just describe what you want (e.g., "start chati" or "plan my project") and Codex will auto-invoke the skill based on its description.
3. Follow the pipeline
The agents guide you through each phase:
| Phase | What happens | You do | |-------|-------------|--------| | DISCOVER | Agents interview you about what you want to build | Answer questions about your project | | PLAN | Agents create PRD, architecture, UX spec, phases, and tasks | Review and approve the plan | | BUILD | Dev agent implements the code, task by task | Review code as it's built | | DEPLOY | DevOps agent handles git, deployment, and documentation | Confirm deployment settings |
Quality gates run automatically between phases. If something doesn't meet the threshold, the system loops back and fixes it.
Monitor progress
npx chati-dev status # One-time snapshot
npx chati-dev status --watch # Auto-refresh every 5sExit & Resume
| CLI | Exit | Resume |
|-----|------|--------|
| Claude Code | /chati exit | /chati |
| Gemini CLI | /chati exit | /chati |
| Codex CLI | $chati exit | $chati |
The system saves your full session state (pipeline position, current agent, decisions, and context). You resume exactly where you left off, even across days or machines.
Key Features
| Feature | What it means |
|---------|--------------|
| Specialized Agents | Each agent has a defined mission, success criteria, and handoff protocol. Not one AI trying to do everything |
| Agent Teams | Planning Team (Detail + Architect + UX + QA-Planning) and Build Team (Dev + QA-Implementation) with Wave-Based Pipeline. Teams work in parallel with peer-to-peer communication, cross-review, and intra-team quality assurance. No single agent bottleneck |
| Visual QA | QA-Visual scores the rendered UI against an 8-dimension rubric (layout, typography, motion, interaction, color, spacing, accessibility, performance) with an anti-slop catalog and a spring-motion veto (linear easing and transition: all are rejected). Screenshots at multiple scroll positions, hover states, and brandbook compliance, powered by Playwright. |
| Premium Motion | Premium motion is required for UI projects, with cubic-bezier easing and full reduced-motion support. The visual gate is animation-stack aware: the motion-premium presets use GSAP + Lenis, the saas-dashboard preset uses framer-motion. |
| Scaffold Presets | Premium starting points applied at build time: motion-premium and motion-premium-3d for animated showcase sites, saas-dashboard for a token-driven app shell (sidebar, sortable data table, KPI cards, a Cmd+K command palette). |
| Execution Kinds | A task declares how it executes. Deterministic dev tasks (lint, tests, file and schema checks) run as zero-LLM scripts through whitelisted executors instead of spending an agent turn. Feature-flagged, off by default, fully back-compatible. |
| Multi-CLI Architecture | Choose your AI provider at install time: Claude, Gemini, or Codex. Each agent gets the optimal model for that provider |
| Quality Gates | Every phase is validated before moving forward, including QA-Visual for visual quality. 3-tier verdicts: APPROVED, NEEDS_REVISION, or BLOCKED |
| Fault Vector Protocol | Root Layer Routing classifies bugs by origin (INTENT/SPEC/CODE/DEFER). Evidence-Bound Verdicts, Decision Trail, and Echo Detection prevent cyclical rework |
| Context Persistence | Sessions survive restarts. Close your IDE, come back next week - the system remembers everything |
| Session Lock | Once activated, you stay inside the system. No accidentally "falling out" into generic AI mode |
| Multi-Terminal | Autonomous agents run in parallel. Planning Team (Detail + Architect + UX + QA-Planning) and Build Team (Dev + QA-Implementation) coordinate via peer-to-peer mailbox |
| Memory System | The system learns from mistakes. Gotchas are captured automatically and recalled when relevant |
| Execution Mode | Two modes: interactive (default) and autonomous (gate >= 95%). Safety reversion to interactive on stuck loop, quality drop, scope creep, error cascade, or user override (Article XVII) |
| IDE-Agnostic | Works with Claude Code, VS Code, Cursor, Gemini CLI, Codex CLI, and AntiGravity |
| 4 Languages | Interface supports English, Portuguese, Spanish, and French. Artifacts are always generated in English |
| Supply Chain Security | Every file is cryptographically signed (Ed25519). Tampered packages are blocked on install |
| Intelligence Upgrade | Per-turn memory extraction, dream consolidation, daily digest, frustration detection, microcompact advisory |
| 23-Point Bash Security | Shell injection defense system: IFS injection, unicode attacks, command substitution, dangerous variables |
| Model-Aware Context | Opus gets 1M context window, Sonnet/Haiku get 200K. Bracket tracker scales proportionally |
| Undercover + Style Guard | Framework terms sanitized from deliverables. Em-dashes and emojis blocked at hook level |
| Orchestrator v2 | Thin prompt + deterministic CLI handler. 5 user commands, natural language for everything else |
Multi-CLI Support
Chati.dev is provider-agnostic. You choose your AI provider during installation, and the system auto-configures optimal model assignments for every agent.
Supported Providers
| Provider | CLI | Deep Reasoning | Lightweight | Status |
|----------|-----|---------------|-------------|--------|
| Claude | claude | Opus | Sonnet / Haiku | Default |
| Gemini | gemini | Pro | Flash | Full support |
| Codex | codex | Codex | Codex Mini | Full support |
How Model Assignment Works
Each agent is classified by its reasoning needs:
- Deep reasoning (Architect, QA, Dev, Detail, Brownfield-WU) → top-tier model
- Lightweight (Brief, Phases, UX, Greenfield-WU, DevOps, Orchestrator) → fast model
When you select a provider, the system maps each agent to the best available model:
Claude: architect → opus, brief → sonnet, greenfield-wu → haiku
Gemini: architect → pro, brief → flash, greenfield-wu → flash
Codex: architect → codex, brief → codex-miniCLI Invocation Syntax
Each provider uses its own CLI syntax. Chati.dev handles this transparently:
| Provider | Command | Example |
|----------|---------|---------|
| Claude | claude --print --model <id> | claude --print --model claude-opus-4-6 |
| Gemini | gemini --model <id> | gemini --model gemini-2.5-pro |
| Codex | codex exec -m <id> | codex exec -m gpt-5.3-codex |
Prompts are piped via stdin for all providers. You can override individual agent models in .chati.dev/config.yaml under agent_overrides.
Execution Mode
Two modes control how much autonomy agents have:
| Mode | Behavior | When to use | |------|----------|-------------| | interactive | Default. Agents propose changes, you approve | Normal development workflow | | autonomous | Agents execute without confirmation (quality gates >= 95%) | Trusted pipelines with high quality scores |
The system starts in interactive mode. Transition to autonomous requires both QA gates scoring >= 95%. Safety reversion takes the pipeline back to interactive on a stuck loop, quality drop, scope creep, error cascade, or user override (Article XVII).
Architecture
Specialized Agents, 4 Pipeline Phases
| Phase | Agents | What they do | |-------|--------|-------------| | DISCOVER | Greenfield WU, Brownfield WU, Brief | Interview you, understand your project, extract requirements | | PLAN | Planning Team (Detail + Architect + UX + QA-Planning), Phases, Tasks | Create PRD, architecture, UX spec with cross-review. QA-Planning validates all 3 artifacts before the team dissolves | | BUILD | Build Team (Dev + QA-Implementation) with Wave-Based Pipeline. After build: QA-Visual validates visual quality. | Implement code task by task, with per-task quality review and visual validation | | DEPLOY | DevOps | Handle git operations, deployment, and documentation |
How the Pipeline Works
You activate the orchestrator (/chati or $chati)
│
▼
┌──────────────────────────────────────────────┐
│ ORCHESTRATOR │
│ Routes you to the right agent. │
│ Manages session state and handoffs. │
└──────────────────────────────────────────────┘
│
├─ In your conversation ─────────────────┐
│ │
│ DISCOVER (interactive) │
│ WU interviews you → Brief compiles │
│ requirements into a structured doc │
│ │
├─ Spawns Planning Team ──────────────────┐
│ (4 agents, peer communication) │
│ │
│ PLAN │
│ Detail ───┐ │
│ Architect ├─ run simultaneously │
│ UX ───────┘ with cross-review │
│ │ │
│ QA-Planning activates after trio │
│ Reviews all 3 artifacts (>= 95%) │
│ Sends feedback via mailbox │
│ Team dissolves when approved │
│ │ │
│ Then: Phases → Tasks │
│ │
├─ Spawns Build Team ────────────────────┐
│ (2 agents, Wave-Based Pipeline) │
│ │
│ BUILD │
│ Build Waves: Dev + QA in parallel │
│ Cleanup Wave: fixes remaining warns │
│ Visual QA Wave: QA-Visual validates │
│ screenshots, GSAP/Lenis, brandbook │
│ Final QA: Triple Review │
│ │
└─ Spawns terminal ──────────────────────┐
│
DEPLOY │
DevOps handles git, deploy, docs │
│
✓ Done │Each spawned terminal runs as a separate CLI process with its own context window, write-scope isolation, and structured handoff output. The AI provider and model are selected automatically based on your configuration.
Intelligence Layer
Three systems operate transparently behind the pipeline:
| System | What it does | |--------|-------------| | Context Engine (PRISM) | Injects the right context at the right time. 6 layers of context (from constitution rules down to keyword-matched domain rules). Uses Progressive Reinforcement: as context degrades, injection budgets INCREASE (1.5% to 5.0% of provider context window). Provider-aware for Claude (1M), Gemini (1M), and Codex (128K). | | Memory System (RECALL) | Remembers decisions, gotchas, and lessons across sessions. Organized into 4 sectors: what happened (episodic), what we know (semantic), how we do things (procedural), and what we learned (reflective). | | Decision Engine (COMPASS) | Before creating something new, checks if a similar component already exists. Decides whether to reuse, adapt, or create from scratch. Keeps a registry of all project entities. |
Constitution
The system is governed by a 25-article Constitution that enforces agent behavior, quality standards, security, and system integrity:
- Agent Governance - Every agent has a defined mission, scope, and success criteria
- Quality Standards - Minimum 95% score on quality gates. 3-tier verdicts (APPROVED / NEEDS_REVISION / BLOCKED)
- Security - No secrets in system files. No destructive operations without confirmation. Ed25519 supply chain verification
- Mode Governance - Planning mode can't modify project code. Build mode has full access
- Session Lock - Once activated, all messages route through the orchestrator
- Model Governance - Each agent runs on its designated model, enforced by the CLI adapter
- Execution Mode - Interactive (default) and autonomous modes, with safety reversion to interactive (Article XVII)
- Multi-CLI - Provider-agnostic architecture with adapter pattern and automatic model mapping
- Agent Teams - Real-time peer communication between agents with cross-review, per-task QA, and sealed-bid quality assurance
- Fault Vector Protocol - Root Layer Routing, Evidence-Bound Verdicts, Decision Trail, and Echo Detection for adversarial quality
- Anti-Loop Protocol - the 3-Strike Rule and mandatory diagnosis mode stop an agent from editing the same file in circles
- Reasoning Tier - per-task cognitive depth (standard / deep / deliberate) with deterministic escalation
- Model-Harness Parity - a re-audit advisory when the active model family changes, so calibration does not drift silently
- Execution Kinds - a task declares how it runs (agent, deterministic script, specialist, or human gate); deterministic dev work can run with no model call (feature-flagged, off by default)
Supported IDEs
| IDE | How it connects | Activation |
|-----|----------------|------------|
| Claude Code | .claude/commands/chati.md → orchestrator | /chati |
| Gemini CLI | .gemini/commands/chati.toml → orchestrator | /chati |
| Codex CLI | .agents/skills/chati/SKILL.md → orchestrator | $chati |
| VS Code | .vscode/chati.md → orchestrator | Extension-dependent |
| Cursor | .cursor/rules/chati.md → orchestrator | Extension-dependent |
| AntiGravity | Platform agent config → orchestrator | Platform-dependent |
All IDEs use a thin router file that points to the same orchestrator. Your project works the same regardless of which IDE you use.
CLI Commands
Setup & Maintenance
| Command | Description |
|---------|-------------|
| npx chati-dev init | Initialize new project with guided wizard |
| npx chati-dev install | Install into existing project |
| npx chati-dev status | Show project dashboard |
| npx chati-dev status --watch | Auto-refresh dashboard every 5s |
| npx chati-dev health | Run system health check (5 checks) |
| npx chati-dev check-update | Check for updates |
| npx chati-dev upgrade | Upgrade to latest version |
| npx chati-dev upgrade --version X.Y.Z | Upgrade to specific version |
| npx chati-dev --reconfigure | Reconfigure installation |
| npx chati-dev changelog | View changelog |
Memory & Context
| Command | Description |
|---------|-------------|
| npx chati-dev memory stats | Show memory statistics |
| npx chati-dev memory list | List memories (filter by --agent, --sector, --tier) |
| npx chati-dev memory search <query> | Search memories by tags or content |
| npx chati-dev memory clean | Clean expired memories (--dry-run to preview) |
| npx chati-dev context | Show context bracket status |
| npx chati-dev registry stats | Show entity registry statistics |
| npx chati-dev registry check | Validate registry against filesystem |
Inside an Active Session
| Action | Claude Code / Gemini | Codex CLI |
|--------|---------------------|-----------|
| Start or resume session | /chati | $chati |
| Show pipeline progress | /chati status | $chati status |
| Show available commands | /chati help | $chati help |
| Resume from continuation | /chati resume | $chati resume |
| Save session and exit | /chati exit | $chati exit |
Project Structure
At a glance, an installed project looks like this:
your-project/
├── CLAUDE.md # Project context (auto-generated)
├── CLAUDE.local.md # Runtime session lock
├── artifacts/ # Pipeline output (visible to user)
│ ├── 0-WU/
│ ├── 1-Brief/
│ ├── 2-PRD/
│ ├── 3-Architecture/
│ ├── 4-UX/
│ └── handoffs/
├── .chati.dev/ # Framework (hidden)
│ ├── agents/
│ ├── hooks/
│ ├── orchestrator/
│ ├── constitution.md
│ └── config.yaml
├── .chati/ # Runtime session state (hidden)
├── .claude/ # Claude Code settings + rules (hidden)
└── .gitignoreThe full layout below shows the Claude Code layout (default). Gemini and Codex get equivalent files in their native locations.
your-project/
├── .chati/
│ ├── session.yaml # Session state (auto-managed, gitignored)
│ └── memories/ # Memory storage (gitignored)
│
│── # ─── Claude Code ───────────────────
├── .claude/
│ ├── commands/
│ │ └── chati.md # Thin router → orchestrator
│ └── rules/
│ └── chati/ # Framework context (auto-loaded)
│ ├── root.md # System overview
│ ├── governance.md # Constitution rules
│ ├── protocols.md # Universal protocols
│ └── quality.md # Quality standards
├── CLAUDE.md # Project context (auto-generated)
├── CLAUDE.local.md # Runtime state / session lock (gitignored)
│
│── # ─── Gemini CLI (when selected) ────
├── .gemini/
│ ├── commands/
│ │ └── chati.toml # TOML command → orchestrator
│ ├── context/ # 4 framework context files (@imported by GEMINI.md)
│ ├── hooks/ # Gemini hooks (governance parity with Claude Code)
│ ├── settings.json # Hook configuration
│ └── session-lock.md # Runtime state / session lock (gitignored)
├── GEMINI.md # Project context with @import chain
│
│── # ─── Codex CLI (when selected) ─────
├── .agents/skills/chati/
│ └── SKILL.md # Skill definition → orchestrator
├── .codex/rules/ # Starlark execution policies (constitution-guard, read-protection)
├── AGENTS.md # Project context with inline governance
├── AGENTS.override.md # Runtime state / session lock (gitignored)
│
│── # ─── Framework (hidden) ────────────
├── .chati.dev/
│ ├── orchestrator/ # Main orchestrator
│ ├── agents/ # Agent definitions
│ │ ├── discover/ # Greenfield WU, Brownfield WU, Brief
│ │ ├── plan/ # Detail, Architect, UX, Phases, Tasks
│ │ ├── quality/ # QA-Planning, QA-Implementation
│ │ ├── build/ # Dev
│ │ └── deploy/ # DevOps
│ ├── workflows/ # 7 workflow blueprints
│ ├── templates/ # 12 artifact templates
│ ├── schemas/ # 5 JSON schemas
│ ├── intelligence/ # PRISM, RECALL, COMPASS specs
│ ├── domains/ # Per-agent and per-workflow configs
│ ├── hooks/ # Shared hooks (used by Claude + Gemini)
│ ├── context/ # Context files (deployed per provider)
│ ├── frameworks/ # Decision heuristics
│ ├── quality-gates/ # Planning & implementation gates
│ ├── patterns/ # Elicitation patterns
│ ├── data/ # Entity registry
│ ├── i18n/ # EN, PT, ES, FR translations
│ ├── migrations/ # Version migration scripts
│ ├── constitution.md # 23 Articles + Preamble
│ └── config.yaml # System configuration
└── packages/
└── chati-dev/ # CLI + runtime engineInternationalization
The installer and agent interactions support 4 languages:
| Language | Code | Status |
|----------|------|--------|
| English | en | Default |
| Português | pt | Full support |
| Español | es | Full support |
| Français | fr | Full support |
Artifacts are always generated in English for portability and team collaboration.
Upgrade System
npx chati-dev check-update # Check for updates
npx chati-dev upgrade # Upgrade to latest
npx chati-dev upgrade --version 1.2.1 # Specific versionUpgrades include automatic backup, migrations, validation, and config merging. Rollback on failure.
Contributing
We welcome contributions: agents, templates, workflows, translations, and CLI improvements. See CONTRIBUTING.md for guidelines.
Security
For security concerns, see our Security Policy.
License
Elastic License 2.0 - free to use for any purpose; you may not offer it as a hosted/managed service to third parties or remove licensing notices.