Sigil

A CLI that orchestrates a team of AI agents through the full software delivery lifecycle — from business idea to production software — with governance, inter-agent collaboration, human checkpoints, and learning memory.

$ sigil new "payment aggregator supporting Stripe, PayPal, and crypto"

One command. Sigil assembles the team (Product, Architect, Security, Backend, Frontend, QA, Reviewer), runs the pipeline, and delivers production-ready software with a complete audit trail.

The gap nobody fills: Governed multi-agent SDLC delivery with inter-agent communication, human checkpoints, learning memory, and audit-ready evidence — as a single CLI.

Quick Start

# Install
npm install -g @bhavanpatel/sigil

# Start a new project from an idea
sigil new "REST API with auth, rate limiting, and OpenAPI docs"

# Protocol injection — for self-orchestrating agents (Claude Code, Codex, Kiro, Windsurf)
sigil init --agent kiro

# Resume a paused run (waiting on human checkpoint)
sigil resume <run-id>

# See what's running
sigil runs list

Requirements: Node.js >= 20

When to Use Sigil

New Project from an Idea

You have a business idea but no code yet. Sigil orchestrates agents through discovery → requirements → architecture → implementation → testing → review → delivery:

sigil new "payment aggregator supporting Stripe, PayPal, and crypto"

Human checkpoints let you approve or redirect at critical points.

Existing Project — Add a Feature

Sigil detects your stack and runs the right agents with relevant skills:

cd my-project
sigil detect                    # See what Sigil knows about your stack
sigil new "add OAuth2 login with Google and GitHub providers"

Targeted Fix

Quick, minimal-stage execution:

sigil new "fix: users can submit empty payment forms" --scope hotfix

Explore Without Building

Agents analyze your codebase and suggest improvements:

sigil run --harness discovery-only

Plan Without Implementing

Architecture decisions, API contracts, and a full plan — stops before code:

sigil run --harness planning-only

Protocol Injection (Agent Self-Orchestrates)

If you prefer your existing agent to follow the Sigil workflow itself rather than Sigil spawning it:

sigil init --agent kiro         # Injects protocol into .kiro/steering/
sigil init --agent cursor       # Injects into .cursorrules
sigil init --agent claude       # Injects into CLAUDE.md
sigil init --agent codex        # Injects into codex.md
sigil init --agent windsurf     # Injects into .windsurfrules

Then tell your agent: "sigil this: add user authentication" and it follows the injected protocol.

Architecture at a Glance

graph TD
    A[Business Idea] --> B["Sigil CLI"]
    B --> C["Run Engine<br/>DAG · State Machine · Checkpoints · Resume"]
    C --> D["Agent Runtime<br/>Claude Code · Codex · Kiro · Cursor · Windsurf"]
    C --> E["Capability Router<br/>Domain match · Model affinity · Methodology"]
    D --> F["Communication Bus<br/>Review · Debate · Messaging"]
    F --> G[Human Loop]
    F --> H[Governance Engine]
    F --> I[Learning Engine]
    F --> J[Artifact Store]
    C --> K["Budget Tracker<br/>Tokens · Cost · Limits · Alerts"]

