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

Coverage check

coverage-check v1

Says whether a carve actually covers the market. Reads the map against the account base and names what nobody owns, what sits in two patches, what is too big for the seller behind it and what is too small to live on. It runs again at every point the carve is committed to: before quotas are drafted, before statements reach sellers, and before a system changes hands. It reports the hole and names it by account or by patch. It does not fill the hole.

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.

Runs assessment alone and unattended inside runs the territory-modeler and quota-setter agents own, which is why what it leaves behind is the only way anyone checks it. Its finding is a gate rather than an opinion: nothing publishes while a hole is open, and a failing patch goes back to whoever drew it. Takes the account base from the analytics agent and the account standing from the account-monitor agent.

The plugin

What is in the package

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

Download the package View on GitHub

coverage-check · 10 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 draw territories, set numbers or move accounts, and holds no
write access to the map, the quotas or the CRM on purpose. The agent
that reports a hole should not be the agent that quietly closes it. Does
not judge whether a carve is a good one either, only whether it is whole
and workable against the rules written down before it was drawn.

## What always goes to a person

- an account in no territory, or in two - to the run that drew the map,
  because the map does not publish with one open
- a patch nobody has the capacity to work - to the sales leader, with
  the accounts, the ground and the amount behind the finding
- a patch with no quota, or with two - to the quota-setter agent, before
  any roll-up is stated against the number
- a request no rule in the carve covers - to whoever amends the carve,
  as an amendment rather than a reasoned yes
- a statement that disagrees with the system that will pay on it - to
  sales operations, named by seller, before that seller sees it

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 `coverage-check` leaves the
following behind, on every run.

Per check: every account in no patch and every account in two, named
rather than counted; every patch nobody holds and every seller holding
more than one; every patch over the stated account count or amount and
every patch under the floor, each failure naming the rule it failed.
Reading last period, it names which patches were worked, which were
never called, and what was left with no owner at all. Reading
statements, it names every place a page and the system that will pay on
it disagree, by seller. Reading a move, it quotes the line of the carve
that allows it as written, or records that no line covers it. Every
finding carries the version of the map and the quota set it was tested
against, so an auditor can rerun it.

