Sign in
abstract agent · revenue-operations · 4 processes · plugin 1.0.0

Data quality check

data-quality-check v1

Runs the rules that say a record is usable, and reports failures to the source rather than patching the report. It writes what the system refuses at save time, what it warns on and what it only reports later, tests those rules over the records already held before any of them goes live, and reads the failing count on a cadence afterwards. When a rule starts failing it confirms the failure is real, measures how far it spread, finds the day it started, and traces it back to the form, the import, the integration or the person that wrote the bad values. It runs the rule again only after the source has been fixed, watches it for a period, and records a failure with no named source as unexplained rather than as fixed.

The abstract agent

What it is granted, and what it hands to a person

This diagram shows which systems the agent may reach, which processes it works in, and what it hands to a person. Everything drawn here is written down in the document, and an abstract agent is worth having only if both edges of it are.

WORKS INref/rev/dedupe-and-mergeref/rev/define-a-recordref/rev/enrich-a-recordGRANTEDthe CRMread — the records the rules are run overthe validation ruleswrite — what the system refuses, what it warnsthe reporting layerread — the query behind a failing rule, read lthe data warehouseread — how many records fail, which objects, wthe review queuewrite — the rule failures and the held fills lthe change logread — what shipped, changed or was imported tTHE ABSTRACT AGENTdata-quality-checkv1runs the rules that say…HANDS TO A PERSONa rule the test shows…a person decidessaves failing in numbers…a person decidesa trail that runs cold,…a person decidesrecords still failing…a person decidesa failure that comes back…a person decidesMUST FOLLOWcollect-and-reportassessmentroll call

Runs assessment over and over: the rules over the records already held before they go live, the definition's rules over everything an enrichment wrote, the counts and the affected reports before and after a merge, and the failing rule re-run against the records as they stand now. Runs collect-and-report on how far a failure spread and on whether the fix held across the watch period, and roll-call on the failing count from the moment the rules go live until the backfill deadline. Takes the definition from the data-steward agent and gives that agent the failing count and the trace. Takes the spread from the statistician agent, takes the held fills from the enrichment-operator agent, and hands what a merge did not carry back to the deduper agent.

The plugin

What is in the package

4 skills and the systems they need, written to version 1.1.0 of the Agent Plugins standard. Nothing in these files names a product. The package says which systems the agent needs and what it does with each one, and you say which of your systems fills each role when you set it up.

data-quality-check · 9 files · 1.0.0
com.agentcatalog.agent/NOT.mdWhat the agent does not do, and when it asks a person.
# Where this abstract agent stops

Does not decide what a record must contain, which is the data-steward
agent publishing the definition this agent writes rules for. Does not
correct the records already wrong or change the source, which are the
data-steward agent and the person who owns the writing system. Does not
fill an empty field, which is the enrichment-operator agent, and only
holds back the fills that fall under the bar. Does not merge or reverse
a merge: it checks that the merge landed and says what did not move.
Does not filter a report to hide the records that fail a rule, and does
not switch a rule off quietly.

## What always goes to a person

- a rule the test shows failing records that are fine, back to the
  draft, because a rule is never shipped with the plan of ignoring its
  own failures
- saves failing in numbers after a rule goes live, and the refusing rule
  drops to a warning rather than being left on while people invent
  values to get past it
- a trail that runs cold, and the failure is closed as unexplained with
  the count and the dates rather than as fixed
- records still failing after the fix, back to the trace, because there
  was more than one source and the second is found the same way as the
  first
- a failure that comes back twice from the same source, to whoever owns
  that system, as a system problem rather than a data problem
com.agentcatalog.agent/RECORDS.mdThe records the agent must leave behind.
# The records this abstract agent must leave

This is the contract. An agent implementing `data-quality-check` leaves
the following behind, on every run.

