JSPM

AI-Powered Multi-Agent Orchestration System
Structured vibe coding for Full Stack Development.

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 13 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:

1. Context Loss — AI forgets decisions across sessions, leading to inconsistent implementations
2. Planning Gaps — Jumping straight to code without structured requirements leads to rework
3. System Leakage — Users accidentally "fall out" of agent systems into generic AI mode

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 never accidentally leave the pipeline.

Quick Start

Prerequisites

• Node.js >= 20.0.0 (download)
• Claude Code — the CLI for Claude (install guide)

Other supported IDEs: VS Code, Cursor, Gemini CLI, GitHub Copilot, AntiGravity (see Supported IDEs).

1. Install in your project

Open a terminal in your project directory:

npx chati-dev init

The wizard asks your language and project type, then auto-configures everything.

2. Activate the orchestrator

Open Claude Code in the same project directory, then type:

/chati

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.

3. Follow the pipeline

The agents guide you through each phase:

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 5s

Exit & Resume

/chati exit     # Save session and exit
/chati          # Resume exactly where you left off

Key Features

Architecture

13 Agents, 4 Pipeline Phases

How the Pipeline Works

 You type /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 separate terminals ────────────┐
       │                                        │
       │    PLAN (autonomous, parallel)         │
       │    Detail ───┐                         │
       │    Architect ├─ run simultaneously     │
       │    UX ───────┘                         │
       │    Then: Phases → Tasks                │
       │                                        │
       ├─ Quality Gate ─────────────────────────┐
       │                                        │
       │    QA-Planning validates the plan      │
       │    Must score ≥ 95% to proceed         │
       │                                        │
       ├─ Spawns terminal(s) ───────────────────┐
       │                                        │
       │    BUILD                               │
       │    Dev implements tasks (parallel      │
       │    when tasks are independent)         │
       │                                        │
       ├─ Quality Gate ─────────────────────────┐
       │                                        │
       │    QA-Implementation validates code    │
       │    Tests + static analysis + coverage  │
       │                                        │
       └─ Spawns terminal ──────────────────────┐
                                                │
            DEPLOY                              │
            DevOps handles git, deploy, docs    │
                                                │
                                         ✓ Done │

Each spawned terminal runs as a separate claude -p --model <model> process with its own context window, write-scope isolation, and structured handoff output.

Intelligence Layer

Three systems operate transparently behind the pipeline:

Constitution

The system is governed by a 17-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. Binary pass/fail, not subjective
• Security — No secrets in system files. No destructive operations without confirmation
• 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 AI model (Opus, Sonnet, or Haiku)
• Execution Modes — Autonomous and human-in-the-loop with safety net and circuit breaker

Supported IDEs

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

Memory & Context

Inside an Active Session

Project Structure

your-project/
├── .chati/
│   ├── session.yaml              # Session state (auto-managed, gitignored)
│   └── memories/                 # Memory storage (gitignored)
├── .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 (gitignored)
├── chati.dev/
│   ├── orchestrator/             # Main orchestrator
│   ├── agents/                   # 13 agent definitions
│   │   ├── discover/             # Greenfield WU, Brownfield WU, Brief
│   │   ├── plan/                 # Detail, Architect, UX, Phases, Tasks
│   │   ├── quality/              # QA-Planning, QA-Implementation
│   │   ├── build/                # Dev
│   │   └── deploy/               # DevOps
│   ├── tasks/                    # 73 task definitions
│   ├── workflows/                # 6 workflow blueprints
│   ├── templates/                # 6 artifact templates
│   ├── schemas/                  # 5 JSON schemas
│   ├── intelligence/             # PRISM, RECALL, COMPASS specs
│   ├── domains/                  # Per-agent and per-workflow configs
│   ├── hooks/                    # 6 Claude Code hooks
│   ├── context/                  # Context files (deployed to .claude/rules/)
│   ├── 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           # 17 Articles + Preamble
│   └── config.yaml               # System configuration
└── packages/
    └── chati-dev/                # CLI + runtime engine

Internationalization

The installer and agent interactions support 4 languages:

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 version

Upgrades 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

MIT

_{Built with structure, validated by agents, governed by constitution.
Chati.dev © 2026}