An agent that leaves less than this does not implement `coverage-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 territory map | read | What the carve says it places. |
| the account record | read | What there is to place. |
| the quota record | read | Whether every patch carries exactly one number. |
| the CRM | read | Who the systems say owns each account. |
| the pay plan record | read | Whether a statement matches what will pay on it. |
| the coverage record | write | The findings, per account and per patch. |

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": "coverage-check",
  "version": "1.0.0",
  "description": "The coverage-check abstract agent. Says whether a carve actually covers the market. Reads the map against the account base and names what nobody owns, what sits in two patches, what is too big for the seller behind it and what is too small to live on.",
  "author": {
    "name": "AgentCatalog",
    "url": "https://agentcatalog.com"
  },
  "homepage": "https://agentcatalog.com/abstract-agents/coverage-check",
  "repository": "https://github.com/jeffrschneider/agentcatalog",
  "license": "CC-BY-4.0",
  "keywords": [
    "abstract-agent",
    "reference",
    "revenue-operations",
    "publish-the-carve",
    "model-the-territories",
    "move-an-account",
    "abstract"
  ],
  "extensions": {
    "com.agentcatalog.agent": {
      "agent": "coverage-check",
      "agentVersion": 1,
      "department": "revenue-operations",
      "abstract": true,
      "works": "Runs assessment alone and unattended inside runs the territory-modeler and quota-setter agents own, which is why what it leaves behind is the only way anyone checks it. Its finding is a gate rather than an opinion: nothing publishes while a hole is open, and a failing patch goes back to whoever drew it. Takes the account base from the analytics agent and the account standing from the account-monitor agent.",
      "servers": [
        {
          "name": "the territory map",
          "role": "territory-map",
          "access": "read",
          "needs": "What the carve says it places."
        },
        {
          "name": "the account record",
          "role": "account-record",
          "access": "read",
          "needs": "What there is to place."
        },
        {
          "name": "the quota record",
          "role": "quota-record",
          "access": "read",
          "needs": "Whether every patch carries exactly one number."
        },
        {
          "name": "the CRM",
          "role": "crm",
          "access": "read",
          "needs": "Who the systems say owns each account."
        },
        {
          "name": "the pay plan record",
          "role": "pay-plan-record",
          "access": "read",
          "needs": "Whether a statement matches what will pay on it."
        },
        {
          "name": "the coverage record",
          "role": "coverage-record",
          "access": "write",
          "needs": "The findings, per account and per patch."
        }
      ],
      "records": [
        "Per check: every account in no patch and every account in two, named rather than counted; every patch nobody holds and every seller holding more than one; every patch over the stated account count or amount and every patch under the floor, each failure naming the rule it failed.",
        "Reading last period, it names which patches were worked, which were never called, and what was left with no owner at all.",
        "Reading statements, it names every place a page and the system that will pay on it disagree, by seller.",
        "Reading a move, it quotes the line of the carve that allows it as written, or records that no line covers it.",
        "Every finding carries the version of the map and the quota set it was tested against, so an auditor can rerun it."
      ],
      "escalates": [
        "an account in no territory, or in two - to the run that drew the map, because the map does not publish with one open",
        "a patch nobody has the capacity to work - to the sales leader, with the accounts, the ground and the amount behind the finding",
        "a patch with no quota, or with two - to the quota-setter agent, before any roll-up is stated against the number",
        "a request no rule in the carve covers - to whoever amends the carve, as an amendment rather than a reasoned yes",
        "a statement that disagrees with the system that will pay on it - to sales operations, named by seller, before that seller sees it"
      ],
      "not": [
        "Does not draw territories, set numbers or move accounts, and holds no write access to the map, the quotas or the CRM on purpose.",
        "The agent that reports a hole should not be the agent that quietly closes it.",
        "Does not judge whether a carve is a good one either, only whether it is whole and workable against the rules written down before it was drawn."
      ],
      "processes": [
        {
          "process": "ref/rev/model-the-territories",
          "activities": [
            "Read How Last Year Was Covered",
            "Check Coverage and Balance"
          ]
        },
        {
          "process": "ref/rev/move-an-account",
          "activities": [
            "Find the Rule That Allows It",
            "Change the Systems Once"
          ]
        },
        {
          "process": "ref/rev/publish-the-carve",
          "activities": [
            "Check the Carve Is Whole",
            "Check the Statements Against the Record",
            "Publish the Final Carve"
          ]
        },
        {
          "process": "ref/rev/set-the-quotas",
          "activities": [
            "Check Every Patch Has One"
          ]
        }
      ]
    }
  }
}

README.mdWhat the package is, and why it carries no mcp.json.

# coverage-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 five 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/model-the-territories`, `ref/rev/move-an-account`,
`ref/rev/publish-the-carve`, `ref/rev/set-the-quotas`. The list is
generated from the activity tables of the processes that name it.

https://agentcatalog.com/abstract-agents/coverage-check

skills/check-a-carve-covers-the-ground/SKILL.mdReads the account base against the map and names what nobody owns, what sits in two patches, what is too big for the seller behind it and what is too small to live on. Use it when running `ref/rev/model-the-territories` and `ref/rev/publish-the-carve`.

---
name: check-a-carve-covers-the-ground
description: Reads the account base against the map and names what nobody owns, what sits in two patches, what is too big for the seller behind it and what is too small to live on. Use it when running `ref/rev/model-the-territories` and `ref/rev/publish-the-carve`.
license: CC-BY-4.0
metadata:
  agent: coverage-check
  agent-version: "1"
---

# Check a carve covers the ground

## What it does

Reads the account base against the map and names what nobody owns, what
sits in two patches, what is too big for the seller behind it and what
is too small to live on. Reads a finished period the same way, naming
the patches that were worked, the ones nobody ever called, and the
accounts left with no owner at all.

## 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 Coverage and Balance**
  - `ref/rev/model-the-territories`, activity 10 -
    [Model the Territories](../../../../processes/revenue-operations/model-the-territories.md)
- **Check the Carve Is Whole**
  - `ref/rev/publish-the-carve`, activity 2 -
    [Publish the Carve](../../../../processes/revenue-operations/publish-the-carve.md)
- **Read How Last Year Was Covered**
  - `ref/rev/model-the-territories`, activity 6 -
    [Model the Territories](../../../../processes/revenue-operations/model-the-territories.md)

## What to record