Per rule: the rule at a version, split into refuse, warn and report, and
the count of records already held that would fail it with the kinds of
record they are. The date it went live, and the failing count on its
cadence until the backfill deadline. Per failure: which rule, what it
measures, since when it has been failing and how far past its threshold
it sits; the re-run that showed whether the failure was in the data or
in the query; the failing records by object, owner and date; the day it
first failed set beside what shipped that week; the system, form or
person that wrote the failing values, with the evidence that it was that
one; the rule's result on the corrected records and on the records
written since the source was fixed; and the rule read on its cadence
across the watch period. A rule changed or retired lands at a new
version with the reason written down. Per merge: the record counts, the
related record counts and the affected reports read before and after,
with anything that did not reconcile.

An agent that leaves less than this does not implement
`data-quality-check`, whatever else it does well.
com.agentcatalog.agent/SERVERS.mdThe systems the agent needs, by role rather than by product.
# The systems this abstract agent needs

Six systems, named by role rather than by product. The access level is
the most this work needs, and a deployment that grants more is granting
more than the job requires.

| Role | Access | What the access is for |
|---|---|---|
| the CRM | read | The records the rules are run over. |
| the validation rules | write | What the system refuses, what it warns on and what it only reports later, held at a version. |
| the reporting layer | read | The query behind a failing rule, read line by line for its own errors before the data is blamed. |
| the data warehouse | read | How many records fail, which objects, which owners, and what share of the period they are. |
| the review queue | write | The rule failures and the held fills land in one queue for the person clearing it. |
| the change log | read | What shipped, changed or was imported the week a rule first began to fail. |

