Case Study

Breaking the innovation bottleneck: Momentuum blue built the Technology Architecture Center, an AI architecture governance platform that checks every design against policy as it is written, so architects spend review time on exceptions instead of routine

Written by Coforge | Nov 19, 2026, 10:59:42 AM

Client Overview

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.

 

The Business Challenge

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).

Our Solution

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:

  • Centralizes architecture knowledge: Policies, standards, decisions and approved designs live in one place, as versioned data rather than scattered documents. It is also the team's first system of record for architecture decisions.
  • Drafts designs grounded in policy: Agents help solution architects produce designs that start out aligned, and answer questions that would otherwise go to a domain architect.
  • Checks every design deterministically: An evaluation engine checks a submitted design against every policy in force and reports evidence-backed findings, each citing the text it rests on.
  • Learns from reviewers: Every finding a reviewer marks as right or wrong feeds a loop that improves the rules and vocabulary, previewed for side effects before anything changes.

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:

  • Policy is data, not code: Rules and the vocabulary they use are versioned data, curated by subject matter experts. A new or changed policy needs no engineering release, and once an expert approves a rule it applies to the next design drafted and to every request still under review.
  • Published standards over a custom rule language: A design is a C4 model expressed as RDF, meaning comes from a SKOS controlled vocabulary, and each rule is a SHACL shape over the design. Rebuilding on standards removed about 65% of the code and added capability, and experts never write SHACL by hand: they fill in a form that generates the shape and its plain-English sentence together.
  • The model reads; rules decide: Language models read messy design documents and diagrams, but the compliance decision is never left to a model, because the same question can get a different answer. Every fact the model reads must carry a quote that code checks against the document, and each reading is pinned to the document's hash, so re-evaluating replays the same reading with no new model call and no drift.
  • Omissions are the hard case: In the engine an omission is just another SHACL constraint, so checking that something is stated costs the same as checking that it is forbidden. The model reads each document once, and adding a rule costs no model calls, which is why a new policy can apply to every design under review the moment it is approved.
  • Unknown is an answer: If a design uses a term the vocabulary does not define, the engine reports it as unverifiable rather than guessing. A small model may suggest a matching term, but it must name one exactly from the list, and a person confirms it.
  • Evidence and coverage, never a verdict: The engine reports six kinds of result (violation, omission, conflict, unverifiable, structure and compliant), each citing the rule version, vocabulary version and source quote behind it. It never says approved; that call stays with the architects.

Key solution components

  • Portal and agents: A React single-page portal (Knowledge Studio, Requester Workspace and Reviewer Workbench) and LangGraph agents that draft, explain and answer, served by a Python application on ECS Fargate.
  • Evaluation Engine: Deterministic code that reads, pins, projects and validates every design against the rules in force, built on C4, RDF, SKOS and SHACL, and records findings, coverage and the evidence behind each.
  • Governed knowledge and integration: Versioned rules and vocabulary in managed AWS stores, a separate Integration API with its own identity for enterprise sources, and an MCP endpoint that exposes read-only knowledge tools to other teams' AI agents.
  • Evaluation framework: Golden sets of designs with planted faults, development and held-out splits, lower-bound scoring and an accuracy gate on every change.

Solution Architecture

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.

Figure 1: How a design is evaluated

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.

Figure 2: AGH  deployment in the client's AWS account

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:

  • Graphs in memory: Each design's RDF graph is built in memory for one evaluation and then discarded. Pinned readings make rebuilding it cheap, and an append-only relational store keeps every version.
  • The option stays open: Designs, rules and vocabulary are already RDF, SHACL and SKOS, so moving them into a graph database later is a storage change, not a redesign. When the client wants to explore open-world questions, such as reasoning across many designs, AGH can migrate to or integrate one.

Built for a regulated enterprise:

  • Private by default: Every AWS service is reached through private endpoints, outbound traffic is limited to an allow-list, and the database uses IAM sign-in with no password.
  • Agents as first-class consumers: An MCP endpoint exposes the knowledge base to other teams' AI agents through the same access controls as the portal.

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.

Business Outcomes & Impact

"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

Additional impact

  • On the held-out set, AGH reports at least 91% of the problems human reviewers would raise, and at least 85% of what it reports is something they would raise too. That puts it in line with a human reviewer working from the same rulebook.
  • Most misses are "unverifiable" findings. When a document is silent on a control, the engine has to say it cannot verify it rather than say nothing. That is the hardest case, and the one being worked on.
  • Every false alarm was an omission raised where the design did not need one. On the development set, both false alarms came from a single rule, which points to a few rules to tighten, not a general fault.
  • The engine does not over-infer: where a document allowed an inference either way, it kept to what was stated.