Architecture Is Policy: Compiling Governance into the AI Stack | Riddhi Mohan Sharma<br>Skip to main contentR<br>Riddhi Mohan Sharma

Riddhi Mohan SharmaEngineering Leader · Identity & AI

Connect

Riddhi Mohan Sharma

Discovery Search<br>⌘K<br>Connect

© 2026 Riddhi Mohan Sharma.

Strategy•Innovation•Technology<br>Architecture Is Policy: Compiling Governance into the AI Stack<br>Mar 21, 2026Case Study6 min read

This post describes the three-tier governance frameworks that use automated pre-build guardrails. These ensure the highest standards of fidelity and the utmost integrity of professionalism.

Typically, professional portfolios are static snapshots that are brittle and are like dioramas, eventually getting buried under a slow accumulation of technical debt.

When I rebuilt Riddhimohan.com, I refused to take the easy route. I considered the site as a living piece of infrastructure, a representative use-case of the enterprise governance architectures I design for AI agents.

The mission was Ethical Hyper-Velocity. It may sound like a contradiction, but it isn’t. It means scaling a professional presence while preserving the structural integrity of a $10B enterprise.

Above: RiddhiMohan.com as viewed on Mobile and Desktop devices, demonstrating visual stability and high-fidelity typography.

Why does manual governance fail at scale?

In contemporary systems, governance is a deployment assurance, not a human review issue. That distinction is significant. On this site, each deployment is subjected to an automated audit by custom Automated Governance guardrails.

The content guard enforces professional claims with the same consistency as a bank for transactional services. It doesn’t just “recommend” consistency; it will block the pipeline if a legacy title tries to go to production.

It treats metadata as a lex contract.

The challenge in the enterprise is not building Agentic AI. The challenge is governing it at a scale where the velocity exceeds the human audit capacity.

Each build on this site is benchmarked to Google’s PageSpeed Insights. The Desktop Performance score is unaccidentally 100/100 at build time.

What is the role of automated guardrails in ensuring integrity?

Here we shift the "culture" of neglect to standards automation. If the governance fails, the deployment fails. Simple as that.

Automated guardrails is a space Engineering Leaders will need to take ownership of. This is not something that can be passed off to Marketing.

Engineering Leaders need to own the automated guardrail roadmap personally. This cannot be pushed to marketing. This model extends directly from my work on Global Identity PaaS.

If Performance could be reduced to a number, it would be a con. A slow site is a broken brand.

In this architecture, a CWV guard will always be there to protect the site.

From Agentic Enforcement to Passive Guardrails

Phase 1 of the three-tier architecture shown above consists of structural guardrails. EHV becomes operationally complete in Phase 2, where CWV Metrics are treated as laws of physics enforced by an AI agent with remediation authority instead of as metrics to monitor.

The distinction is important. A conventional guardrail alerts. An agentic guardrail steps in.

The AI agent in this framework does more than just identify a slow Largest Contentful Paint (LCP). It finds the offending code change, isolates the architectural root cause, and creates a fix.

Deployment is prevented until the fix is executed, typically by the agent itself.

To enact Governance and Guardrails for CWV Metrics deploying AI agents as 'laws of physics,’ we step from just periodic watching, into Active Enforcement and Automated Remediation.

Core Technical Structural Build

This build is built upon three distinct Agentic Roles:

RoleResponsibilityTechnical ToolingThe ObserverContinuous runtime & build-time performance auditing.Lighthouse CI, metrics library, PuppeteerThe LawmakerDefines non-negotiable thresholds (The "Physical Laws")cwv-guard.mjs, budget.json.The Remediator(The AI Agent) Analyzes regressions and applies fixes.LLM-driven Diff Analysis, Image Tuning API, Next/Image automation.<br>1. The 'Physical Law' Layer (Pre-Commit/Pre-Push)

The architecture strengthens the scripts/cwv-guard.mjs to interact with a Budget Policy. It does more than just look for 'legacy colors' anymore; it performs a gated check for real performance metrics.

Shadow Build Mechanism: A GitHub Action or Git Hook that initiates a 'Shadow Build.'

Enforcement: If during the shadow build the LCP is above 1.2s or CLS > 0.1, the build is marked as a 'Hard Fail'.

2. The Agentic Remediation Loop

The AI Agent gets invoked whenever a 'Physical Law' gets broken.

Context Injection: These agents obtain the Lighthouse JSON report & Current Git Diff.

Root Cause Analysis: The agents clarify which change caused the issue (e.g. “The new hero image in HomeClient.tsx lacks fetchPriority”).

The ‘Correction’ Ghostwriter: The agent creates a Remediation...