Whoever builds an agent from this plugin writes the `mcp.json` that
points these roles at their own systems. Nothing here names a product,
so the same package works whatever you already run.
plugin.jsonThe manifest. It lists the skills and the systems the agent needs.
{
  "$schema": "https://agent-plugins.org/schemas/1.1.0/plugin.schema.json",
  "name": "data-quality-check",
  "version": "1.0.0",
  "description": "The data-quality-check abstract agent. Runs the rules that say a record is usable, and reports failures to the source rather than patching the report.",
  "author": {
    "name": "AgentCatalog",
    "url": "https://agentcatalog.com"
  },
  "homepage": "https://agentcatalog.com/abstract-agents/data-quality-check",
  "repository": "https://github.com/jeffrschneider/agentcatalog",
  "license": "CC-BY-4.0",
  "keywords": [
    "abstract-agent",
    "reference",
    "revenue-operations",
    "fix-a-data-quality-failure",
    "define-a-record",
    "enrich-a-record",
    "abstract"
  ],
  "extensions": {
    "com.agentcatalog.agent": {
      "agent": "data-quality-check",
      "agentVersion": 1,
      "department": "revenue-operations",
      "abstract": true,
      "works": "Runs assessment over and over: the rules over the records already held before they go live, the definition's rules over everything an enrichment wrote, the counts and the affected reports before and after a merge, and the failing rule re-run against the records as they stand now. Runs collect-and-report on how far a failure spread and on whether the fix held across the watch period, and roll-call on the failing count from the moment the rules go live until the backfill deadline. Takes the definition from the data-steward agent and gives that agent the failing count and the trace. Takes the spread from the statistician agent, takes the held fills from the enrichment-operator agent, and hands what a merge did not carry back to the deduper agent.",
      "servers": [
        {
          "name": "the CRM",
          "role": "crm",
          "access": "read",
          "needs": "The records the rules are run over."
        },
        {
          "name": "the validation rules",
          "role": "validation-rules",
          "access": "write",
          "needs": "What the system refuses, what it warns on and what it only reports later, held at a version."
        },
        {
          "name": "the reporting layer",
          "role": "reporting-layer",
          "access": "read",
          "needs": "The query behind a failing rule, read line by line for its own errors before the data is blamed."
        },
        {
          "name": "the data warehouse",
          "role": "data-warehouse",
          "access": "read",
          "needs": "How many records fail, which objects, which owners, and what share of the period they are."
        },
        {
          "name": "the review queue",
          "role": "review-queue",
          "access": "write",
          "needs": "The rule failures and the held fills land in one queue for the person clearing it."
        },
        {
          "name": "the change log",
          "role": "change-log",
          "access": "read",
          "needs": "What shipped, changed or was imported the week a rule first began to fail."
        }
      ],
      "records": [
        "Per rule: the rule at a version, split into refuse, warn and report, and the count of records already held that would fail it with the kinds of record they are.",
        "The date it went live, and the failing count on its cadence until the backfill deadline.",
        "Per failure: which rule, what it measures, since when it has been failing and how far past its threshold it sits; the re-run that showed whether the failure was in the data or in the query; the failing records by object, owner and date; the day it first failed set beside what shipped that week; the system, form or person that wrote the failing values, with the evidence that it was that one; the rule's result on the corrected records and on the records written since the source was fixed; and the rule read on its cadence across the watch period.",
        "A rule changed or retired lands at a new version with the reason written down.",
        "Per merge: the record counts, the related record counts and the affected reports read before and after, with anything that did not reconcile."
      ],
      "escalates": [
        "a rule the test shows failing records that are fine, back to the draft, because a rule is never shipped with the plan of ignoring its own failures",
        "saves failing in numbers after a rule goes live, and the refusing rule drops to a warning rather than being left on while people invent values to get past it",
        "a trail that runs cold, and the failure is closed as unexplained with the count and the dates rather than as fixed",
        "records still failing after the fix, back to the trace, because there was more than one source and the second is found the same way as the first",
        "a failure that comes back twice from the same source, to whoever owns that system, as a system problem rather than a data problem"
      ],
      "not": [
        "Does not decide what a record must contain, which is the data-steward agent publishing the definition this agent writes rules for.",
        "Does not correct the records already wrong or change the source, which are the data-steward agent and the person who owns the writing system.",
        "Does not fill an empty field, which is the enrichment-operator agent, and only holds back the fills that fall under the bar.",
        "Does not merge or reverse a merge: it checks that the merge landed and says what did not move.",
        "Does not filter a report to hide the records that fail a rule, and does not switch a rule off quietly."
      ],
      "processes": [
        {
          "process": "ref/rev/dedupe-and-merge",
          "activities": [
            "Check the Merge Landed"
          ]
        },
        {
          "process": "ref/rev/define-a-record",
          "activities": [
            "Write the Rules That Enforce It",
            "Test the Rules on Real Records",
            "Turn the Rules On"
          ]
        },
        {
          "process": "ref/rev/enrich-a-record",
          "activities": [
            "Hold Back the Weak Fills",
            "Run the Rules Over the Fill"
          ]
        },
        {
          "process": "ref/rev/fix-a-data-quality-failure",
          "activities": [
            "Take in the Failing Rule",
            "Check the Failure Is Real",
            "Measure How Far It Spread",
            "Trace It to Its Source",
            "Run the Rule Again",
            "Watch That the Fix Held",
            "Tighten the Rule"
          ]
        }
      ]
    }
  }
}
README.mdWhat the package is, and why it carries no mcp.json.
# data-quality-check

This is an abstract agent, published as an Agent Plugin. An abstract
agent is a job description rather than an implementation. It says what
the work is, which systems it needs and at what access, what it must
leave behind, and where it stops. Any agent that leaves the records can
implement it.

The plugin carries four skills, no `mcp.json`, and everything the
abstract agent owes under `com.agentcatalog.agent/`.

## Why there is no mcp.json

A conformant server entry in `mcp.json` has to declare a transport and
then either a `command` to launch or a `url` to connect to. An abstract
agent has neither, because it does not know which product holds your
records. Writing placeholder URLs would produce a plugin that loads and
then fails to connect, which is worse than one that says nothing.

Section 6.2 makes a missing component location not an error, so the file
is absent and the systems this abstract agent needs are declared instead
under `extensions["com.agentcatalog.agent"].servers`, as a role, an
access level and what the access is for. Whoever builds an agent from
this plugin writes the `mcp.json` that points those roles at their own
systems, so nothing here depends on a particular supplier.