Per check: every account in no patch and every account in two, named
rather than counted; every patch nobody holds and every seller holding
more than one; every patch over the stated account count or amount and
every patch under the floor, each failure naming the rule it failed.
Reading last period, it names which patches were worked, which were
never called, and what was left with no owner at all. Reading
statements, it names every place a page and the system that will pay on
it disagree, by seller. Reading a move, it quotes the line of the carve
that allows it as written, or records that no line covers it. Every
finding carries the version of the map and the quota set it was tested
against, so an auditor can rerun it.

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/check-a-statement-against-what-will-pay-on-it/SKILL.mdReads a seller's statement against the system that will pay on it and names every place the two disagree, by seller, before that seller sees the page. Use it when running `ref/rev/publish-the-carve`.

---
name: check-a-statement-against-what-will-pay-on-it
description: Reads a seller's statement against the system that will pay on it and names every place the two disagree, by seller, before that seller sees the page. Use it when running `ref/rev/publish-the-carve`.
license: CC-BY-4.0
metadata:
  agent: coverage-check
  agent-version: "1"
---

# Check a statement against what will pay on it

## What it does

Reads a seller's statement against the system that will pay on it and
names every place the two disagree, by seller, before that seller sees
the page.

## Where it happens

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

- **Check the Statements Against the Record**
  - `ref/rev/publish-the-carve`, activity 4 -
    [Publish the Carve](../../../../processes/revenue-operations/publish-the-carve.md)

## What to record

Per check: every account in no patch and every account in two, named
rather than counted; every patch nobody holds and every seller holding
more than one; every patch over the stated account count or amount and
every patch under the floor, each failure naming the rule it failed.
Reading last period, it names which patches were worked, which were
never called, and what was left with no owner at all. Reading
statements, it names every place a page and the system that will pay on
it disagree, by seller. Reading a move, it quotes the line of the carve
that allows it as written, or records that no line covers it. Every
finding carries the version of the map and the quota set it was tested
against, so an auditor can rerun it.

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/check-every-patch-carries-one-number/SKILL.mdSets the quota record against the map and names every patch that carries no number and every patch that carries two. Use it when running `ref/rev/set-the-quotas`.

---
name: check-every-patch-carries-one-number
description: Sets the quota record against the map and names every patch that carries no number and every patch that carries two. Use it when running `ref/rev/set-the-quotas`.
license: CC-BY-4.0
metadata:
  agent: coverage-check
  agent-version: "1"
---

# Check every patch carries one number

## What it does

Sets the quota record against the map and names every patch that carries
no number and every patch that carries two. It runs before anything is
stated against those numbers.

## Where it happens

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

- **Check Every Patch Has One**
  - `ref/rev/set-the-quotas`, activity 10 -
    [Set the Quotas](../../../../processes/revenue-operations/set-the-quotas.md)

## What to record

Per check: every account in no patch and every account in two, named
rather than counted; every patch nobody holds and every seller holding
more than one; every patch over the stated account count or amount and
every patch under the floor, each failure naming the rule it failed.
Reading last period, it names which patches were worked, which were
never called, and what was left with no owner at all. Reading
statements, it names every place a page and the system that will pay on
it disagree, by seller. Reading a move, it quotes the line of the carve
that allows it as written, or records that no line covers it. Every
finding carries the version of the map and the quota set it was tested
against, so an auditor can rerun it.

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/see-a-settled-carve-land-once/SKILL.mdConfirms that what goes into the systems and out to the field is the version that was checked, and that an account moves in one place rather than in several. Use it when running `ref/rev/move-an-account` and `ref/rev/publish-the-carve`.

---
name: see-a-settled-carve-land-once
description: Confirms that what goes into the systems and out to the field is the version that was checked, and that an account moves in one place rather than in several. Use it when running `ref/rev/move-an-account` and `ref/rev/publish-the-carve`.
license: CC-BY-4.0
metadata:
  agent: coverage-check
  agent-version: "1"
---

# See a settled carve land once

## What it does

Confirms that what goes into the systems and out to the field is the
version that was checked, and that an account moves in one place rather
than in several. Nothing publishes while a hole is still open.

## Where it happens

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

- **Change the Systems Once**
  - `ref/rev/move-an-account`, activity 10 -
    [Move an Account](../../../../processes/revenue-operations/move-an-account.md)
