Product Understanding
The long-term brain of the product. Maintains the product constitution, tracks business rules and architectural decisions, and supplies context to every other agent.
The platform
Agents that own the work
around the code.
A closed loop of specialized agents running over one SDK core — delivered into your CI, your cloud, or ours. Agent logic never forks per cloud or per git provider.
The wedge — live today
The six-agent loop
Change Impact Analysis
Predicts consequences before changes occur — dependency, API, service, database and customer impact — and generates a release risk score before merge.
Incident Learning
Ensures failures permanently improve the system: root-cause discovery, links incidents to code and PRs, and updates constitutions and review policies.
Code Correction
Closes the loop from flagged risk to proposed safeguard — generates fixes, creates patch proposals, and submits them through a human approval workflow.
Feature Planning
Turns a plain-language feature request into a scoped specification and task breakdown, grounded in Product Understanding's repository context.
Feature Build
Implements an approved task file, self-checks its own diff through Change Impact Analysis, and opens a draft PR for human approval.
Operate & govern
Built to run hundreds of agents — safely.
Monitor
Agent Monitoring Platform
Orchestration, run history and evaluation across every deployment model. One standardized run record from every entry point — local CLI, customer CI, or vendor cloud — so observability never fragments.
Govern
Human-in-the-Loop Platform
A controlled collaboration layer: approvals, escalations, supervision, analytics and governance. Evidence informs a human's decision — it never closes one.
Command
Standalone Command Center
A tool-agnostic dashboard and approval layer across Claude Code, Cursor, GitHub Copilot and VyomGrid's own agents — unified run history, cross-tool inbox, uniform guardrails. Shared, not private: one inbox the whole org works from, with substitute approvers and per-persona routing.
The graph layer
More than the agent loop —
a decision graph under it.
Every ratification — and its staleness — is shared state the whole team works from, not a private inbox.
01
Staleness propagation
When an upstream decision changes, every downstream ratification goes stale — still signed, but against something that no longer holds. Each comes back as a delta review, routed to the accountable persona. Surfaced, never auto-enforced.
02
The doc↔code join
Documents point at the code realizing them (block_realizations). "These files changed — which ratifications are now unverified?" becomes an answerable question, not archaeology.
03
Release sign-off that doesn't rot
A sign-off records the version it was signed against — and goes stale the moment that version moves. No forgotten approvals, no ritual re-reads.
What it looks like today
The real thing, not a mockup.
One shared inbox where ratifications land — and one command center over every agent run. Staleness is surfaced with the delta, never auto-enforced.
Delivery
Your trust model, your boundary.
Three deployment models, one shared pipeline. Agent logic never forks.
Model A
Customer-hosted
Agents run inside your CI — GitHub Actions, Azure DevOps, your Function App. Prompts and IP stay inspectable, inside your boundary.
Model B
Vendor-hosted
Git provider webhook → our serverless endpoint on Azure, AWS or GCP. Closed-source, fully managed, zero infrastructure for you.
Hybrid (A′)
Hybrid
Your CI triggers, our platform computes. Customer trigger, vendor compute — the middle path for regulated teams.
See the loop run on your repo.
Onboarding prepares the knowledge artifacts — codebase map, product constitution, CI workflow — in one command.