## Why the obligations are in an extension

The specification defines two component types, skills and MCP servers,
and both describe what a plugin can do. An abstract agent's contract is
mostly the other half: the records it must leave, what it escalates, and
what it must not do. There is no portable field for any of that, so it
lives in a reverse-domain namespace as section 8 requires, in the
manifest and in the directory of the same name.

## Where this abstract agent is used

`ref/rev/dedupe-and-merge`, `ref/rev/define-a-record`,
`ref/rev/enrich-a-record`, `ref/rev/fix-a-data-quality-failure`. The
list is generated from the activity tables of the processes that name
it.

https://agentcatalog.com/abstract-agents/data-quality-check
skills/confirm-a-failure-and-find-what-wrote-it/SKILL.mdTakes in a failing rule and re-runs it to see whether the failure is in the data or in the query behind it. Use it when running `ref/rev/fix-a-data-quality-failure`.
---
name: confirm-a-failure-and-find-what-wrote-it
description: Takes in a failing rule and re-runs it to see whether the failure is in the data or in the query behind it. Use it when running `ref/rev/fix-a-data-quality-failure`.
license: CC-BY-4.0
metadata:
  agent: data-quality-check
  agent-version: "1"
---

# Confirm a failure and find what wrote it

## What it does

Takes in a failing rule and re-runs it to see whether the failure is in
the data or in the query behind it. Then measures how far it spread,
finds the day it started, and traces it back to the form, the import,
the link or the person that wrote the bad values.

## Where it happens

The agent does this in four activities across one reference process.
Each one names the activity as that process words it.

- **Check the Failure Is Real**
  - `ref/rev/fix-a-data-quality-failure`, activity 2 -
    [Fix a Data Quality Failure](../../../../processes/revenue-operations/fix-a-data-quality-failure.md)
- **Measure How Far It Spread**
  - `ref/rev/fix-a-data-quality-failure`, activity 3 -
    [Fix a Data Quality Failure](../../../../processes/revenue-operations/fix-a-data-quality-failure.md)
- **Take in the Failing Rule**
  - `ref/rev/fix-a-data-quality-failure`, activity 1 -
    [Fix a Data Quality Failure](../../../../processes/revenue-operations/fix-a-data-quality-failure.md)
- **Trace It to Its Source**
  - `ref/rev/fix-a-data-quality-failure`, activity 5 -
    [Fix a Data Quality Failure](../../../../processes/revenue-operations/fix-a-data-quality-failure.md)

## What to record

Per rule: the rule at a version, split into refuse, warn and report, and
the count of records already held that would fail it with the kinds of
record they are. The date it went live, and the failing count on its
cadence until the backfill deadline. Per failure: which rule, what it
measures, since when it has been failing and how far past its threshold
it sits; the re-run that showed whether the failure was in the data or
in the query; the failing records by object, owner and date; the day it
first failed set beside what shipped that week; the system, form or
person that wrote the failing values, with the evidence that it was that
one; the rule's result on the corrected records and on the records
written since the source was fixed; and the rule read on its cadence
across the watch period. A rule changed or retired lands at a new
version with the reason written down. Per merge: the record counts, the
related record counts and the affected reports read before and after,
with anything that did not reconcile.

That contract covers every activity this abstract agent takes on, and it
is repeated in `com.agentcatalog.agent/RECORDS.md`. What the abstract
agent does not do is in `com.agentcatalog.agent/NOT.md`.
skills/prove-the-fix-held/SKILL.mdRuns the rule again only after the source has been fixed, reads it on its cadence across a watch period, and tightens it where the failure showed the rule was too loose. Use it when running `ref/rev/fix-a-data-quality-failure`.
---
name: prove-the-fix-held
description: Runs the rule again only after the source has been fixed, reads it on its cadence across a watch period, and tightens it where the failure showed the rule was too loose. Use it when running `ref/rev/fix-a-data-quality-failure`.
license: CC-BY-4.0
metadata:
  agent: data-quality-check
  agent-version: "1"
