Qualimetry Qualimetry Enterprise
Agentic Enablement

Your standards, inside the agent's context, before it writes a line

An agent that cannot read your standards will not follow them. Qualimetry delivers your policies, principles and language standards into the agent's working context automatically, so the code comes back compliant the first time instead of coming back for another review round.

Book a Demo See the Standards Center
Eliminate agent rework

Correction is the expensive way to get compliant code

Standards reach the agent while it writes, not after it has finished. Compliant by construction, not by correction.

When the standard only appears at review time, every non-compliant change costs twice: a reviewer's attention on a rule that was written down years ago, and another agent cycle rewriting work that should never have been produced. Moving the standard upstream of the keystroke removes both costs.

  • The agent asks the MCP server what the standard is, live, as it writes.
  • Opening a file hands the agent that file's open findings and a compliant example, unprompted.
  • The pull request is reviewed against the same standards, so review confirms rather than discovers.
  • Nobody has to remember to paste a standards document into a prompt.

How your standards reach a coding agent

One source of truth, the Standards Center, reaches the agent through four parallel channels: a read-only MCP server for live tool calls, agent skills that package the workflows, agent apps for Claude Code, Codex, VS Code and Cursor, and a hook that fires when a file is opened. All four land in the same place, the agent's working context, before any code is written.

Standards Center Policies, principles, language and architecture standards
  • MCP server Live tool calls, read only StandardsFindingsCompliant examples
  • Agent skills Workflow packs, installed once CheckFixDependencies
  • Agent apps Where your teams already work Claude CodeCodexVS Code and Cursor
  • On file open Automatic, no prompt needed This file's findingsA compliant example
The agent's working context Your rules are present before the first line is written
Four channels, one destination. Nobody has to paste a standards document into a prompt.
The MCP server

Eighteen read-only tools, grouped four ways

Any agent that speaks the Model Context Protocol can call these. Every tool is read-only by design, so connecting an agent to Qualimetry can never change your standards, your findings or your configuration. Findings can be scoped to a single pull request, and a mono-repo can address one analysis at a time.

Your standards

  • get_language_coding_standards

    The language standards for the language the agent is writing in.

  • get_general_principles

    The general coding principles that apply everywhere in the estate.

  • get_secure_principles

    Your secure coding posture, as principles rather than a scanner ruleset.

  • get_policies

    The organisation-level decisions the code has to respect.

Open review findings

  • get_coding_standards_review_issues

    Open language-standard findings, optionally scoped to a pull request.

  • get_design_best_practice_review_issues

    Open design and best-practice findings.

  • get_general_principles_review_issues

    Open general-principle findings.

  • get_secure_principles_review_issues

    Open secure-principle findings.

  • get_policies_review_issues

    Open policy findings.

  • get_all_review_issues

    Everything open across all five review perspectives.

Examples and packs

  • get_standards_compliant_example

    A worked example of the compliant form, so the agent has a target rather than a complaint.

  • get_coding_standards_blitzy

    Your standards materialised as a rules pack for tools that read rules from disk.

Analysis and dependencies

  • get_rules_based_analysis_issues_summaryEnterprise

    A summary of deterministic findings for the project.

  • get_rules_based_analysis_issuesEnterprise

    The deterministic findings themselves.

  • get_rules_based_analysis_rulesEnterprise

    The rules currently active for the project.

  • get_rules_based_analysis_rules_blitzyEnterprise

    Those rules as a pack.

  • get_dependency_vulnerabilitiesEnterprise

    Known vulnerabilities in the components this project depends on.

  • get_dependency_upgrade_adviceEnterprise

    The next safe version, and how risky the upgrade looks.

Access is authenticated with a token issued from the Compliance Center, and the standards themselves are also exposed as MCP resources for clients that prefer to read rather than call.

Agent apps

Installed where your teams already work

Three shipped apps, each carrying the connection, the skills and the automatic hook. Setup is a single command or a single dialog.

Claude Code

A plugin with a compliance reviewer agent and slash commands for checking, fixing, pulling standards, triaging analysis findings and upgrading dependencies.

OpenAI Codex

A plugin installed from the Codex marketplace, with the same setup command, the same skills and the same automatic file-open hook.

VS Code and Cursor

An extension that connects Copilot Chat or Cursor chat to your MCP server and installs the skills, with a guided setup command.

Five skills, installed once

Skills package the workflows so that applying your standards is one step rather than a prompt somebody has to remember correctly.

coding-standards

Applies the standards, principles and policies for the file's language, silently, as the agent writes.

review-check

Pulls the open review issues for a file across all five perspectives, with a compliant example.

blitzy-rules

Materialises your standards as a rules pack for tools that read their rules from disk.

Enterprise

analysis-issues

Triages deterministic findings by severity, security first, then reliability, then quality.

Enterprise

dependency-check

Assess, locate manifests, upgrade to the next safe version, then restore and build to validate.

Zero-effort context

Open a file, and the agent already knows what is wrong with it

This is the feature that changes the economics, and it is deliberately invisible. No prompt, no command, no discipline required from the engineer driving the agent.

The agent reads a file

Any file, in the course of whatever it was already doing. Nothing is invoked and nothing is configured per repository.

The hook fires

It needs nothing on the machine beyond git and a standard HTTP client, so it works the same on a laptop as in a container.

Findings arrive

That file's open findings across every review perspective, grouped by pillar and severity, land in the agent's working context.

So does the fix

A standards-compliant example comes with them, so the agent has a target to write to rather than a complaint to react to.

The engineer sees none of this. They asked the agent to work on a file, and the change that comes back already respects standards nobody mentioned. That is the difference between governance people have to remember and governance that simply holds.

Getting connected

A token and an app, both issued from the Compliance Center

Engineers do not raise a ticket to get set up. The two buttons they need are on the page they already use to see their compliance.

  • Get MCP Token issues the access token their agent or IDE will use.
  • Get Agent App hands them the right app for the agent they run.
  • Setup then takes one command, and the skills and hook come with it.
See the Compliance Center
18 tools
all read-only
3 agent apps
shipped today
5 skills
installed once
On file open
context injected
The chain

Where this sits in Continuous Analysis

None of this works as a separate product. Each stage exists because of the one before it and is only worth doing because of the one after it.

Comes from
The Standards Center

Policies, principles, language standards and architecture standards, authored once and published from one place.

Leads to
Reviewed on the pull request

The same standards are checked again when the change is proposed, so review confirms rather than discovers.

See the whole loop
Questions

Agent enablement, answered

Which agents does this work with?
Claude Code, OpenAI Codex, and VS Code or Cursor have shipped apps that install the connection, the skills and the hook. Beyond those, any client that speaks the Model Context Protocol can connect to the server directly, so an agent we have never heard of can still read your standards.
Can an agent change anything through the MCP server?
No. Every one of the eighteen tools is read-only. An agent can ask what your standards are and what findings are open, and that is the entire surface. Authoring and publishing happen only in the Standards Center, by people you authorise.
Where does the access token come from?
From the Compliance Center, using the Get MCP Token button. It is self-service for the engineer and scoped to your organisation, so nobody has to wait on an administrator to start working.
Does the agent need a pull request to exist first?
No. Standards and compliant examples are available from the first keystroke. Findings can be scoped to a pull request when one exists, which is how the agent picks up exactly what its own change broke, but the standards themselves are always there.

Put your standards in front of every agent

Book a demo and watch an agent pick up your standards, then produce a pull request that already complies.

Book a Demo