The client is a global consumer products company. Its architecture review board reviews proposed technology initiatives against company policy before they proceed. The board is also the intended model for the many other review boards across the company, so whatever was built had to generalize.
Like most large organizations, the company ran architecture governance the same way. A team proposes an initiative, and a small group of domain architects reviews it against policies written in prose, spread across wikis, document libraries and people’s heads. The review board meets weekly for one hour and covers about two initiatives, and only four domain architects serve the board. Designs come back for missing information, get revised, and join the queue again. The cost is not just reviewer hours. Every week an initiative waits for alignment is a week of its value lost, and every month a policy is not applied is a month of exposure.
Momentuum blue was engaged to evolve the company’s architecture operating model from a predominantly people-centric, manually driven approach to a scalable, knowledge- and intelligence-enabled one. In 16 weeks, with a small hybrid onshore and offshore team, it built the Architecture Governance Hub (AGH), an AI architecture governance platform, entirely inside the client’s own cloud account, to remove the queue. Agents draft designs grounded in the organization’s policies, a deterministic engine checks each design against those policies and shows exactly where it departs from them, and architects spend their review time on the exceptions.
AGH is deployed and in user acceptance testing on live designs.
Challenge 1: Expertise does not scale
The people who know the policies well enough to apply them are few, and they are also the people the organization most needs designing new things. Reviewer bandwidth is the bottleneck: every new initiative queues behind a handful of expert architects.
Challenge 2: Policy lives in prose
A rule in a document cannot check anything. It has to be read, remembered and applied by hand, every time, by every reviewer.
Challenge 3: New policy takes months to reach practice
A policy reaches designs through communication, training and review cycles. In a DataGrail survey of US companies, 52% took at least seven months to become GDPR compliant once they started, and only 12% managed it within three (OODA Loop). A MetricStream survey of more than 260 organizations found 55% were unaware of policy violations in their own enterprise (IT Chronicles).
Momentuum blue built Architecture Governance Hub (AGH), an AI architecture governance platform, in 16 weeks with a small hybrid onshore and offshore team, entirely inside the client's own cloud account. Agents draft designs that are grounded in the organization's policies from the first line. A deterministic engine checks each design against those policies and shows exactly where it departs from them. Architects spend their review time on the exceptions instead of the routine.
Governance at the speed of automation: when policy is data that code applies to every design as it is written, a newly approved policy reaches the very next design, not the next training cycle.
AGH does four things:
A governance tool lives or dies on trust. If an architect cannot see why a finding was raised, or gets a different answer when they ask twice, they will go back to reviewing by hand. Six design principles shaped everything built:
AGH runs as Python services on ECS Fargate, backed by managed AWS stores, inside the client's own AWS account. The application serves the portal, the agents and the evaluation engine. A separate Integration API, with its own identity, connects to enterprise sources such as the architecture repository, wiki and ticketing system. Every model call leaves through the client's LiteLLM gateway; nothing else in the system talks to a model.
Every design is evaluated in five steps, and the evaluation never lets a model make the decision.
Step 1: Read: A model reads the document's prose and diagram images into C4 facts, each with a quote that code checks against the source.
Step 2: Pin: The reading is stored against the document's SHA-256 hash and replayed on every re-evaluation.
Step 3: Project: Code turns the pinned facts into an RDF graph.
Step 4: Validate: Every rule in force runs as a SHACL shape over that graph.
Step 5: Record: Findings, compliant results and coverage are stored with the rule, vocabulary and quote behind each one. A person decides.
The Evaluation Engine (highlighted below) is where every finding is made, by deterministic code. Agents and the engine's readers reach models only through Model Access, so every call is screened and audited in one place.
Closed world now, open world later: AGH answers a closed-world question: does this design satisfy these governance constraints? Everything needed to answer it is in the design and the rules, and anything the design does not state counts as not stated. That is exactly the assumption SHACL validates under, and it is what makes omissions checkable at all. So the initial rollout does not run a graph database:
Built for a regulated enterprise:
How it gets better: Reviewers mark each result right or wrong and route a wrong one to the rule, the vocabulary or the facts. When an expert changes a rule or term, the change is first replayed against every submission reviewers have already judged: a wrong result that disappears is a fix, and a right one that disappears is a regression. Only then does it apply. That preview is what makes it safe for policy to change quickly.
"It looks right in the demo" is not evidence, so the evaluation framework was built into the system. Test cases are design documents written from known designs with problems deliberately planted, and a person approved every document as a faithful account of its design. AGH was tuned against a development set and is reported on a held-out set it was never tuned on. Recall and precision are reported separately and never averaged into an F1 score, and a measure passes only if, allowing for chance in a sample of this size, we are 80% confident the true rate is at least 80%. The rules and vocabulary used for scoring are frozen with the golden set, and the accuracy suite runs on every pull request.
| Metric | Result | What it means |
|---|---|---|
| Time to deploy | 16 weeks | Built with a small hybrid onshore and offshore team, entirely inside the client's own cloud account. Now deployed and in user acceptance testing on live designs. |
| Recall, held-out set | 94.9% at least 91% |
74 of 78 planted problems reported, as the right kind of finding on the right element. The lower bound at 80% confidence clears the 80% bar. |
| Precision, held-out set | 89.8% at least 85% |
79 of 88 reported findings are supported by the design. Recall rose and precision fell compared with the development set, the usual pattern when a system meets cases it was not tuned on, and both still clear the bar. |
| Recall, development set | 89.7% at least 83% |
35 of 39 planted problems reported. |
| Precision, development set | 94.9% at least 89% |
37 of 39 reported findings are supported by the design. |
Figure 3: AGH evaluation runs on the development and held-out golden sets