The platform

One system of record. Six layers. Any harness.

The engineering operating system for AI-powered software delivery, as a closed loop: the Knowledge Core defines the architecture, the Ledger records intent, traceability links everything, and your own AI coding tools execute, all run from Mission Control. Every cycle sharpens the record.

Book a demo Apply for the Commercial Beta

mission control · your move

7 queued

If it isn't here, nothing needs you.

What the Knowledge Core actually builds

Before a specification is written, ModernPath parses your repositories, schemas and documentation into a structured model of the estate: systems, interfaces, dependencies, and every place implementation has drifted from contract.

Layer 01

Sources: everything you already use

Keep every tool you run: the record starts from what exists, with provenance preserved on ingestion. As the System of Record takes over, you consolidate on your schedule, not ours.

Code repositories

40+ languages parsed into structure, dependencies, and business logic

Databases

Schema extraction, relationship mapping, data flow tracing

Documents

PDF, Word, PowerPoint, Excel, Markdown, with AI extraction and enrichment

Work management

Jira issues, epics, and stories via two-way sync

Documentation

Confluence pages, specs, and designs; Google Drive documents

Integrations

GitHub, GitLab, Bitbucket, and Slack decision capture

APIs & feeds

External data, regulation, market information

Layer 02

Knowledge Core

A domain-driven model of your real system: architecture, patterns, conventions, and business rules, grounding every agent and human. Specifications are generated against the architecture you actually have; knowledge accuracy is the leading indicator of delivery success.

PatternsCapabilitiesSubsystemsDependenciesLibrariesRepository metadataTechnology stackCompliance artifactsDocumentsDesign systemPlanning sessions

Multi-stage analysis pipeline

Six-pass AI analysis across 40+ languages, three-tier documentation, and semantic indexing for natural language search.

Indexed context, lower token spend

Domains, capabilities, and patterns are indexed once and queried, not re-stuffed into every prompt from scattered documents. Higher quality, faster, cheaper.

Specification generation

Seven specialized agents produce ~20 artifacts per run, grounded in your actual patterns and file locations, not generic templates.

Chat-based interface

Plan with an AI that knows the codebase; sessions end in structured handover documents: the why and the how.

Four architect agents run in parallel on every analysis

Domain Design

Bounded contexts, aggregates, domain language alignment

Architecture Quality

Dependency direction, layer separation, coupling, interfaces

Dead Code

Unused code, orphaned modules, over-engineering

Code Health

Naming issues, unclear intent, accumulated technical debt

What compounds, and what resets

Grounded context available to your AI tools, cycle after cycle

Sessions end. Models change. Tools get replaced. The record does not: feedback from every cycle updates the Knowledge Core and the Ledger.

Layer 03

Ledger: the System of Record

The real-time System of Record for intent, rules, and decisions. Every record is versioned, immutable, and attributable. History is kept, never overwritten.

Requirements. Functional and non-functional, held as linked registers with a formal approval step
Business rules. Policies, constraints, and operating rules
ADRs & decisions. Architecture decision records and rationale
Standards & contracts. APIs, schemas, interfaces, agreements
Risks & constraints. Risks, assumptions, and dependencies

System of Record

Why a ledger, not a wiki

Documentation drifts; a system of record does not. Requirements survive refactors, rewrites, and tool changes, and the platform can prove, at any moment, what was decided, by whom, and why.

The Ledger's requirement registers: rows like REQ-AGT-024 and REQ-CMP-010 with titles, acceptance descriptions, MVP scope tags, and done, deferred, or proposed statuses. — Requirements as linked registers: real IDs, acceptance criteria, scope tags, and status. Not prose in a wiki.

Layer 04

Traceability & Mapping

Every requirement and rule in the Ledger is mapped, bidirectionally, to the artifacts that realize it: from a requirement to the code that implements it, and from any line of code back to the decision behind it.

Requirement

from the Ledger

Design

components, interfaces

Code

services, config, IaC

Tests

unit → e2e

Evidence

coverage, results, logs

⇄ Impact of a change is visible in both directions

Gaps identified automatically

Coverage reported as a single number

Layer 05

Execution Loop

The platform runs the process and asks when your input is needed. Changes are reviewed against the specification that was agreed, not generic best practice.

1Intention
2Plan
3Implement
4Verify
5Validate
6Deliver
7Learn

Feedback from every cycle updates the Knowledge Core and the Ledger

Intention
Plan
Implement
Verify
Validate
Deliver
Learn

↺ Feedback from every cycle updates the Knowledge Core and the Ledger

Task derivation

A seven-phase pipeline turns specs into epics, stories, and sprint plans, exported to JSON, Markdown, or your tracker.

Verification & delivery

Red-first tests encode the acceptance criteria before code is written. Evidence (test runs, CI results, review outcomes) attaches to the requirement chain; approval gates control progression to done.

Layer 06

Harnesses: the tools you already use

MCP tools, hooks, and APIs drive every harness with the same context, rules, and acceptance criteria. Switch tools without losing the record, and source code stays in your environment.

Claude CodeCursorCodexGitHub CopilotWhatever ships next

claude-code · connected to ModernPath via MCP

> Add per-tenant rate limiting to the billing API