---

# Prove the fix held

## What it does

Runs the rule again only after the source has been fixed, reads it on
its cadence across a watch period, and tightens it where the failure
showed the rule was too loose. Records still failing go back to the
trace, because there was more than one source.

## Where it happens

The agent does this in three activities across one reference process.
Each one names the activity as that process words it.

- **Run the Rule Again**
  - `ref/rev/fix-a-data-quality-failure`, activity 12 -
    [Fix a Data Quality Failure](../../../../processes/revenue-operations/fix-a-data-quality-failure.md)
- **Tighten the Rule**
  - `ref/rev/fix-a-data-quality-failure`, activity 14 -
    [Fix a Data Quality Failure](../../../../processes/revenue-operations/fix-a-data-quality-failure.md)
- **Watch That the Fix Held**
  - `ref/rev/fix-a-data-quality-failure`, activity 13 -
    [Fix a Data Quality Failure](../../../../processes/revenue-operations/fix-a-data-quality-failure.md)

## What to record

Per rule: the rule at a version, split into refuse, warn and report, and
the count of records already held that would fail it with the kinds of
record they are. The date it went live, and the failing count on its
cadence until the backfill deadline. Per failure: which rule, what it
measures, since when it has been failing and how far past its threshold
it sits; the re-run that showed whether the failure was in the data or
in the query; the failing records by object, owner and date; the day it
first failed set beside what shipped that week; the system, form or
person that wrote the failing values, with the evidence that it was that
one; the rule's result on the corrected records and on the records
written since the source was fixed; and the rule read on its cadence
across the watch period. A rule changed or retired lands at a new
version with the reason written down. Per merge: the record counts, the
related record counts and the affected reports read before and after,
with anything that did not reconcile.

That contract covers every activity this abstract agent takes on, and it
is repeated in `com.agentcatalog.agent/RECORDS.md`. What the abstract
agent does not do is in `com.agentcatalog.agent/NOT.md`.
skills/run-the-rules-over-what-something-just-wrote/SKILL.mdRuns the definition's rules over everything an enrichment wrote and holds back the fills that fall under the bar. Use it when running `ref/rev/dedupe-and-merge` and `ref/rev/enrich-a-record`.
---
name: run-the-rules-over-what-something-just-wrote
description: Runs the definition's rules over everything an enrichment wrote and holds back the fills that fall under the bar. Use it when running `ref/rev/dedupe-and-merge` and `ref/rev/enrich-a-record`.
license: CC-BY-4.0
metadata:
  agent: data-quality-check
  agent-version: "1"
---

# Run the rules over what something just wrote

## What it does

Runs the definition's rules over everything an enrichment wrote and
holds back the fills that fall under the bar. Reads the record counts,
the related record counts and the affected reports before and after a
merge, and says what did not move.

## Where it happens

The agent does this in three activities across two reference processes.
Each one names the activity as that process words it.

- **Check the Merge Landed**
  - `ref/rev/dedupe-and-merge`, activity 14 -
    [Dedupe and Merge](../../../../processes/revenue-operations/dedupe-and-merge.md)
- **Hold Back the Weak Fills**
  - `ref/rev/enrich-a-record`, activity 11 -
    [Enrich a Record](../../../../processes/revenue-operations/enrich-a-record.md)
- **Run the Rules Over the Fill**
  - `ref/rev/enrich-a-record`, activity 12 -
    [Enrich a Record](../../../../processes/revenue-operations/enrich-a-record.md)

## What to record