- **Publish the Final Carve**
  - `ref/rev/publish-the-carve`, activity 13 -
    [Publish the Carve](../../../../processes/revenue-operations/publish-the-carve.md)

## What to record

Per check: every account in no patch and every account in two, named
rather than counted; every patch nobody holds and every seller holding
more than one; every patch over the stated account count or amount and
every patch under the floor, each failure naming the rule it failed.
Reading last period, it names which patches were worked, which were
never called, and what was left with no owner at all. Reading
statements, it names every place a page and the system that will pay on
it disagree, by seller. Reading a move, it quotes the line of the carve
that allows it as written, or records that no line covers it. Every
finding carries the version of the map and the quota set it was tested
against, so an auditor can rerun it.

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/test-a-move-against-the-written-carve/SKILL.mdReads a request to move an account and quotes the line of the carve that allows it as written, or records that no line covers it. Use it when running `ref/rev/move-an-account`.

---
name: test-a-move-against-the-written-carve
description: Reads a request to move an account and quotes the line of the carve that allows it as written, or records that no line covers it. Use it when running `ref/rev/move-an-account`.
license: CC-BY-4.0
metadata:
  agent: coverage-check
  agent-version: "1"
---

# Test a move against the written carve

## What it does

Reads a request to move an account and quotes the line of the carve that
allows it as written, or records that no line covers it. It does not
reason its way to a yes.

## Where it happens

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

- **Find the Rule That Allows It**
  - `ref/rev/move-an-account`, activity 3 -
    [Move an Account](../../../../processes/revenue-operations/move-an-account.md)

## What to record

Per check: every account in no patch and every account in two, named
rather than counted; every patch nobody holds and every seller holding
more than one; every patch over the stated account count or amount and
every patch under the floor, each failure naming the rule it failed.
Reading last period, it names which patches were worked, which were
never called, and what was left with no owner at all. Reading
statements, it names every place a page and the system that will pay on
it disagree, by seller. Reading a move, it quotes the line of the carve
that allows it as written, or records that no line covers it. Every
finding carries the version of the map and the quota set it was tested
against, so an auditor can rerun it.

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.

territory-map · readaccount-record · readquota-record · readcrm · readpay-plan-record · readcoverage-record · write

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": {
    "territory-map": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/territory-map"
    },
    "account-record": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/account-record"
    },
    "quota-record": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/quota-record"
    },
    "crm": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/crm"
    },
    "pay-plan-record": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/pay-plan-record"
    },
    "coverage-record": {
      "type": "streamable-http",
      "url": "https://mcp.yourcompany.com/coverage-record"
    }
  }
}

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, 8 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.

Model the Territoriesref/rev/model-the-territories · 15 activities

Read How Last Year Was Covered · Check Coverage and Balance

Move an Accountref/rev/move-an-account · 14 activities

Find the Rule That Allows It · Change the Systems Once

Publish the Carveref/rev/publish-the-carve · 15 activities

Check the Carve Is Whole · Check the Statements Against the Record · Publish the Final Carve

Set the Quotasref/rev/set-the-quotas · 15 activities

Check Every Patch Has One

The records it leaves

What it writes down

Per check: every account in no patch and every account in two, named rather than counted; every patch nobody holds and every seller holding more than one; every patch over the stated account count or amount and every patch under the floor, each failure naming the rule it failed. Reading last period, it names which patches were worked, which were never called, and what was left with no owner at all. Reading statements, it names every place a page and the system that will pay on it disagree, by seller. Reading a move, it quotes the line of the carve that allows it as written, or records that no line covers it. Every finding carries the version of the map and the quota set it was tested against, so an auditor can rerun it.

Where it stops

What it will not do

Does not draw territories, set numbers or move accounts, and holds no write access to the map, the quotas or the CRM on purpose. The agent that reports a hole should not be the agent that quietly closes it. Does not judge whether a carve is a good one either, only whether it is whole and workable against the rules written down before it was drawn.

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: coverage-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.

ShipCheck MCP server · wtaylorwilson.github.io · hosted · mirrored from the MCP registry Independent preview-URL QA for coding agents. Playwright heuristics, pass/fail pack.
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.
mcp MCP server · n0brains.com · hosted · mirrored from the MCP registry Self-routing market intel for agents: A-F trade checks, one-call briefs, real liq maps, proof board.