⏺ modernpath.get_architecture_context("billing")
  subsystem   billing-api · Elixir/Phoenix
  pattern     RateLimiter behaviour · golden ref: gateway-api
  rule        BR-142 · tenant limits configurable per plan (Ledger, approved)
  acceptance  AC-89 · 429 + Retry-After on limit

⏺ implementing against SPEC-2041 …
  conformance PASS · drift none
  evidence → attached to REQ-311 (tests 14/14 · coverage 96%)

get_architecture_contextsearch_codebaseget_patternscheck_conformancetrace_requirementrecord_decision+ 20 more MCP tools

Two surfaces

Run it from Mission Control. Explore it in the Context Management UI.

Six layers underneath, two surfaces on top, and evidence flowing back up the stack. Everything the engineering OS holds and runs is served through these two screens.

ModernPath · The Engineering Operating System

You work from two surfaces

Mission Control

Run delivery, answer decisions

Context Management UI

Explore the record

01Sources: everything you already use

Jira · Confluence · Repos · Documents · Slack · APIs

02Knowledge Core

Defines your architecture and software behaviour

03Ledger: System of Record

Requirements, rules, and decisions, immutable

04Traceability & Mapping

Every requirement linked to code, tests, evidence

05Execution Loop

Seven steps, from intention to learning

06Harnesses: your tools

Claude CodeCursorCodexCopilot

Surface 01 · Mission Control

You stop running the board. You just make the calls.

The real-time view of the record, for everyone: progress computed from artifacts, requirements linked to development status, decisions queued to the people who own them, with what each answer unblocks. If it isn't here, nothing needs you.

Mission Control, Act view. 'Your move': a queue of decisions with median gate age, moves in queue, items pooled behind gates, and per-decision context showing what approving unblocks. — 1one screen, zero status meetings2answers un-pool blocked work3impact shown before you decide
The decision queue, live: what needs you, in what order, and what answering releases.

Mission Control, Observe view. 'Whole': release-scoped requirements by domain with done, in-review, proposed, deferred, and blocked counts, and per-domain progress bars. — Progress computed from artifacts, not standup claims: every domain, every requirement state, one screen.

Surface 02 · Context Management UI

A record that compounds, and never resets

Explore the queryable graph of requirements, decisions, code, and tests: search across everything, trace any requirement to the code that realizes it, view decision records and rationale, run impact analysis and what-if simulations.

context-management-ui · trace · REQ-CMP-011

acceptance criteria

Architecture
Patterns24
Capabilities61
Decisions118
Requirements245

requirements / REQ-CMP-011

Requirement

First-class acceptance criteria

Approved

Derives from

ADR-007 · Acceptance criteria live as rows

Decided

decided by Pasi · grounded in Knowledge Core

Implemented by

3 modules

criteria_rows.ex · criteria_view.ex · sync_upsert.ex

Verified by

7 tests

All green

unit · integration · e2e

Evidence

Run #482 · coverage 96%

attached by the loop · 2 days ago

Every link carries provenance: who, what model, which source, who approved.

A stylized view of the surface: one requirement traced to everything that realizes it, in both directions.

Harness sessions reset to zero at every boundary. The record compounds, cycle after cycle.

Beyond the two UIs: ask, act, and get answers from Slack, AI chatbots, automation tools, and custom applications through open APIs and MCP.

Governance & control

Governed at every layer

Governance is cross-cutting: it applies to every layer of the platform and every operation on the record.

Human approval gates

Material decisions pass through recorded Decision Gates: who decided, on what basis, from what source. First answer wins: a decision is never silently overwritten.

Policy enforcement & RBAC

Organizational policies enforced across workflows; role-based access integrated with the identity layer.

Audit & immutable history

The Ledger and all work events form an append-only history supporting compliance review, investigation, and audit.

System of Record integrity

Fail-safe, replay-safe sync; attributable writes only; tenant isolation enforced on every request.

Compliance & regulation

Regulations ingested as sources and traced to the requirements, tests, and code they motivate.

Inside the Knowledge Core

See your architecture the way the AI does

Patterns and conventions

Curated standards and reference implementations that define how things should be built. AI-driven pattern discovery, formal pattern contracts, conformance scoring, and drift detection with five severity levels.

Capability index

A cross-architecture capability index that answers "where is X implemented across all our systems?" Automated detection with confidence scoring and seven curation states, from detected to golden to deprecated.

Architecture Browser

Interactive exploration of analyzed systems: dependency graphs, subsystem drill-down, AI-generated three-tier documentation, health dashboards, and natural language search across the entire codebase.

Enterprise-ready

European infrastructure, defense in depth

Security

Defense in depth

ZITADEL identity layer: SSO, RBAC, multi-tenant isolation
Per-organization AES-256-GCM envelope encryption
Tenant isolation enforced at the database level
GDPR workflows: export, deletion, anonymization

Data residency

EU-only data residency

All LLM processing stays in EU data centers, enforced by the LLM Proxy. Token usage is included in the license. No separate AI bills, no provider keys.

Deployment

Run it your way

Cloud (SaaS): zero-downtime blue-green deployment
On-premise: server-side components in your environment
Hybrid: combination of both
In every model, harnesses run in your environment

See the six layers running on your codebase.

One hour with an architect. We connect a repository, walk the Knowledge Core, and run the loop end to end.

Book a demo Explore services