Per rule: the rule at a version, split into refuse, warn and report, and
the count of records already held that would fail it with the kinds of
record they are. The date it went live, and the failing count on its
cadence until the backfill deadline. Per failure: which rule, what it
measures, since when it has been failing and how far past its threshold
it sits; the re-run that showed whether the failure was in the data or
in the query; the failing records by object, owner and date; the day it
first failed set beside what shipped that week; the system, form or
person that wrote the failing values, with the evidence that it was that
one; the rule's result on the corrected records and on the records
written since the source was fixed; and the rule read on its cadence
across the watch period. A rule changed or retired lands at a new
version with the reason written down. Per merge: the record counts, the
related record counts and the affected reports read before and after,
with anything that did not reconcile.

That contract covers every activity this abstract agent takes on, and it
is repeated in `com.agentcatalog.agent/RECORDS.md`. What the abstract
agent does not do is in `com.agentcatalog.agent/NOT.md`.
skills/write-the-rules-a-record-is-held-to/SKILL.mdWrites what the system refuses at save time, what it warns on and what it only reports later, holds that split at a version, runs it over the records already held to see what would fail, and turns it on with the failing count read on a cadence afterwards. Use it when running `ref/rev/define-a-record`.
---
name: write-the-rules-a-record-is-held-to
description: Writes what the system refuses at save time, what it warns on and what it only reports later, holds that split at a version, runs it over the records already held to see what would fail, and turns it on with the failing count read on a cadence afterwards. Use it when running `ref/rev/define-a-record`.
license: CC-BY-4.0
metadata:
  agent: data-quality-check
  agent-version: "1"
---

# Write the rules a record is held to

## What it does

Writes what the system refuses at save time, what it warns on and what
it only reports later, holds that split at a version, runs it over the
records already held to see what would fail, and turns it on with the
failing count read on a cadence afterwards.

## Where it happens

The agent does this in three activities across one reference process.
Each one names the activity as that process words it.

- **Test the Rules on Real Records**
  - `ref/rev/define-a-record`, activity 11 -
    [Define a Record](../../../../processes/revenue-operations/define-a-record.md)
- **Turn the Rules On**
  - `ref/rev/define-a-record`, activity 15 -
    [Define a Record](../../../../processes/revenue-operations/define-a-record.md)
- **Write the Rules That Enforce It**
  - `ref/rev/define-a-record`, activity 10 -
    [Define a Record](../../../../processes/revenue-operations/define-a-record.md)

## What to record

Per rule: the rule at a version, split into refuse, warn and report, and
the count of records already held that would fail it with the kinds of
record they are. The date it went live, and the failing count on its
cadence until the backfill deadline. Per failure: which rule, what it
measures, since when it has been failing and how far past its threshold
it sits; the re-run that showed whether the failure was in the data or
in the query; the failing records by object, owner and date; the day it
first failed set beside what shipped that week; the system, form or
person that wrote the failing values, with the evidence that it was that
one; the rule's result on the corrected records and on the records
written since the source was fixed; and the rule read on its cadence
across the watch period. A rule changed or retired lands at a new
version with the reason written down. Per merge: the record counts, the
related record counts and the affected reports read before and after,
with anything that did not reconcile.

That contract covers every activity this abstract agent takes on, and it
is repeated in `com.agentcatalog.agent/RECORDS.md`. What the abstract
agent does not do is in `com.agentcatalog.agent/NOT.md`.
mcp.jsonNot in the package.

Every server entry in an mcp.json needs either a command to run or a url to connect to, and the package cannot know either of those until somebody points it at their own systems. So the file is left out, the systems the agent needs are named by role in plugin.json, and you write the mcp.json when you set it up.

Setting it up

Point it at your systems

To run an agent built from this package, write an mcp.json that says which of your systems fills each role. The package names these 6 roles, and the access level beside each one is the most the work needs.

crm · readvalidation-rules · writereporting-layer · readdata-warehouse · readreview-queue · writechange-log · read
mcp.json You write this file. It is not part of the package.
{
  "$schema": "https://agent-plugins.org/schemas/1.1.0/mcp.schema.json",
  "mcpServers": {
    "crm": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/crm"
    },
    "validation-rules": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/validation-rules"
    },
    "reporting-layer": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/reporting-layer"
    },
    "data-warehouse": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/data-warehouse"
    },
    "review-queue": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/review-queue"
    },
    "change-log": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/change-log"
    }
  }
}

