Moira

AI-native SDLC cockpit — a governed orchestration layer above best-of-breed agent backends.

The speed of AI. The calm of someone who has the proof.

Moira drives AI agents across the whole lifecycle — intent → requirements → design → code → QA → deploy — behind human quality gates, with a git-native, tamper-evident decision trail and model-agnostic execution. It doesn't re-implement an agent harness; it orchestrates pluggable frontier backends (Claude Code CLI, OpenAI Codex CLI, direct API) and adds the governance, traceability and cockpit layer on top.

See it: marketing one-pager · Run it: USER_GUIDE.md · Build it: CONTRIBUTING.md

_{Mission control — runs, success rate, gates awaiting you, delivery-health per func-spec.}

What Moira gives you

• Governed gates — auto / hybrid / human, with a decision-ready Inbox: every gate card shows AC-coverage + conformance, and a failed step shows the error with a one-click jump into the run.
• Git-native, tamper-evident audit — every step and decision in a hash-chained trail, sealed into both the primary store and the git mirror (verify via GET /api/runs/{id}/verify); pluggable persistence (SQLite / PostgreSQL / git mirror).
• Enforced RBAC + identity — default-deny authorization with 5 roles (admin/developer/compliance/client/viewer); JWT identity (local self-issued or OIDC); gate approvals come from the authenticated principal, not a spoofable field.
• Governance packs — versioned, repo-owned compliance bundles (deterministic checks first, LLM as labeled second opinion) that block release on policy violations; the applied policy is sealed into the audit. Samples: gdpr-basic, wcag2.2, logs-advanced.
• Durable runner — jobs/leases/workers with lease heartbeat, crash recovery, and mid-drive cancellation; embedded (desktop) or external (team, Postgres).
• End-to-end traceability — Spec ↔ Tests ↔ Tasks ↔ Code completeness, measured deterministically from the repo, plus an optional LLM conformance scorecard as a second opinion.
• Git-native task/epic backlog — Zdzira-compatible, one markdown per ticket; pm@decompose-func turns a func-spec into an epic + tasks tagged by acceptance criterion. One format, four tools.
• Deterministic quality gates — AUTO_CHECK nodes: ac_coverage (every AC has a task), test_exec (the test suite actually passes), log_hygiene (no sensitive data in logs) — escalate to a human on a gap.
• Delivery-health dashboard — per-FUNC decomposed / tested / built / conformance across the whole repo, in one view.
• Discovery (BA mode) — drive AI SDLC skills to author intents / requirements / func-specs, gated at each step — as guided presets or as a real pipeline.
• Model-agnostic — Claude Code CLI · LiteLLM (frontier + local, anti-lock-in) · Codex CLI. Desktop · web cockpit (local gate inbox at /m; cross-device access needs OIDC + a bind address — future).

What it looks like

_{A run: the execution plan + AUTO_CHECKs, the outputs it produced, and Spec ↔ Tests ↔ Tasks ↔ Code traceability.}

_{Decision-ready Inbox — AC-coverage chip, the checks feeding the gate, the diff, Approve / Reject & rework.}

_{Discovery — drive AI SDLC skills to author intents / requirements / func-specs, gated at each step.}

One repo. This is the whole Moira product: orchestrator/ (Python sidecar) + cockpit/ (React/TS) + src-tauri/ (desktop shell). The AI SDLC framework content (intents, requirements, specs, agents, skills) and any target application code live in separate repositories Moira reads/writes as a workspace.

Status — v0.2 slice · 305 unit/integration tests green (SQLite + live Postgres) · 16 ADRs implemented (see docs/adr/) · proven end-to-end on a real project (CSL Driver).

What Moira's governance guarantees — and what it does not (signing, sandboxing, auth defaults, cost limits): docs/SECURITY_BOUNDARIES.md.

Getting started

New here? Read USER_GUIDE.md — how to run Moira, load/create an AI SDLC repo, create a workspace, define agents, build pipelines, and run them.

Run the cockpit

# web cockpit (no Tauri needed) — builds frontend, serves it + API on one origin.
# Auth ON by default (MOIRA_AUTH_MODE=local): the sidecar injects a session token.
./run-cockpit.sh                 # -> http://127.0.0.1:8765

# dev mode (hot reload): two terminals (no auth unless you set MOIRA_AUTH_MODE)
python3 orchestrator/moira_api.py --repo ../ai-sdlc      # API on :8765
npm --prefix cockpit run dev                              # UI on :5173 (proxies /api)

# desktop shell (needs tauri-cli + webkit2gtk) — runs auth=off (single-user, local)
cargo tauri dev

Architecture

Tauri Shell (Rust) + React UI   ← cockpit (web or desktop) + mobile gate inbox (/m)
        │ HTTP
Python orchestration sidecar    ← own DAG engine, gates, audit (hash-chain),
        │ delegates each node to    pluggable persistence (SQLite/Postgres/git)
Execution layer (pluggable)     ← Claude Code CLI · LiteLLM (frontier/local) · (Codex CLI planned)

Key decisions (full index: docs/adr/):

• ADR-002 — own dependency-free DAG engine (LangGraph deferred)
• ADR-003 — LiteLLM for model-agnostic routing (frontier-first, local as anti-lock-in)
• ADR-004 — DEV execution is delegated, not re-implemented
• ADR-005 — pluggable run/audit persistence (primary store + export sinks)
• ADR-006/007/008 — durable runner (jobs/leases) · governance packs as enforceable controls · JWT identity + default-deny RBAC
• ADR-009…011, 013, 014 — the closed, bounded quality loop: findings feedback on reject, max_loop cap, informed retry with backoff, a human retry decision on failed nodes, failing check output into the rework prompt (opt-in)
• ADR-012, 015, 016 — backend install/login probes with fail-fast launch gating · fail-loud model identity · verified process-group termination

Repository layout

orchestrator/   Python sidecar — DAG engine, gates, audit (hash chain), pluggable
                persistence (SQLite/Postgres/git), HTTP API, backends (mock/claude_code/litellm)
cockpit/        React + TypeScript + Vite frontend (+ mobile gate inbox)
src-tauri/      Tauri v2 desktop shell (spawns the sidecar)
docs/           Marketing landing pages (PL + EN), ADRs (adr/), design notes (design/)

Architecture & design: docs/adr/ (decision records) · docs/design/ (product design notes: intents, audit-record spec, operating model, red-team verdict).

See CONTRIBUTING.md for how to run, test and build.

Source of truth

Project context, intents, requirements, specs, ADRs, standards live in a separate AI SDLC repo that you point a workspace at (e.g. --repo /path/to/ai-sdlc).

Why build-own

Hycom owns the tooling: no per-seat license fees, full control, on-prem. GitLab Duo and exAI Cloud are reference designs, not vendors we pay.

License

Apache License 2.0 — see LICENSE and NOTICE. © 2026 Hycom S.A.