| Component | Role | | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | Run Engine | State machine for SDLC execution. DAG resolution (Kahn's algorithm), stage transitions, error recovery with exponential backoff and circuit breaker. | | Agent Runtime | Provider-agnostic adapter interface. Agents are roles, not LLMs. Swap Claude for Codex without changing pipelines. | | Capability Router | Score-based task routing: domain match + methodology skills + model affinity + task complexity. | | Prompt Compiler | Compiles identity + skills + memory + output contract into a system prompt per agent invocation. | | Communication Bus | Inter-agent messaging — reviews, flags, questions, decisions, challenges. File-backed for crash recovery. | | Debate Protocol | Adversarial proposer/challenger rounds with time-boxing and escalation rules. Prevents infinite loops. | | Review Protocol | Structured review cycles with configurable rounds, blocking issues, and verdicts. | | Human-in-the-Loop | Interactive checkpoints. Approve, revise, reject, or skip. Agent-initiated questions. | | Governance Engine | Named policy sets (SOC2, HIPAA), evidence generation, artifact lineage graph. | | Learning Engine | Dual-layer memory (project + global). Auto-captures decisions, patterns, review outcomes. | | Budget Tracker | Per-agent and per-run token/cost tracking with configurable limits and alerts. |

CLI Reference

| Command | Description | | ----------------------------- | ------------------------------------------------------------------ | | sigil new "<idea>" | Start a new orchestrated run from a business idea | | sigil run --harness <name> | Execute a specific harness in the current project | | sigil resume <run-id> | Resume a paused run (waiting on human checkpoint) | | sigil runs list | List all runs | | sigil runs inspect <id> | Inspect a run's state and artifacts | | sigil init --agent <name> | Inject protocol files for self-orchestrating agents | | sigil detect | Detect project type, recommend skills and harness | | sigil list-harnesses | List available harness presets | | sigil trace <run-id> | Walk the lineage graph (idea → requirement → code → test → deploy) | | sigil evidence <run-id> | Generate audit-ready evidence report | | sigil memory search <query> | Search learning memory | | sigil memory list | List memory entries | | sigil memory add <entry> | Add a manual memory entry (interactive) | | sigil memory stats | Show memory statistics | | sigil memory export | Export memory to JSON | | sigil memory import <file> | Import memory from JSON |

Output Modes

Sigil automatically detects the terminal environment and adjusts output:

| Mode | When | Behavior | | ---------- | ------------------------ | -------------------------------------------------- | | TTY | Interactive terminal | Colored output, progress indicators, live updates | | Pipe | Piped to another command | Clean text, no colors, machine-parseable | | NDJSON | --json | Newline-delimited JSON events for programmatic use |

# Machine-readable output for CI/CD pipelines
sigil runs list --json

# Pipe-friendly (auto-detected when stdout is not a TTY)
sigil runs list | grep completed

Modes of Operation

Direct orchestration (sigil new) — Sigil spawns and manages agents as subprocesses. Controls execution, routing, checkpoints, and communication.

Protocol injection (sigil init) — Generates workflow protocol into your project. Your agent follows it autonomously. Sigil provides the structure without being the runtime.

Features

🤖 37 Agents

27 Lifecycle agents covering the full SDLC:

scope → scan → knowledge → constraints →
discover → ideate → decide → refine →
validate → prd → architecture → api-design →
plan → test-design → security → infra-plan →
scaffold → implement → unit-test → integrate →
review → fix → e2e-test → document →
deploy → verify → release → retrospect

9 Specialists: performance · data-model · devops · ux-review · documentation · security-audit · frontend-impl · backend-impl · mobile-impl

🧠 129 Skills (14 Methodology)

Dynamically injected based on project detection:

| Domain | Count | Domain | Count | | ------- | ----- | ------------- | ----- | | testing | 15 | frontend | 13 | | backend | 11 | data | 10 | | infra | 8 | architecture | 7 | | core | 7 | documentation | 7 | | mobile | 7 | security | 7 | | design | 6 | devops | 5 | | product | 5 | messaging | 4 | | ai | 4 | platform | 4 | | cloud | 3 | performance | 1 |

14 Methodology skills at priority 90: C4, STRIDE, SRE, Diataxis, dual-track agile, and more.

🎯 22 Harnesses

Pipeline presets with configurable automation:

| Category | Harnesses | | ----------- | ------------------------------------------------------------------------------------------------------------------------- | | Quick | hotfix · task | | Feature | feature · api-service · fullstack-app · mobile-app · microservice · design-system | | Project | project · enterprise · supervised · semi-auto · full-lifecycle | | Special | spike · refactor · migration · security-audit · documentation · data-pipeline · planning-only · dev-loop · discovery-only |

From 2-stage hotfixes to 28-stage enterprise delivery.

🔌 Multi-Adapter Runtime

Agents are roles, not LLMs. Swap freely per stage:

| Adapter | Backend | | -------------- | ------------ | | claude-cli | Claude Code | | codex-cli | OpenAI Codex | | kiro-cli | Kiro | | windsurf-cli | Windsurf | | mock | Testing |

Capability Router scores agents by domain match, methodology skills, model affinity, and task complexity.

Prompt Compiler assembles identity + skills + memory + output contract per invocation.

🏛️ Governance

| Feature | Description | | ---------------- | ----------------------------------------- | | Policies | Named sets: SOC2, HIPAA, default | | Evidence | Auto-generated audit reports per run | | Lineage | Artifact graph with BFS traversal | | Traceability | idea → requirement → code → test → deploy | | Gates | Approval · Automated (Zod) · Conditional |

💾 Learning Memory

| Feature | Description | | ---------------- | ---------------------------------------------------- | | Dual-layer | Project .sigil/memory/ + global ~/.sigil/memory/ | | Auto-capture | Decisions, gate failures, reviews, debates | | Injection | Relevant memories prepended to agent prompts | | Search | Scored by weight · recency · tags | | Portable | Export/import across projects |

⚡ Budget Tracker

• Per-agent and per-run token/cost tracking
• Configurable warn + hard-stop limits
• Real-time alerts via callbacks
• Per-harness budget policies

🔄 Enhanced Debate

• Time-boxing prevents infinite loops
• Escalation rules: auto-accept or escalate-to-human
• Structured phases: opening → challenge → rebuttal → resolution
• All decisions captured to memory

Programmatic API

import { runHarness, createFullRegistry, detectProject } from 'sigil';
import { RunEngine, AgentRuntimeRegistry } from 'sigil/runtime';

// Engine-level orchestration
const engine = new RunEngine(runStore, runtimeRegistry);
const run = await engine.execute({
  idea: 'payment aggregator',
  harness: 'api-service',
});

// Project detection + skill injection
const profile = await detectProject(fileExists, fileReader);
const registry = createFullRegistry();
const skills = getSkillsForProfile(profile, registry);

What Makes Sigil Different

| Others | Sigil | | -------------------------------------------------- | ---------------------------------------------------------- | | Single coding agents (Devin, Claude Code, Codex) | Orchestrates teams of agents as replaceable workers | | Generic multi-agent frameworks (CrewAI, LangGraph) | SDLC-specific with deep domain knowledge (129 skills) | | Linear pipelines (ticket → PR → release) | Inter-agent debate, review protocols, conflict resolution | | Stateless execution | Persistent runs, cross-run learning, organizational memory | | No governance | Named policy sets, evidence generation, full traceability | | Single LLM lock-in | Provider-agnostic: 5 adapters, swap freely per stage |

Tech Stack

• TypeScript (strict mode, exactOptionalPropertyTypes)
• Node.js >= 20, ESM
• CLI: Commander.js (lightweight, POSIX-compliant argument parsing)
• Output: @clack/prompts (interactive), chalk + boxen (formatting), marked + marked-terminal (markdown rendering)
• Validation: Zod
• Testing: Vitest
• CI: GitHub Actions (lint, format, build, test)

Contributing

git clone https://github.com/BhavanPatel/sigil.git
cd sigil
npm install
npm test
npm run build

TypeScript strict mode. ESM imports with .js extensions. exactOptionalPropertyTypes enforced — use conditional spread for optional props.

License

MIT