LeapKeep maps your system, scores deployment risk, and orchestrates domain-specific AI experts across every workflow — from code change to rollback.
Built for builders first, but readable by founders, operators, and every team responsible for what goes live.
DORRA V-1000™ · Reality InterpreterGit shows commits. Cloud tools show services. Logs show symptoms. Tickets show process. None of them show, in one place, what a change actually means before it becomes reality.
Seven layers. Five engines. One deterministic clearance authority. No single point of AI improvisation. Every answer is grounded in live context, structured memory, and explicit policy.
Formal change representation — PR diff, config delta, deployment manifest
Governed map of system reality — repos, services, APIs, owners, business functions
Routes deployment questions through domain-specific experts — right-sized model per task, policy-governed execution
Graph propagation, Monte Carlo sampling, Koopman-style surrogate dynamics¹
Layered historical recall — working, episodic, semantic, procedural
Converts graph + dynamics + memory into structured risk and cost estimates
AI Explorer — agentic workflow orchestration, human-in-the-loop deployment intelligence, multi-model reasoning
Deterministic authority layer — applies policy doctrine to produce an explicit, reviewable verdict
A governed graph of system reality. Repos, services, APIs, secrets, environments, owners, and business-critical flows — structured as nodes and typed dependency edges, not documentation.
Assembles the minimum sufficient evidence bundle for each analysis: diff context, topology, runtime state, historical analogs, policy constraints, and role-specific framing — before any interpretation begins.
Estimates likely consequence paths, destabilization routes, and dependency propagation using graph propagation and scenario analysis. Produces uncertainty bands and scenario outcomes before release.
Layered historical recall: working memory (current session), episodic memory (prior clearances, incidents, rollbacks), semantic memory (normalized system facts), procedural memory (investigation doctrine).
The deterministic authority layer. Applies explicit policy doctrine to consequence engine outputs and issues go, caution, or block — with required approvals, remediation steps, and fallback path. Not AI-improvised. Not reversible without a record.
Dorra V-1000 sits above this stack as the Reality Interpreter — querying the graph, pulling memory, invoking simulation, and explaining findings in role-aware language. It is not the math engine. It is not the final authority. LeapKeep Core issues clearance.
System Space is not a visualization. It is the live meaning map of software change — every dependency, every risk concentration, every clearance state, in one surface.
LeapKeep is not a check list. It is a governed engine that answers the questions that matter before a change becomes reality, risk, or wasted money.
Normalized diff ingested from PR metadata, git diff, deployment manifest, or config delta — not left as raw text.
Graph projection identifies directly affected nodes and probable downstream services via coupling weights and dependency traversal.
Propagation scoring and scenario simulation estimate plausible destabilization routes, impact paths, and uncertainty bands — before release.
Episodic and semantic memory retrieves prior analogs — prior clearances, failures, rollbacks, overrides, and postmortems from operational history.
Ship regret: E = P_failure × L_failure. Delay regret: E = P_delay × L_delay. Both modeled explicitly as a decision input, not a footnote.
Deterministic verdict (go / caution / block) plus evidence-bound, role-aware guidance on required approvals, remediation, and fallback path.
Connect via GitHub or upload directly. LeapKeep detects stack, config, dependencies, and environment structure automatically.
System Space assembles the live meaning map — services, databases, APIs, secrets, and deployment targets become one connected surface.
Deterministic checks run across the change surface. Blockers, drift, failure paths, and affected services surface before anything ships.
A go, caution, or block verdict with explicit reasons and required actions. Humans approve. Every decision is recorded. Clearance — not deployment — is the endpoint.
Dorra is LeapKeep's embedded synthetic intelligence layer. It assembles live system context, interprets what a software change means in that context, retrieves relevant historical outcomes, and surfaces risk in language your team can act on.
The migration adds a composite index on (user_id, created_at). This improves read performance for the 4 ORM query paths in backend-api that filter by user and time range. auth-service is unaffected — it queries by primary key only. notify-svc fetches preferences on a separate column and is not covered by this index.
Dorra assists interpretation. LeapKeep clearance remains explicit, deterministic, and reviewable. Clearance authority is never delegated to AI.
Not a summary. Not a chat response. A governed, evidence-linked, versioned output contract — with explicit risk scores, cost-of-being-wrong estimates, and role-aware explanations.
Lock contention risk is low (CONCURRENTLY flag present). 3 downstream readers. 0 downstream writers. Rollback path is clean. Query plan unverified on production replica — run EXPLAIN ANALYZE before clearing.
Expected loss if the change causes significant failure
E_ship = P_failure × L_failureExpected loss if delaying the change causes material loss
E_delay = P_delay × L_delayEvidence-weighted confidence basis for this analysis
Based on 4 evidence refs · policy v12Built for teams that carry real operational exposure. Every credential, every action, every access path is bounded, auditable, and reviewable.
All credentials are scoped to specific roles and environments. Staging credentials never touch production. Access is environment-aware by default.
Secrets are encrypted at rest and never passed to external systems without explicit approval. Zero-trust by default, approval-gated by design.
Staging, production, and preview environments are strictly separated. No credential bleed. No cross-environment access.
Every team member operates within explicit role boundaries. Access is granted, not assumed. Boundaries are reviewable and auditable.
No action proceeds without an accountable decision. Approval gates are explicit, not bypassed. Every gate is logged.
Every access, every decision, every credential use is logged with full context. Compliance-ready. Exportable. Tamper-evident.
GitHub keeps code history.
Cloud dashboards show infrastructure.
Logs show symptoms.
Tickets show process and intent.
LeapKeep turns those fragments into live meaning, operational legitimacy, and a clear decision surface — without replacing any of them.
Understand what your change means before it touches production — without reading five dashboards first.
Know what your team is shipping, what risk it carries, and why each decision was made — without needing to be in every PR.
One surface for what changed, what it touched, what was cleared, and how to recover if something goes wrong.
Operational clearance that is deterministic, reviewable, and accountable — not AI-generated confidence without basis.
Start free. Upgrade when operational clearance demands it.
The full experience for a single project. No credit card required.
For builders shipping multiple projects who want full control.
For teams that need shared visibility, audit history, and collaboration.
For organizations that demand advanced intelligence, governance, and dedicated support at scale.
For teams that want more certainty and less fragmentation before software goes live.