# Ignite 🔥

**Personalized, Observable, Memory-Driven Multi-Agent Development**

Ignite orchestrates the entire software development lifecycle through intelligent, parallel, multi-agent systems — **with real-time visibility, persistent memory, and deterministic workflows**.

You describe *what* you want—from complex architectures to specific features—and Ignite handles the rest:
**researching, planning, building, verifying, and evolving** your system while continuously learning *how you work*.

Ignite is the evolution of **Get Shit Done (GSD)** into an **engineering-grade development operating system**.

---

## ✨ Why Ignite?

Most AI coding tools are:

* Stateless
* Opaque
* Prompt-driven
* Easy to derail

Ignite is:

* 🧠 **Memory-first**
* 🔁 **Lifecycle-aware**
* 🤖 **Multi-agent**
* 👀 **Fully observable**
* 🎯 **Personalized to you**

No vibe coding.
No black boxes.
Just structured execution that improves over time.

---

## 🚀 Core Capabilities

### 🔁 Full Development Lifecycle

Ignite manages the entire journey:

* Discovery & research
* Architectural discussion
* Phase-based planning
* Parallel execution
* Verification & acceptance
* Continuous iteration

Every step produces explicit, auditable artifacts.

---

### 🧠 Persistent Memory & Personalization

Ignite continuously learns and remembers:

* Architectural decisions
* Trade-offs and assumptions
* Blockers and failure modes
* Successful patterns
* Your tech stack, standards, and preferences

Memory is **actively injected** into agent prompts to:

* Avoid repeating mistakes
* Enforce consistency
* Improve output quality over time

This is **personalized GSD**.

---

### 👀 Real-Time Observability (Ignite UI)

Ignite is not a black box.

Open a live web interface showing *everything* happening inside the system:

```bash
ignite:ui
```

The UI exposes:

* 🧠 Real-time memory stream
* 🗺️ Project milestones & phases
* 📋 Phase plans & revisions
* 🤖 Active agents and activity
* 📂 Generated artifacts

Autonomy without observability is not acceptable — Ignite gives you both.

---

## 🧩 How Ignite Works

### High-Level Flow

```
User → Ignite Commands → Orchestrators → Agents → Memory → Filesystem
                                       ↑
                                       └── Ignite UI (Live)
```

---

## ⌨️ Ignite Command Interface

All workflows are triggered through **`ignite:` commands**:

```bash
ignite:new-project
ignite:discuss-phase [N]
ignite:plan-phase [N]
ignite:execute-phase [N]
ignite:verify-work [N]

ignite:memory-search
ignite:similar-phases
ignite:project-insights

ignite:ui
```

Each command launches a **structured multi-agent workflow**, not a single prompt.

---

## 🧭 Workflow Orchestrators

Ignite uses dedicated orchestrators for each stage of development:

### Discover Orchestrator

* Clarifies problem space
* Aligns scope and constraints
* Enriches context using historical memory

### Discuss Orchestrator

* Captures architectural decisions
* Records trade-offs and assumptions
* Prevents premature execution

### Planning Orchestrator

* Produces deterministic phase plans
* Validates plans against memory
* Generates verifiable artifacts

### Execution Orchestrator

* Runs agents in parallel
* Applies coding standards
* Produces auditable output

---

## 🤖 Specialized Agents

Each agent has a focused role and access to shared memory:

| Agent              | Responsibility                 |
| ------------------ | ------------------------------ |
| Project Researcher | Domain & ecosystem research    |
| Phase Researcher   | Deep-dive research per phase   |
| Planner Agent      | Deterministic, testable plans  |
| Executor Agent     | Implementation & changes       |
| Verifier Agent     | Validation & acceptance checks |

All agents can:

* Query semantic memory
* Retrieve similar past phases
* Learn from previous outcomes

---

## 🧠 Memory Integration Layer

### Context Enrichment Engine

* Injects relevant memories into agent prompts
* Semantic search over past work
* Retrieves decisions, patterns, and blockers

### Observation Capture System

* Hooks into agent outputs
* Extracts structured knowledge
* Tags observations with:

  * Project
  * Phase
  * Agent
  * Milestone

Memory is **active**, not archival.

---

## 🗄️ Memory Storage

### Hybrid Storage Model

**SQLite**

* Sessions
* Observations
* Project metadata
* Timelines

**Chroma Vector Database**

* Observation embeddings
* Semantic similarity search
* Hybrid keyword + vector queries

### Memory Worker Service (HTTP API)

```http
/search?q=...
/store
/timeline
/similar
```

Designed to be:

* Local-first
* Open-source
* Vendor-agnostic
* CLI & UI friendly

---

## 🖥️ Ignite UI (Web View)

The `ignite:ui` command opens a local, self-hosted web interface.

### What You See (Live)

* 🧠 **Real-time memory stream**

  * New observations as they’re captured
  * Source agent & phase
  * Relevance scoring

* 🗺️ **Milestones & phases**

  * Current state
  * Dependencies
  * Completion progress

* 📋 **Phase plans**

  * Generated plans
  * Revisions over time
  * Linked research & summaries

* 🤖 **Agent activity**

  * Running agents
  * Current tasks
  * Memory queries & outputs

### Design Principles

* No hallucinated state
* Read-only by default
* Fully derived from real system data
* Time-travel friendly

Ignite UI makes autonomy **debuggable and trustworthy**.

---

## 📁 Filesystem as Source of Truth

Ignite produces explicit, inspectable artifacts:

```
.planning/
  ├── memory/              (SQLite + Chroma)
  ├── research/
  ├── 01-PLAN.md
  ├── 01-RESEARCH.md
  ├── 01-SUMMARY.md
  └── config.json

PROJECT.md
ROADMAP.md
REQUIREMENTS.md
STATE.md
```

No hidden state.
No magic.
Everything is auditable.

---

## 🧪 What Ignite Is (and Isn’t)

### Ignite Is

* A development orchestration system
* A memory-driven execution engine
* A personalized engineering assistant
* A long-running project companion

### Ignite Is Not

* A chat-only coding tool
* A prompt wrapper
* A black-box agent swarm
* A replacement for engineering judgment

---

## 🛠️ Built For

* Senior engineers
* Founders
* Small, high-leverage teams
* Long-running products
* Complex, evolving systems

If you care about:

* Architecture
* Consistency
* Speed without chaos
* Learning from history

Ignite is for you.

---

## 🔥 Philosophy

> **Describe intent once.
> Execute deterministically.
> Observe everything.
> Learn continuously.**