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:

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:

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)

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

.ignite/
  ├── 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.