# Modular workflow governance and evals for AI-DLC

> Source: <https://mirevox.dev/>
> Published: 2026-11-21 23:48:33+00:00

**Key takeaway:** Mirevox's v0.1 modules join routing, eval and egress records by request/trace id and index each repo once in a shared Context Engine instead of re-ingesting it per agent startup.

Mirevox

# A self-hosted control plane for AI-assisted delivery.

It sits on top of the models and harnesses you already use. It doesn't try to replace them.

Status: all seven modules and the control-plane hub ship runnable v0.1 slices with Docker Compose and unit tests.

## The tools already exist. The problem is the gaps between them.

If you've wired up AI tooling for a team, you already know the pieces. LiteLLM or Portkey handle routing. Langfuse, LangSmith or Braintrust handle traces and evals. LangGraph handles orchestration, and OpenMetadata or Atlan handle lineage. Each one is good at its own job. None of them agree on what a project is, which request belongs to which stage, or where the data went after it left the router.

So you end up writing glue. You have keys in three places, evals in four dashboards, and a spreadsheet saying which model is allowed to see which data. Mirevox is meant to be that glue, written once, with contracts that travel well enough that you can swap out any of the tools underneath. Apache-2.0. Every module repo and this site ship with Docker Compose and runnable v0.1 slices.

## Where it sits

Models are at the bottom: Foundry, Bedrock, Vertex, or whatever you run locally. Harnesses sit above them—the workspace around the model, like VS Code with an agent or a chat UI. Mirevox is the layer above the harness. It's the part a non-technical person needs to get work through, and the part an operator needs to see what happened. It isn't another terminal harness.

1. 01 ### Models & providers
  - Azure AI Foundry
  - AWS Bedrock
  - Google Vertex / Agent Builder
  - Local models
 Not Mirevox. Hyperscalers and local runtimes own this layer.
2. 02 ### Harnesses & clients
  - VS Code + side agents
  - Home chatbots
  - Other MCP-capable UIs
 Workspace around the model—tools, retries, memory. We sit on top.
3. 03 ### Request pathroute → eval / egress evidence, joined by request / trace id.
4. 04 ### Project threadproject → stage → cross-tool history, plus a shared multi-repo index.
5. 05 ### Delivery & durability observabilitycode turnover, PR review tax, AI attribution share, and complexity-adjusted throughput.
6. 06 ### Control plane hub
  - Thin compose layer
 Optional showcase connectivity—modules stay standalone, not a monolith.

## Built for the whole AI development lifecycle, not just the model call

Most AI tooling stops at the request. Real delivery takes longer than that. Someone has an idea, it turns into requirements, then a design decision, then a spec, then code, then tests. The modules are designed to follow that whole path: high-level requirements, then functional and non-functional requirements, then ADRs, then specs. At each step you get a clear answer to "can I move on yet?" SpecKit or OpenSpec can plug in, but you don't need them.

1. 01Pre-requirementsIntake, constraints, and whether the work should start at all.
2. 02HLRHigh-level requirements in language reviewers can argue with.
3. 03FR / NFRFunctional and non-functional detail—enough to build against.
4. 04ADRArchitecture decisions recorded before code pretends they were obvious.
5. 05Spec / planSpecKit, OpenSpec, or your own template—Stage Gate does not lock the method.
6. 06BuildHarness work with a clear gate: what evidence advances the stage.
7. 07VerifyTests, reviews, and sign-off tied back to the same project id.

Stages are a metaphor borrowed from ordinary workflows (book a slot, meet the gate, move on)—applied to AI delivery. Advance criteria stay readable; SpecKit and OpenSpec are options, not the only path.

## Two flows, one shared index

Nearly everything here falls into one of two paths. Both can lean on the Context Engine, so each repo gets indexed once and shared, instead of being re-ingested every time an agent starts up.

request / trace_id

A request comes in from VS Code or the home chatbot, both pointing at the same endpoint. [Smart Router](https://mirevox.dev/smart-router) decides where it goes—local model or provider—based on the task and what you've said is allowed. On the way through, [Evals & English Governance](https://mirevox.dev/evals) checks the conversation against rules you wrote in plain English, and [Data Lineage](https://mirevox.dev/data-lineage) records what data left and where it went.

project_id

Someone starts a project and gets a project ID. That ID ties together Confluence or SharePoint pages, the GitHub or Bitbucket repo, and the test results. [Stage Gate](https://mirevox.dev/stage-gate) shows which stage they're in and what's still needed. [Shadow Versioning](https://mirevox.dev/shadow-versioning) keeps the history across those tools so nobody has to learn what a rebase is just to see what changed. [Context Engine](https://mirevox.dev/context-engine) is the shared index underneath, while [AI-DORA](https://mirevox.dev/ai-dora) measures post-merge code durability, review tax, and throughput across repos.

## Why we don't build models

Foundation models are a capital game, and the hyperscalers are winning it. Competing there would waste everyone's time. The same goes for cloud Terraform portals, which were the 2020 problem.

What's left is the unglamorous part: routing between models, checking what they do, and keeping track of projects and data. The platforms will probably absorb it eventually. Until then it's useful, so it's here, open source, for anyone to run or build a business on.

## The hub is thin on purpose

There is a [control plane (opens in a new tab)](https://github.com/Mirevox/control-plane) repo, but it's mostly meant to bring the modules up together and connect them. Each module is its own repo with its own contract. You can run all seven or just the router. Nothing is hosted for you; it runs on your own machine.

## The modules

There are seven. Each one has its own page saying what it's meant to do and how far along it is. Check the repo before you depend on anything.

- [Smart RouterrunnableModel access gets scattered across provider keys, endpoints, deployment rules, and separate UIs. Even a VS Code assistant and a home chatbot can end up repeating the same integration work.](https://mirevox.dev/smart-router)
- [Evals & English GovernancerunnableEach model platform has its own eval screens, scoring terms, and policy controls. Teams end up comparing results by hand, while governance rules live in documents that do not map cleanly to provider settings.](https://mirevox.dev/evals)
- [Stage GaterunnableAI-assisted projects can jump from an appointment straight into generated code. The missing middle—prerequisites, requirements, decisions, and clear advance criteria—is usually spread across documents and understood by only a few people.](https://mirevox.dev/stage-gate)
- [Shadow VersioningrunnableOne project can have its brief in Confluence, approvals in SharePoint, code in Git, and evidence in a testing system. Humans see one piece of work, but the tools expose unrelated histories and technical version language.](https://mirevox.dev/shadow-versioning)
- [Context EnginerunnableAn agent working across 15 repositories can spend more tokens rediscovering the codebase than answering the question. Every tool builds its own partial picture, then throws much of that work away.](https://mirevox.dev/context-engine)
- [Data LineagerunnableOnce a prompt crosses a gateway, it can be hard to explain which provider, region, model, or internal service handled it. Existing lineage tools cover data estates well, but AI request paths often need a smaller, trace-linked view.](https://mirevox.dev/data-lineage)
- [AI-DORArunnableAI coding agents inflate commit counts and PR volume, hiding code churn, review bottlenecks, and rework. Traditional DORA dashboards track deployment frequency without telling you if half the AI-written lines were reverted two weeks later.](https://mirevox.dev/ai-dora)
