A multi-agent orchestration toolkit for Claude Code that produces high-quality code through structured validation layers with persistent institutional memory 🧠. Instead of asking an AI to "build X" and hoping for the best, OMEGA forces every piece of code through questioning, architecture design, test-driven development, implementation, QA validation, and review — each handled by a specialized agent that reads from and writes to a shared knowledge base.
Claude is great at writing code. It's remarkably stupid at analyzing problems. Its default behavior is to rush toward resolution — picking an interpretation and running with it instead of questioning, sitting with uncertainty, or doing root cause analysis. This isn't a configuration issue; it's a documented structural bias in how the model reasons: premature closure, discomfort with "I don't know," and a pull toward making things feel done before they're understood.
When you ask it to write code directly, it:
- 🙈 Assumes things instead of asking — leading to silent bugs
- 🔄 Writes tests after code — biasing tests toward what was built, not what should be built
- 🏗️ Skips architecture — jumping straight to implementation without thinking through design
- 📖 Ignores context — not reading existing code conventions, patterns, or documentation
- 📉 Lets documentation rot — specs and docs drift out of sync with the actual codebase
- 🔗 Has no traceability — requirements, tests, and code aren't linked, so gaps go unnoticed
- 🧹 Forgets everything — each session starts fresh with zero knowledge of past decisions, failures, or patterns
OMEGA solves all of that. ✅
When you run an OMEGA command, the orchestrator (your Claude Code session) coordinates the pipeline. Each agent runs as a sub-agent in its own isolated context window — it can't see what other agents did. Agents communicate through artifacts (files in specs/, docs/) and memory.db (the shared knowledge layer that persists across all agents and sessions).
┌─ YOUR CLAUDE CODE SESSION ──────────────────────────────────────────────────┐
│ │
│ ORCHESTRATOR CONTEXT (main conversation) │
│ ┌────────────────────────────────────────────────────────────────────────┐ │
│ │ • Owns the pipeline flow (which agent runs next) │ │
│ │ • Reads compressed outputs from each sub-agent │ │
│ │ • Passes artifacts between stages (specs, docs, test files) │ │
│ │ • Survives the entire workflow — but compresses older messages │ │
│ └────────────────────────────────────────────────────────────────────────┘ │
│ │
│ Each agent below runs as a SUB-AGENT — a separate process with │
│ its own fresh context window. It sees ONLY what the orchestrator │
│ passes to it (prompt + file access + memory.db). │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Analyst │ │Architect │ │ Test │ │Developer │ │ Reviewer │ │
│ │ │ │ │ │ Writer │ │ │ │ │ │
│ │ own │ │ own │ │ own │ │ own │ │ own │ │
│ │ context │ │ context │ │ context │ │ context │ │ context │ │
│ │ window │ │ window │ │ window │ │ window │ │ window │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────┐ │
│ │ SHARED STATE (persists across all agents) │ │
│ │ │ │
│ │ 📁 Artifacts 🧠 memory.db 📄 specs/ & docs/ │ │
│ │ (files on disk) (decisions, findings, (requirements, │ │
│ │ failed approaches, architecture, │ │
│ │ hotspots, incidents) test plans) │ │
│ └──────────────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────────────────┘
Key implications:
- No agent sees another agent's reasoning — only its output artifacts. The Architect can't see the Analyst's internal thought process, only the requirements document it produced.
- Each sub-agent gets 100% of its context for its task — it's not competing for space with other agents' work.
- The orchestrator's context grows as it coordinates more agents, but each agent's compressed summary (not full output) is what stays in the orchestrator.
- memory.db is the long-term bridge — behavioral learnings, failed approaches, and decisions persist across sessions, not just agents.
Thirty-six core agents execute in chain or standalone, each with a single responsibility. Every agent has mandatory briefing/incremental logging/close-out phases — querying memory.db before starting, writing continuously during work, and verifying completeness after finishing.
┌─ YOUR CLAUDE CODE SESSION ───────────────────────────────────────────────────────┐
│ │
│ Your Idea │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ ORCHESTRATOR registers pipeline in memory.db │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ┌────────────────────────────┼────────────────────────────────────────────┐ │
│ │ SEQUENTIAL SUB-AGENTS (each gets its own fresh context) │ │
│ │ │ │
│ │ Discovery ──────► compressed summary ──────────────────────────►──┐ │ │
│ │ (own context) returned to orchestrator │ │ │ │
│ │ │ │ │ │
│ │ Evaluator ──────► GO/NO-GO verdict ───────────────────────►───┤ │ │ │
│ │ (own context) returned to orchestrator │ │ │ │ │
│ │ │ │ │ │ │
│ │ Analyst ────────► requirements doc (specs/) ──────────►───┤ │ │ │ │
│ │ (own context) + compressed summary │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │ │
│ │ Architect ──────► architecture doc (specs/) ────► Orchestrator │ │ │
│ │ (own context) + compressed summary holds these │ │ │
│ │ compressed │ │ │
│ │ summaries + │ │ │
│ │ artifact refs │ │ │
│ └────────────────────────────┼────────────────────────────────────────────┘ │
│ │ │
│ ┌────────────────────────────┼────────────────────────────────────────────┐ │
│ │ PER-MILESTONE LOOP (auto-continues) │ │
│ │ │ │
│ │ Test Writer ────► test files on disk ──────────────────────────►──┐ │ │
│ │ (own context) reads: requirements + architecture from specs/ │ │ │
│ │ │ │ │
│ │ Developer ──────► implementation on disk ─────────────────►───┐ │ │ │
│ │ (own context) reads: tests + architecture from specs/ │ │ │ │
│ │ │ │ │ │
│ │ Compiler ───────► pass/fail (bash, not a sub-agent) ──►───┐ │ │ │ │
│ │ │ │ │ │ │
│ │ QA ─────────────► validation report ──────────────►───┐ │ │ │ │ │
│ │ (own context) reads: requirements + actual code │ │ │ │ │ │
│ │ │ │ │ │ │ │
│ │ Reviewer ───────► findings ──────────────────►────┐ │ │ │ │ │ │
│ │ (own context) reads: all artifacts + code │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │
│ │ Security ──────► probe report ───────────►──┐ │ │ │ │ │ │ │
│ │ Prober CRITICAL/HIGH block commit │ │ │ │ │ │ │ │
│ │ (own context) NO QA/reviewer context ▼ ▼ ▼ ▼ │ │ │ │
│ │ Orchestrator │ │ │ │
│ │ decides next │ │ │ │
│ │ milestone or │ │ │ │
│ │ completion │ │ │ │
│ └────────────────────────────┼────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ Pipeline completes — memory.db populated incrementally throughout │ │
│ │ Behavioral learnings extracted — available to ALL future sessions │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────────────────┘
See the full Installation & Deployment guide — prerequisites, omg CLI, shell script, setup options, and what gets deployed.
omega/
├── core/ # Every project gets this
│ ├── agents/ # 38 universal agents
│ ├── commands/ # 30 universal commands
│ ├── protocols/ # 26 on-demand reference files (with @INDEX lazy-load) + index
│ ├── db/ # Institutional memory layer
│ │ ├── schema.sql # SQLite schema
│ │ └── queries/ # Named query templates
│ ├── scripts/ # Agent query helpers (blast.py — code-graph blast radius)
│ └── hooks/ # 23 automation hooks + lib-prompt.sh shared helpers + 4 Python modules
│
├── extensions/ # Opt-in per project
│ ├── blockchain/ # Ethereum, Solana, Cosmos, Substrate
│ ├── cortex-bridge/ # Self-hosted Cortex sync bridge (Rust/axum)
│ └── wizard-ux/ # Wizard flow design for TUI/GUI/Web/CLI
│
├── cli/ # Rust binary (omg) — recommended installer
│ ├── src/ # 11 modules (~3200 lines)
│ ├── Cargo.toml
│ └── install.sh # curl-pipe-bash installer
│
└── scripts/
├── setup.sh # Legacy shell installer
├── db-init.sh # Initialize/migrate SQLite
└── build-protocol-index.sh # Regenerate @INDEX blocks after protocol edits
Every target project gets .omega/memory.db — a persistent knowledge base that survives context compression and session boundaries:
| Table | Purpose |
|---|---|
workflow_runs |
Pipeline execution traces |
changes |
What files were changed and why |
decisions |
Design decisions with rationale + rejected alternatives |
failed_approaches |
What was tried and why it failed |
bugs |
Symptoms, root cause, fix, affected files |
hotspots |
Files that keep breaking (risk levels, touch counts) |
findings |
Reviewer/QA findings with status tracking |
dependencies |
Component relationships |
requirements |
Requirement lifecycle (defined -> tested -> verified) |
patterns |
Successful patterns to reuse |
outcomes |
Self-learning Tier 1: raw self-scored results per action |
lessons |
Self-learning Tier 2: distilled domain-specific patterns |
behavioral_learnings |
Cross-domain meta-cognitive rules (injected at session start) |
incidents |
Structured bug tracking with contributor-prefixed INC-{PREFIX}-NNN ticket numbers |
incident_entries |
Chronological log of attempts/discoveries per incident |
decay_log |
Memory evolution audit trail |
user_profile |
Per-project identity (name, experience level, communication style) |
onboarding_state |
Tracks onboarding flow progress and resumability |
shared_imports |
Tracks imported shared knowledge entries (deduplication) |
cortex_security_log |
Security audit trail for Cortex operations |
cortex_sync_state |
Middleware sync tracking for adapter backends |
tips_shown |
Tracks which contextual tips have been shown (deduplication) |
artifacts |
Workflow artifact tracking (files produced by pipeline runs) |
invariants |
INV-{DOMAIN}-NNN records extracted from Level 2+ incidents |
regression_tests |
Tests linked to invariants for regression prevention |
monitoring_signals |
Monitoring signals linked to Level 3 invariants |
The schema also includes 16 convenience views (e.g., v_file_briefing, v_incident_timeline, v_regression_map, v_behavioral_briefing) and 11 migration scripts for incremental schema evolution.
Agent protocol: Before work -> query DB (briefing). During work -> log incrementally. After work -> close-out (verify completeness, distill lessons, extract behavioral learnings, track bugs as incidents). The briefing hook injects an OMEGA Identity block and behavioral learnings at session start.
Alongside the memory DB, every project gets a code knowledge graph — a tree-sitter AST map of the codebase built by graphify (36+ languages, zero LLM cost). Where memory.db holds decisions and history, the graph holds structure: who calls what, what depends on what, where the coupling hotspots ("god nodes") are.
It is the answer to any dependency, blast-radius, caller/callee, or architecture question — queried before grep by every briefing-layer agent (analyst, architect, developer, reviewer, security-auditor, the investigators, and more) per Global Rule #28. Typed, deduplicated dependents come back ~12× cheaper than grep+read (50–120× vs reading whole files).
- Fully automated lifecycle —
setup.shprovisions graphify (into a managed~/.graphify-venv), keeps it within a verified compatibility range (pinned, not unbounded "latest" — graphify is0.xwith no schema-stability guarantee) on every deploy, builds the graph, and installs a post-commit auto-refresh hook. No human ever runs a build; it self-refreshes on every commit. A graphify installed outside the managed venv is treated as user-managed and left untouched. - Three query verbs —
blast.py(reverse dependents),graphify explain(directed neighborhood),graphify path(causal chain between two symbols). - Fails safe — if graphify can't be provisioned, agents transparently fall back to grep. The graph is an accelerant, not a dependency.
See .claude/protocols/graph-briefing.md for the full protocol.
Agents learn at three levels, each injected at different times:
- 🧬 Behavioral Learnings (session start): Cross-domain meta-cognitive rules about HOW Claude should think — e.g., "Always verify technical claims with evidence." Extracted from user corrections, incident resolutions, and self-reflection. These make Claude progressively smarter across sessions.
- 📚 Lessons (agent briefing, on-demand): Domain-specific patterns — e.g., "Use Option for concurrent access in Rust." Distilled from 3+ similar outcomes. Queried per scope when agents brief themselves.
- 📊 Outcomes (internal): Raw self-scored actions (+1/-1). Feed lesson distillation but never shown at session start.
Bugs are tracked as incidents with contributor-prefixed IDs (INC-AJL-001, INC-BS-002, ...). Each contributor has their own independent sequence, preventing collisions in team collaboration. Each incident has a structured timeline of attempts, discoveries, clues, hypotheses, and resolution. When resolved, agents extract behavioral learnings if the incident revealed a flaw in Claude's reasoning. Open incidents appear in the session briefing as a summary; full details are queried on-demand.
Shell hooks enforce the memory protocol automatically (key hooks below — full inventory in docs/DOCS.md §4), supported by four Python modules:
| Hook | Event | Purpose |
|---|---|---|
briefing.sh |
UserPromptSubmit | Auto-injects behavioral learnings + open incidents (once per session); suggests arming the gauntlet when a Level-3 incident exists in an unarmed project |
learning-detector.sh |
UserPromptSubmit | Detects corrections, tracks as pending, nags until saved (every message) |
doctor-init.sh |
UserPromptSubmit | Auto-activates pipeline gate when /omega-doctor or /omega-redesign is detected |
learning-gate.sh |
PreToolUse (Bash) | Blocks git commit until pending corrections are saved as behavioral learnings |
debrief-gate.sh |
PreToolUse (Bash) | Blocks git commit if no outcomes are logged |
pipeline-gate.sh |
PreToolUse (Read/Write/Edit/Grep/Glob/Bash) | Unified gate — enforces pipeline order: prompt refinement, INC ticket, parallel investigation, test-before-fix, evidence pivot, test coverage, output contract, and incremental logging |
evidence-pivot.sh |
UserPromptSubmit | Arms the evidence pivot when a shipped fix didn't change the symptom — blocks the next fix until runtime evidence from the failing environment is captured |
gauntlet-gate.sh |
PreToolUse (Bash) | System-impact gate (opt-in via .omega/gauntlet.conf): blocks workflow close in system-dynamics domains without a passing gauntlet run, blocks hand-written gauntlet results, requires Failure-Modes: commit attestation |
debrief-nudge.sh |
PostToolUse | Periodic reminder to log incrementally |
trace-gate.sh |
PreToolUse (Write/Edit) | Blocks source edits when milestone REQ-* IDs lack test references; blocks test files without OUTPUT CONTRACT checklist |
ssf-init.sh |
UserPromptSubmit | Auto-activates SSF enforcement when /omega-ssf is detected |
ssf-inject.sh |
PreToolUse | Injects SSF compliance reminder during active SSF evaluation |
session-close.sh |
Notification | Promotes hotspot risk levels at session end |
| Python Module | Purpose |
|---|---|
cortex_adapter.py |
Cortex backend adapter abstraction (pluggable sync backends) |
cortex_middleware.py |
Cortex middleware: intercepts memory.db writes and syncs to shared store |
cortex_sanitize.py |
Cortex security: input sanitization, Ed25519 verification, path validation |
git_jsonl_adapter.py |
Default Cortex adapter: git-based JSONL sync backend |
| Agent | Role |
|---|---|
| discovery | Pre-pipeline conversation: explores, challenges, clarifies raw ideas |
| idea-perspective | Parallel idea evaluator: one of 3 independent instances (Explorer, Skeptic, Analogist) examining raw ideas |
| analyst | Business analysis: requirements, acceptance criteria, MoSCoW, traceability. Security Requirements Gate: trust boundary detection, mandatory REQ-*-SEC generation. Architecture comprehension for modifications |
| skeptic-analyst | Independent requirements skeptic: produces ONLY contradicting interpretations of the same source material to break anchor detection bias |
| architect | Adversarial architecture design: confidence-quantified decisions (conf(float, basis)), constraint tables from past failures, Design Space Gate. Security Analysis Gate: dedicated adversarial pass for trust boundaries |
| architecture-perspective | Parallel architecture reasoner: one of 3 independent instances (Explorer, Skeptic, Analogist) approaching design from different cognitive modes |
| test-writer | TDD red phase: writes failing tests before code, priority-driven. Output Contract: mandatory enumeration of all observable outputs before writing any assertion. Adversarial Input Testing: mandatory injection payload tests for external data |
| developer | Implementation: module by module, minimum code to pass tests. Reads architecture context before coding |
| qa | End-to-end validation, acceptance criteria, exploratory testing. Independent security probing regardless of architect docs |
| reviewer | Audit: bugs, security, performance, tech debt, specs/docs drift. Injection Pattern Scanner: active grep, automatic blocker (read-only) |
| feature-evaluator | GO/NO-GO gate: 7-dimension scoring before committing resources |
| dimension-scorer | Parallel feature dimension scorer: one of 3 independent instances, each scoring a subset of evaluation dimensions |
| codebase-expert | Deep comprehension: 6-layer progressive exploration + shallow functionality inventory mode (read-only) |
| investigator | Parallel diagnostic investigator: 5 independent instances examine bugs from different evidence layers (logs, code, state, constraints, wildcard). Context isolation prevents shared-context bias |
| diagnosis-synthesizer | Reads all investigator reports, detects convergence (3+/5 agreement = high confidence) and contradictions (disagreement = investigate further), produces unified diagnosis |
| design-evaluator | Parallel architecture evaluator: 5 independent instances examine redesign from different analytical lenses (subtraction, restructure, patterns, failures, radical simplification). Context isolation prevents shared-context bias |
| design-synthesizer | Reads all design evaluator reports, detects convergence across proposals, applies failure constraints as filters, produces unified redesign proposal |
| fundamentals-checker | On-demand fundamentals verification (resource, dimensional audit, Occam's ordering, invariant mapping). Parses target hosts from the description and runs the checklist per host via SSH; falls back to localhost if no host is named (Sonnet) |
| evidence-assembler | Evidence collection: constraint tables, incident timelines, shared incidents from memory.db (Sonnet) |
| log-specialist | Strategic log instrumentation: adds structured, contextual logging at error boundaries, state transitions, external calls, data transformations, and branch decisions |
| cargo-test-expert | Adversarial Rust testing: writes cargo tests that expose bugs, trigger panics, reproduce failures, and stress edge cases |
| error-design-auditor | Audits error handling for agentic consumption quality: structured, explicit, stage-aware errors that AI agents can parse and self-correct |
| git-expert | Complex git operations: merges, rebases, cherry-picks, conflict resolution, history rewriting, bisect, reflog recovery |
| branch-strategist | Branch comparison: classifies change quality (root-cause vs patches), recommends merge direction |
| content-creator | Turns your project + your human intro into a truthful, publish-ready Markdown post: reads the actual code so every technical claim is verified (VERIFIED / USER-ATTESTED / SPEC-ONLY claim ledger). Local draft only — never publishes |
| omega-router | Intelligent dispatch: classifies requests, finds/creates specialists, assembles pipelines |
| role-creator | Meta-agent: designs new agent role definitions |
| curator | Knowledge curation: evaluates memory.db entries for team sharing, exports to .omega/shared/ |
| security-prober | Independent security probe: lightweight single-agent probe for ad-hoc use |
| security-auditor | Parallel security auditor: one of 5 independent attack perspectives (injection, auth, crypto, logic, config) for /omega-audit |
| security-synthesizer | Reads all 5 security auditor reports, deduplicates findings, assigns severity (P0-P3), produces unified security report |
| role-auditor | Meta-agent: adversarial audit of role definitions (read-only) |
| audit-reviser | Independent audit revision: re-reads completed audit reports from scratch, flags unsupported conclusions and miscalibrated severity |
| report-conclusion | Lightweight conclusion extractor: reads ONE investigation report and produces a standalone conclusion to break sequential anchoring bias |
| Command | Description |
|---|---|
/omega-setup [--target=PATH] |
Guided installation wizard: build binary, select target project, choose installation type, deploy, verify |
/omega-new "idea" |
Full pipeline for greenfield projects |
/omega-new-feature "feat" [--scope] |
Full pipeline for existing projects (with feature gate) |
/omega-improve "desc" [--scope] |
Refactor/optimize (analyst comprehends architecture, no separate architect step) |
/omega-redesign "problem" [--scope] [--fix] |
Architecture redesign (parallel design evaluators + synthesizer); --fix for auto-implementation |
/omega-doctor "bug" [--scope] [--investigate] [--fast] |
Unified bug fix — auto-triages: fast path (simple) or deep path (architect + 5 parallel investigators + synthesizer). --investigate for diagnosis-only. --fast for simple, localized bugs (skips prompt refinement and parallel investigation) |
/omega-fundamentals-check "desc" |
On-demand resource/capacity/environment check. Parses target hosts from the description and runs the checklist per host via SSH; falls back to localhost if no host is named. Not auto-invoked by any pipeline |
/omega-log "desc" --scope="area" |
Add strategic log instrumentation for observability and root cause analysis |
/omega-audit [--fix] [--scope] |
Security audit with 5 parallel attack perspectives (injection, auth, crypto, logic, config) + synthesizer; --fix for auto-fix pipeline |
/omega-error-audit [--fix] [--scope] |
Audit error handling for agentic consumption quality; --fix for auto-implementation |
/omega-sync [--scope] |
Generate, update, or sync specs/docs with codebase |
/omega-understand [--scope] [--depth=shallow] |
Deep codebase comprehension (--depth=shallow for flat functionality inventory) |
/omega-resume [--from] |
Resume stopped workflow |
/omega-consult "request" [--critical] |
Intelligent specialist routing: find/create domain experts |
/omega-create-role "desc" |
Design a new agent role |
/omega-audit-role "path" [--scope] |
Adversarial audit of role definitions |
/omega-cargo "desc" [--scope] |
Adversarial Rust testing: expose bugs, trigger panics, stress edge cases |
/omega-git "operation" |
Complex git operations: merges, rebases, cherry-picks, conflict resolution, history rewriting |
/omega-probe-model [--model] [--compare] |
Probe model reasoning biases and failure modes |
/omega-learn "rule" [--list] [--remove] |
Manually teach OMEGA a behavioral learning |
/omega-onboard [--update] |
Set up your OMEGA identity profile |
/omega-share [--force] [--dry-run] [--scope] |
Export curated knowledge to shared team store |
/omega-team-status |
Dashboard: shared knowledge stats, contributions, incidents, hotspots |
/omega-cortex-config [--show] [--reset] |
Configure Cortex sync backend (git-jsonl, cloudflare-d1, turso, self-hosted) |
/omega-ssf [text|path] |
Evaluate a proposal or response for SSF (Stupid Simple First) compliance |
/omega-branch-compare "branchA" "branchB" |
Compare branches by change quality, recommend merge direction |
/omega-post "intro" [--format=social|dev-log|announcement] |
Write an engaging, truthful post about your own project from your human intro + the actual code; local Markdown draft in posts/ (does not publish) |
/omega-collaborate [--status] |
Guided team collaboration setup: prerequisites, partner onboarding, knowledge sharing |
/omega-review-imports |
Review pending shared knowledge before import (when review mode is enabled) |
OMEGA ships with 39 core agents that cover software development. But real projects need expertise in hundreds of domains — marketing, compliance, database optimization, DevOps, security hardening, content writing, etc.
/omega-consult is the catch-all for domain expertise that doesn't fit the structured development commands:
/omega-consult "help me design a HIPAA-compliant data flow"
/omega-consult "optimize my PostgreSQL queries for 10M rows"
/omega-consult "write SEO-optimized copy for my landing page"
/omega-consult --critical "should we migrate to microservices?"The omega-router agent classifies every request into one of three tiers:
| Tier | When | What happens |
|---|---|---|
| 1 — Simple | General knowledge, quick answer | Handled directly, no specialist |
| 2 — Specialist | Domain expertise needed | Finds existing specialist OR creates one via role-creator, then delegates |
| 3 — Critical | High-stakes, needs adversarial review | Assembles a multi-agent pipeline (e.g., discovery → specialist → reviewer) |
The first time you ask about a domain, the router creates a specialist agent (saved to .claude/agents/). The second time, that specialist already exists — routing is instant.
Session 1: "help with HIPAA compliance" → creates hipaa-specialist.md → analyzes your code
Session 5: "check this new endpoint for HIPAA" → hipaa-specialist exists → routes directly
Over time, your project accumulates the exact specialists it needs. A fintech project might grow hipaa-specialist.md, dba-optimizer.md, tokenomics-designer.md. A SaaS project might grow seo-specialist.md, pricing-strategist.md.
| Your task | Use this, not /omega-consult |
|---|---|
| Fix any bug (simple or complex) | /omega-doctor (auto-triages) |
| Fix a simple, localized bug | /omega-doctor --fast (lightweight pipeline) |
| Investigation only (no auto-fix) | /omega-doctor --investigate |
| Add a feature | /omega-new-feature |
| Refactor code | /omega-improve |
| Architecture is wrong/tangled | /omega-redesign |
| Add logging/observability | /omega-log |
| Analyze logs / build timeline | /omega-forensics (blockchain extension) |
| Security audit | /omega-audit |
| Domain expertise outside development | /omega-consult |
The visual maps below illustrate just two of OMEGA's 31 core commands. Every command follows the same multi-agent, memory-backed pipeline — these are shown in detail so you can see what that actually looks like end to end.
The user says "fix this." OMEGA decides how deep to dig. /omega-doctor is the single entry point for ALL bugs — from typos to heisenbugs. The Analyst triages automatically: simple bugs get the fast path; complex bugs trigger the full architect + parallel investigation pipeline. No user decision needed.
/omega-doctor "login page shows 500 error" # system triages
/omega-doctor "sync fails intermittently" --scope="networking" # scoped
/omega-doctor "backfill skips state updates" --fast # simple bug, no overhead
/omega-doctor --incident=INC-AJL-003 # resume prior
┌─ YOUR CLAUDE CODE SESSION ────────────────────────────────────────────────────────┐
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ /omega-doctor "the bug" │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 0: INCIDENT TRACKING Hook-enforced gate │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Create INC-{PREFIX}-NNN ticket ◄──── or resume --incident=INC-... │ │ │
│ │ │ Write ticket ID to .claude/hooks/.inc_id │ │ │
│ │ │ ⚠ Source code reads BLOCKED until this gate passes │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 1: ANALYST + TRIAGE │ │
│ │ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ │ │
│ │ │ │
│ │ Fundamentals quick-check (build? tests? dependencies?) │ │
│ │ Read scoped code, comprehend architecture │ │
│ │ Identify probable cause (if possible) │ │
│ │ Impact analysis │ │
│ │ │ │
│ │ ━━━ TRIAGE VERDICT ━━━ │ │
│ │ Path: FAST or DEEP ◄──── system decides, not the user │ │
│ │ ━━━━━━━━━━━━━━━━━━━━━━ │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────┴───────────┐ │
│ │ TRIAGE DECISION │ │
│ └───────────┬───────────┘ │
│ FAST / \ DEEP │
│ / \ │
│ ┌──────────┘ └──────────────────────────────┐ │
│ │ │ │
│ │ ▼ │
│ │ ┌────────────────────────────────────────────────────────┐ │
│ │ │ DEEP PATH (auto-triggered, no user decision) │ │
│ │ │ │ │
│ │ │ Step 2a: Evidence Assembler (subagent) │ │
│ │ │ Constraint table, incident history, shared matches │ │
│ │ │ │ │ │
│ │ │ ▼ │ │
│ │ │ Step 2b: Architect + Log Sufficiency (PARALLEL) │ │
│ │ │ Architect: module map, data flows, design intent │ │
│ │ │ Log Specialist: sufficiency verdict │ │
│ │ │ (SUFFICIENT / CRITICAL-GAP — anti-hedging) │ │
│ │ │ │ │ │
│ │ │ ▼ │ │
│ │ │ Step 2c: 5 Parallel Investigators (Opus) │ │
│ │ │ Each in own isolated context — no shared bias │ │
│ │ │ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ │
│ │ │ │ Log │ │ Code │ │State │ │Constr│ │Wild- │ │ │
│ │ │ │Foren.│ │Logic │ │Recon.│ │Elim. │ │card │ │ │
│ │ │ └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘ │ │
│ │ │ └────────┴────────┴────────┴────────┘ │ │
│ │ │ │ │ │
│ │ │ ▼ │ │
│ │ │ Step 2d: Diagnosis Synthesizer (Opus) │ │
│ │ │ Convergence detection (3+/5 = high confidence) │ │
│ │ │ Contradiction detection (disagreement = gold) │ │
│ │ │ conf(probability, basis) on every hypothesis │ │
│ │ │ │ │
│ │ │ Output: diagnosis-report.md │ │
│ │ └────────────────────────┬───────────────────────────────┘ │
│ │ │ │
│ └───────────────┬───────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 3: MILESTONE LOOP (same destination for both paths) │ │
│ │ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ │ │
│ │ │ │
│ │ Test Writer → Developer → QA → Reviewer → Security Prober │ │
│ │ (each = sub-agent in own context) │ │
│ │ │ │
│ │ ⚠ pipeline-gate: Developer BLOCKED until Test Writer's test exists │ │
│ │ 🔒 Security Prober: CRITICAL/HIGH findings block commit │ │
│ │ 📋 Output Contract: ALL outputs enumerated before any assertion │ │
│ │ DEEP path: Developer reads diagnosis-report.md before coding │ │
│ │ FAST path: Developer reads analyst's analysis before coding │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────────────┘
| Standard AI Debugging | OMEGA Unified Bugfix |
|---|---|
| User must decide: "simple bug or hard bug?" | System auto-triages — user just says "fix this" |
| User's prompt anchors the entire investigation | Prompt Refinement: strips investigation-anchoring language, preserves domain context, de-biases before any agent runs |
| Read error → guess fix → try it → repeat | FAST: analyst finds cause → fix. DEEP: architect blueprint → 5 parallel investigators (each in isolated context) → synthesizer → fix once |
| Anchors on the first file it reads | Architect provides system blueprint before investigation; 5 independent investigators in separate context windows prevent shared-context bias |
| Finds a trigger event and stops | Trigger ≠ Root Cause: mandatory distinction — traces triggered operation's code path to find WHY it produces wrong state |
| Lists "downstream symptoms" without investigating | Derivation Test: every item in the causal chain must be derived from the root cause (show work) or investigated as a second root cause |
| Treats each attempt independently | Every failed fix becomes a constraint that narrows the search |
| "Works on my machine" | Fundamentals check first: does it build? Do tests pass? |
| Fix test checks one output, misses regression | Output Contract: enumerate ALL outputs × ALL paths before writing assertions |
| No memory across sessions | Incident timeline persists — resume with --incident=INC-XXX-NNN |
| Confidence is implicit | Every hypothesis carries conf(probability, basis) — overconfidence triggers alerts |
| Adds code to fix bugs (retries, checks, layers) | Subtraction Gate: asks "can we fix by removing?" before any additive fix |
| Keeps trying code fixes on architecture problems | Three feasibility gates auto-escalate to /omega-redesign when the problem is structural |
┌─ YOUR CLAUDE CODE SESSION ──────────────────────────────────────┐
│ │
│ /omega-doctor "something is broken" │
│ │ │
│ Analyst investigates │
│ + issues TRIAGE VERDICT │
│ │ │
│ FAST / \ DEEP │
│ / \ │
│ Analyst found it Bug is complex, multi-component, │
│ Fix directly or previous fix failed │
│ \ / │
│ \ / Evidence + Escalation Gate │
│ \ / Architect + Log Sufficiency │
│ \ / 5 Parallel Investigators │
│ \ / + Synthesizer + Feasibility │
│ ▼ ▼ │
│ Milestone Loop │
│ (Test → Dev → QA → Review → Security) │
│ │
└─────────────────────────────────────────────────────────────────┘
/omega-doctor --investigate is the investigation-only mode — for when you want a diagnosis report without auto-fixing (security investigations, learning, post-mortems).
Architectural escalation: Three independent mechanisms prevent endless code fixes on structural problems: (1) Hydra detection — 3+ distinct root causes auto-escalates. (2) Feasibility gates — architect and diagnosis synthesizer independently assess if the bug is code-fixable; ARCHITECTURAL/NO verdicts auto-escalate. (3) Cross-incident aggregation — 5+ total failed attempts (across all modules/milestones) auto-escalates. All escalate to /omega-redesign, which uses its own parallel evaluation pipeline (5 design evaluators + synthesizer).
The user's raw prompt is the most powerful steering force in any pipeline. "Research deeply in the logs what caused this" anchors every downstream agent to log evidence — even agents with explicit mandates to check code will deprioritize it because the user's intent feels clear.
Prompt Refinement (Global Rule #22) runs before any agent work begins on every major command. It:
━━━ PROMPT REFINEMENT ━━━
Original: "N1, N7, N11 lost integrity chain. Research very deeply in the logs what caused this."
Anchors detected:
- "Research very deeply in the logs" → STRIP — layer anchor constrains
investigation to log evidence; root cause may be in code logic
Domain context preserved:
- N1, N7, N11 affected (3 specific nodes)
- Integrity chain lost (symptom)
Refined: "N1, N7, N11 lost integrity chain. Investigate what caused the integrity loss.
Follow evidence wherever it leads — logs, code logic, state reconstruction,
configuration, architecture."
━━━━━━━━━━━━━━━━━━━━━━━━━
Detects three anchor types: layer (WHERE to look), depth (HOW DEEP), cause (WHAT the answer is). Preserves all domain context. Reframes assumed root causes as hypotheses. Appends command-specific scope-broadening directives. Transparent and overridable — the user sees exactly what changed and can override.
Combined with the Trigger ≠ Root Cause rule (don't stop at what event happened — trace what the operation does to state) and the Derivation Test (every item in the causal chain must be derivable from the root cause or investigated), these three rules form the diagnostic investigation stack:
1. Prompt Refinement → don't let the question constrain the answer
2. Trigger ≠ Root Cause → don't stop at what happened
3. Derivation Test → if you can't derive it, investigate it
Origin: A partner using plain Claude Code (no OMEGA) found a root cause that OMEGA missed across 4 diagnostic runs. The difference: the partner's prompt was unconstrained. OMEGA's prompt said "research in the logs" — anchoring the entire investigation to the wrong evidence layer. These three rules were designed to close that gap.
/omega-redesign is for structural problems — not bugs, not missing features, but architecture that's tangled, doesn't scale, or has module boundaries in the wrong place. It puts the Architect at the center with subtraction as the default posture: what can we remove, simplify, or collapse before adding anything new?
/omega-redesign "auth middleware is a tangled mess" --scope="auth"
/omega-redesign "module boundaries are wrong in the pipeline"
/omega-redesign "this design doesn't scale" --fix # propose + auto-implement
┌─ YOUR CLAUDE CODE SESSION ────────────────────────────────────────────────────────┐
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ /omega-redesign "the problem" [--fix] │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 0: ANALYST (problem-scoping) Sub-agent: own context window │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Read specs + code for affected area only │ │ │
│ │ │ │ │ │
│ │ │ Map ────────── module boundaries, data flows, dependencies │ │ │
│ │ │ Identify ───── tangles, coupling, misplaced abstractions │ │ │
│ │ │ Define ─────── acceptance criteria for "better" │ │ │
│ │ │ Prioritize ─── Must / Should / Could / Won't (MoSCoW) │ │ │
│ │ │ │ │ │
│ │ │ Output: docs/redesigns/[domain]-redesign-analysis.md │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 1: PARALLEL DESIGN EVALUATION │ │
│ │ │ │
│ │ Default posture: SUBTRACTION — what can we remove before adding? │ │
│ │ │ │
│ │ Step 1.2: 5 Parallel Design Evaluators (each in isolated context) │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌──────────┐│ │
│ │ │Subtraction-│ │Restructur- │ │ Pattern │ │ Failure │ │ Radical ││ │
│ │ │ist │ │er │ │ Matcher │ │ Analyst │ │Simplifier││ │
│ │ │ │ │ │ │ │ │ │ │ ││ │
│ │ │ What can │ │ Where are │ │ What known │ │ What │ │ Minimum ││ │
│ │ │ be REMOVED │ │ boundaries │ │ pattern │ │ BREAKS and │ │ viable ││ │
│ │ │ to solve │ │ wrong? │ │ solves │ │ what must │ │ arch if ││ │
│ │ │ this? │ │ │ │ this? │ │ NOT break? │ │ built ││ │
│ │ │ │ │ │ │ │ │ │ │ today? ││ │
│ │ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ └────┬─────┘│ │
│ │ └──────────────┴──────────────┴──────────────┴──────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Step 1.4: Design Synthesizer (reads all 5 reports) │ │
│ │ ▸ Convergence detection (which evaluators agreed, on what) │ │
│ │ ▸ Failure constraints applied as filters to all proposals │ │
│ │ ▸ Current architecture map → Proposed architecture map │ │
│ │ ▸ Migration path (current → proposed without breaking) │ │
│ │ ▸ What gets DELETED (prominent, not hidden) │ │
│ │ ▸ Confidence-quantified decisions: conf(float, basis) │ │
│ │ ▸ Milestones (if 4+ modules affected) │ │
│ │ │ │
│ │ Output: specs/[domain]-architecture.md │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ╔══════════════════════════════════════════════════════════════════════════════╗ │
│ ║ Back in ORCHESTRATOR context (user interaction) ║ │
│ ╚══════════════════════════════════════════════════════════════════════════════╝ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 2: USER GATE (mandatory) │ │
│ │ │ │
│ │ ┌─────────────────────────────────┐ ┌─────────────────────────────┐ │ │
│ │ │ Without --fix (default) │ │ With --fix │ │ │
│ │ │ │ │ │ │ │
│ │ │ STOP here. Proposal saved. │ │ Present the saved proposal │ │ │
│ │ │ Artifacts in docs/redesigns/ │ │ for approval: │ │ │
│ │ │ and specs/. │ │ │ │ │
│ │ │ │ │ "The proposal: [summary]" │ │ │
│ │ │ What would you like to do? │ │ │ │ │
│ │ │ ▸ Implement: /omega-redesign │ │ Do you approve? │ │ │
│ │ │ --fix --scope=... │ │ ✓ Approve → Step 3 │ │ │
│ │ │ ▸ Deploy existing fixes first │ │ ~ Modify → adjust, redo │ │ │
│ │ │ ▸ Discuss specific findings │ │ ↻ Iterate → back Step 1 │ │ │
│ │ │ │ │ ✗ Reject → STOP │ │ │
│ │ └─────────────────────────────────┘ └──────────────┬──────────────┘ │ │
│ └──────────────────────────────────────────────────────────┬──────────────────-┘ │
│ │ │
│ ┌──────────────────────────────┘ │
│ │ User approved │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 3: MILESTONE EXTRACTION │ │
│ │ │ │
│ │ Parse architecture for milestones (M1, M2, M3...) │ │
│ │ Small redesigns = single milestone │ │
│ │ Output: docs/.workflow/milestone-progress.md │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEPS 4-9: PER-MILESTONE LOOP │ │
│ │ │ │
│ │ +--- For each milestone (auto-continues) ───────────────────────────────+ │ │
│ │ │ Each agent = sub-agent in its own context window │ │ │
│ │ │ Agents read artifacts from disk, not from each other's context │ │ │
│ │ │ │ │ │
│ │ │ Test Writer ──► regression tests + new structure tests (TDD) │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ Developer ───► restructure one module at a time │ │ │
│ │ │ │ follow migration path — no freelancing │ │ │
│ │ │ ▼ │ │ │
│ │ │ Compiler ────► build + lint + test validation gate │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ QA ──────────► behavior preserved? structural improvements met? │ │ │
│ │ │ │ (max 3 iterations with Developer) │ │ │
│ │ │ ▼ │ │ │
│ │ │ Reviewer ────► architecture improved? migration path followed? │ │ │
│ │ │ │ (max 2 iterations with Developer) │ │ │
│ │ │ ▼ │ │ │
│ │ │ Security ───► probe changed code for vulnerabilities │ │ │
│ │ │ Prober CRITICAL/HIGH block commit (max 2 iterations) │ │ │
│ │ │ ▼ │ │ │
│ │ │ Commit + Push ► refactor: complete [milestone] (M[N]) │ │ │
│ │ │ │ │ │
│ │ +────────────────────────────────────────────────────────────────────────+ │ │
│ └──────────────────────────────┬───────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STEP 10: FINAL VERSIONING │ │
│ │ │ │
│ │ ✓ Full test suite (cross-milestone integration) │ │
│ │ ✓ Version tag + git push --tags │ │
│ │ ✓ Clean up temporary workflow files │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────────────┘
| Standard AI Refactoring | OMEGA Redesign |
|---|---|
| Jumps straight to rewriting code | Analyst scopes the problem, Architect reasons adversarially before any code changes |
| Adds layers and abstractions | Subtraction-first: remove, collapse, simplify before restructuring |
| One monolithic change | Milestone-based migration: incremental, testable, reversible |
| No alternatives considered | 6 alternatives evaluated per decision through Explorer/Skeptic/Analogist loop |
| "Trust me, it's better" | Confidence-quantified decisions with conf(float, basis) tags |
| Tests after the rewrite | TDD: regression tests lock behavior BEFORE restructuring begins |
| Docs rot immediately | Specs and docs updated as part of the pipeline, not as an afterthought |
┌─ YOUR CLAUDE CODE SESSION ───────────────────────────┐
│ │
│ Is the code working correctly? │
│ │ │
│ yes / \ no │
│ / \ │
│ Structure OK? /omega-doctor │
│ │ (--investigate for │
│ │ diagnosis only) │
│ yes / \ no │
│ / \ │
│ /omega-improve /omega-redesign │
│ (optimize, (module boundaries wrong, │
│ clean up) architecture tangled, │
│ design doesn't scale) │
│ │
└──────────────────────────────────────────────────────┘
- blockchain-network — P2P networking, node operations, RPC infrastructure, monitoring
- blockchain-debug — Diagnoses active connectivity problems using 7-phase methodology
- stress-tester — Black-box adversarial testing of blockchain CLI/RPC endpoints
- p2p-network-engineer — P2P/libp2p protocol specialist: reviews, designs, and audits peer-to-peer networking code
- frontend-ux-expert — Frontend UX audit and design for blockchain interfaces (bridge UI, swap, DeFi dashboards)
- log-forensics — Log forensics and timeline reconstruction for blockchain incidents
- fork-engineer — Fork root cause analysis: chain splits, reorgs, consensus failures, divergent chain states
- blockchain-investigator — Parallel fork investigation agent (4 evidence layers: logs, chain state, network topology, consensus/validator)
- blockchain-synthesis — Synthesizes parallel investigator reports into convergence-based diagnosis with fork classification
- blockchain-domain-investigator — Parallel domain-lens investigator (4 domains: fork, connectivity, parameters, code). Examines ALL evidence through one domain's perspective
- blockchain-domain-synthesizer — Determines which domain the problem belongs to as OUTPUT (not input). Detects cross-domain causation chains
- defi-economist — DeFi economic layer specialist: tokenomics, AMM/lending economics, stablecoin/yield sustainability, oracle/governance capture cost, MEV, mechanism design. Advisory-only; with
--fixauto-implements code-fixable findings
Commands: /omega-blockchain-network, /omega-blockchain-debug, /omega-stress-test, /omega-p2p, /omega-ux-audit, /omega-forensics, /omega-fork, /omega-swarm, /omega-defi-economist, /omega-defi-redesign
- wizard-ux — Designs step-by-step installation, setup, and onboarding flows for TUI/GUI/Web/CLI
Command: /omega-wizard-ux
- Self-hosted sync bridge for OMEGA Cortex collective intelligence
- Rust/axum HTTP server with TLS (rustls), HMAC-SHA256 authentication, SQLite storage
- Docker deployment via included Dockerfile and docker-compose.yml
- 🔐 Security chain enforcement: When features involve external data, 5 independent security gates activate: Analyst (trust boundary detection + REQ-*-SEC requirements), Architect (substantive security analysis or STOP), Test Writer (adversarial injection payloads), QA (independent security probing), Reviewer (injection pattern scanner — automatic blocker). No single agent failure creates a security blind spot
- ✂️ Subtraction-first fixes: Anti-overengineering gate asks "can this be solved by removing?" before any additive solution. The investigators, architect, and analyst all pass through Q0 (Subtraction Principle) — less code, fewer layers, simpler systems
- 🏗️ Architecture before modification: Every modification workflow (bugfix, improve, diagnose --fix) requires architecture comprehension before proposing or implementing changes
- 🚧 Prerequisite gates: Every agent verifies upstream output exists before proceeding
- 👀 Read-only agent boundaries: Research agents (codebase-expert, functionality-analyst) never offer to implement — they report findings and suggest appropriate commands
- 🔢 Iteration limits: QA<->Developer max 3, Reviewer<->Developer max 2, Audit fix max 5 per finding
- 🐉 Hydra detection: Bugfix auto-escalates to
/omega-redesignafter 3+ distinct root causes on the same incident (prevents symptom-chasing loops) - 🏛️ Architecture feasibility gates: Three-layer detection prevents endless code fixes on architectural problems: (1) Analyst brittleness check, (2) Architect feasibility verdict (CODE-FIXABLE/ARCHITECTURAL/UNCERTAIN), (3) Diagnosis Synthesizer feasibility verdict (YES/NO/UNCERTAIN). ARCHITECTURAL or NO auto-escalates to
/omega-redesign - 📊 Cross-incident failure aggregation: Tracks total failed attempts across an entire incident (not per-module). At 5 failures, auto-escalates to redesign — catches architectural problems that distribute symptoms across modules
- 📏 60% context budget: Agents stop at 60% context usage, save state, continue via
/omega-resume - ✅ Inter-step validation: Commands verify each agent produced output before invoking the next
- 💾 Error recovery: Failed chains save state to
docs/.workflow/chain-state.md+ memory.db - 🔁 Developer max retry: 5 attempts per test-fix cycle, then escalation
- 🌍 Language-agnostic: Adapts to Rust, TypeScript, Python, Go, Elixir, or any detected language
Codebase > .omega/memory.db > specs/ > docs/
When anything conflicts, the codebase wins. Agents flag discrepancies and update accordingly.
OMEGA is designed for use with Claude Code by Anthropic.
OMEGA Ω was created by Ivan Lozada and Antonio Lozada
two Venezuelans in exile 🇻🇪
𝕏 @isudoajl