The hostnames here are a placeholder for your own. Whichever product holds each of these systems, the agent you build is yours and nobody else has to be involved in running it.

Where it works

4 processes, 13 activities

The highlighted activities are the ones this abstract agent does. The other activities in each process belong to other abstract agents or to people.

Dedupe and Mergeref/rev/dedupe-and-merge · 17 activities
1234567891011121314151617

Check the Merge Landed

Define a Recordref/rev/define-a-record · 17 activities
1234567891011121314151617

Write the Rules That Enforce It · Test the Rules on Real Records · Turn the Rules On

Enrich a Recordref/rev/enrich-a-record · 16 activities
12345678910111213141516

Hold Back the Weak Fills · Run the Rules Over the Fill

Fix a Data Quality Failureref/rev/fix-a-data-quality-failure · 16 activities
12345678910111213141516

Take in the Failing Rule · Check the Failure Is Real · Measure How Far It Spread · Trace It to Its Source · Run the Rule Again · Watch That the Fix Held · Tighten the Rule

The records it leaves

What it writes down

Per rule: the rule at a version, split into refuse, warn and report, and the count of records already held that would fail it with the kinds of record they are. The date it went live, and the failing count on its cadence until the backfill deadline. Per failure: which rule, what it measures, since when it has been failing and how far past its threshold it sits; the re-run that showed whether the failure was in the data or in the query; the failing records by object, owner and date; the day it first failed set beside what shipped that week; the system, form or person that wrote the failing values, with the evidence that it was that one; the rule's result on the corrected records and on the records written since the source was fixed; and the rule read on its cadence across the watch period. A rule changed or retired lands at a new version with the reason written down. Per merge: the record counts, the related record counts and the affected reports read before and after, with anything that did not reconcile.

Where it stops

What it will not do

Does not decide what a record must contain, which is the data-steward agent publishing the definition this agent writes rules for. Does not correct the records already wrong or change the source, which are the data-steward agent and the person who owns the writing system. Does not fill an empty field, which is the enrichment-operator agent, and only holds back the fills that fall under the bar. Does not merge or reverse a merge: it checks that the merge landed and says what did not move. Does not filter a report to hide the records that fail a rule, and does not switch a rule off quietly.

These limits are written into the job on purpose, so that everyone adopting the process knows which decisions stay with a person.

Agents built from this plugin

Who has built one, and how far each one got

Nobody has built one yet. The catalog says so rather than leaving the section off, because an empty list is a fact about the document.

declare it implements: data-quality-check v1 One line in your agent's manifest. The catalog checks it against the records your runs actually leave.
A guess, not a claim

The closest things in the catalog, by description

Nobody above has claimed any of these. This is the nearest match by wording between the job written above and what publishers wrote about their own listings, closest first, and wording is not evidence: some of these will be wrong, and a job with nothing suitable still gets whatever was nearest. The publishers have never heard of this abstract agent and have promised nothing about it. What a claim looks like is in the table above, and it is signed.

Might be reached for

Not workers. These are capability that whatever does the job would use, which is a different relationship and kept in its own column for that reason.

  • Before Users Do MCP server · bhuman-ai.github.io · hosted · mirrored from the MCP registry Browser-backed QA with evidence and fix-ready reports for coding agents.
  • GoldenCheck MCP server · benseverndev-oss.github.io · hosted · run it yourself · mirrored from the MCP registry Auto-discover validation rules from data — scan, profile, health-score. No rules to write.
  • Data Quality Gate - deterministic post-scrape cleaner + verdict MCP server · aidatatools-dev.github.io · hosted · mirrored from the MCP registry Post-scrape data cleaner, no LLM: repairs mojibake, HTML, invisible chars. Plus a verdict.