Free CGBB membership and a signed trust.json for brands; verify any brand's CGBB record.
Scored across 6 tools
Most tools target distinct steps in the CGBB membership lifecycle: learning about CGBB, applying, checking domain verification, checking application status, retrieving the trust file, and verifying a brand. The closest overlap is between check_domain_verification and get_application_status, and between verify_brand and get_trust_file, but their descriptions provide enough distinction.
The tools use consistent snake_case and mostly follow a clear verb_noun or verb_object pattern: apply_for_membership, check_domain_verification, get_application_status, get_trust_file, verify_brand. The only notable deviation is about_cgbb, which is informational rather than action-oriented, but this is minor.
Six tools are well-scoped for a focused membership and trust-verification workflow. Each tool corresponds to a meaningful step, and there is no obvious redundancy or missing bulk operation that would justify more tools.
The tool set covers the core lifecycle from learning about CGBB and applying for membership through domain verification, status checking, trust file retrieval, and external brand verification. Minor gaps exist around updating or revoking membership details and listing applications, but core workflows are covered.
What CGBB is, what the free CGBB Member trust.json contains, and how an AI agent can apply for a brand.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already tells the agent this is a safe read with no side effects, so the bar is lower. The description adds that the content is explanatory (definition, trust.json contents, application steps) but says nothing about the shape or length of the informational response.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with no filler, and the content scope is front-loaded. It loses a point only for being a sentence fragment rather than a declarative statement of what the tool does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only tool the description covers the essentials, but with no output schema an agent still cannot tell what it will actually receive (prose, JSON, or a payload) or how long it is. Marginal but real gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Parameter count is 0, which is the baseline-4 case: there is nothing for the description to disambiguate and no arguments to get wrong.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description enumerates the exact topics this tool answers – what CGBB is, what the free trust.json contains, and how to apply. That scope is specific enough to distinguish it as an informational/discovery tool, though it is written as a noun phrase rather than a verb+resource statement and never names the sibling tools it is not (get_trust_file, apply_for_membership).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use or when-not-to-use guidance. The phrase 'how an AI agent can apply for a brand' could easily be misread as the action tool, when apply_for_membership is the actual sibling for that, so the boundary is not drawn anywhere.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Apply for free CGBB membership on behalf of a brand. Returns an application_id, a domain-verification token and next steps. A real person at the brand (contact_email) must confirm by email; the CGBB Secretariat then reviews it.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | ||
| about | No | Short introduction to the brand (max 1200 characters) | |
| domain | Yes | The brand’s own website domain, e.g. brand.com | |
| country | No | ||
| markets | No | Primary markets | |
| category | No | organizational | |
| job_title | No | ||
| agent_name | No | Name of the AI agent or tool making the application | |
| contact_name | Yes | ||
| organisation | Yes | Legal or brand name of the organisation | |
| contact_email | Yes | A real person at the brand who will confirm by email |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only say it is a non-destructive, open-world write; the description adds real behavioral value by disclosing the human email-confirmation requirement, the Secretariat review gate, and the returned identifiers. It stops short of covering idempotency or what happens if the domain is already registered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, no filler, and the action plus return values are front-loaded before the confirmation workflow.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 11-parameter mutation with no output schema, the description covers the outcome (application_id, verification token, next steps) and the post-call process, which is what an agent most needs. Remaining gaps are edge-case behavior such as duplicate applications or what to do if email confirmation never occurs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 55%, so the schema documents roughly half the inputs. The description reinforces the most consequential one ('contact_email must be a real person at the brand who confirms by email') and the brand scope behind organisation/domain, but says nothing about agent_name, lang, category, country, markets or job_title. Baseline 3 fits.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource with scope: 'Apply for free CGBB membership on behalf of a brand', and names the artifacts produced (application_id, domain-verification token, next steps). Differentiation from siblings like get_application_status is implicit via the described workflow rather than stated explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The eligibility context ('a real person at the brand must confirm by email') and the Secretariat review step imply when this tool applies, but there is no explicit when-to-use/when-not guidance and no named alternative (e.g., checking an existing application first).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
After publishing the token (DNS TXT record or /.well-known/cgbb-verification.txt), check it. Returns the updated application status.
| Name | Required | Description | Default |
|---|---|---|---|
| application_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already disclose readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description adds the prerequisite and notes that it returns the updated application status, but it does not explain side effects, authorization needs, or rate limits beyond that.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the prerequisite front-loaded and the return behavior stated last. Every sentence contributes useful information without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter verification-check tool, the description covers the trigger and a brief return summary. However, it omits any explanation of application_id and gives no failure or pending-state context, leaving a gap against the 0% schema coverage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should explain the single parameter, but it never mentions application_id. The property name is fairly self-explanatory, which keeps this from being a total failure, but there is no added meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action (check the published verification token) and the resource (DNS TXT record or /.well-known/cgbb-verification.txt), making the purpose clear. It does not explicitly contrast with the sibling get_application_status, but the prerequisite and token focus still distinguish it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear timing guidance: use this after publishing the token via DNS TXT or the well-known file. It does not name alternatives or state when not to use it, but the prerequisite is explicit enough for correct invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Status and next steps for an application.
| Name | Required | Description | Default |
|---|---|---|---|
| application_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes that this is a safe read operation. The description adds that the response includes status and next steps, but it does not cover error behavior, permissions, or return shape in detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no wasted words and is front-loaded with the key purpose. It is perhaps too terse, but it is structurally efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only lookup, the annotation covers safety and the description broadly indicates the return content. However, with no output schema and no parameter explanation, an agent lacks details on inputs and response structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the single required parameter application_id is not explained in the description. The agent can infer it identifies an application, but nothing about format, source, or constraints is added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource and the information returned: status and next steps for an application. It is clear what the tool does, but it does not explicitly distinguish it from siblings such as apply_for_membership or check_domain_verification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives. The phrase 'for an application' weakly implies post-application lookup, but no conditions, prerequisites, or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the signed CGBB Member trust.json for an approved domain, ready to publish at https:///.well-known/trust.json.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already tells the agent this is a safe read, so the description mainly adds that the returned artifact is signed and intended for publication at a specific well-known path. It does not disclose what happens for an unapproved or unverified domain (error vs. empty result), nor any auth requirements, which are the gaps an agent would actually hit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence with no filler, and the core action plus the publication context are front-loaded. Nothing in it is redundant with the title or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read tool with no output schema and only a readOnlyHint annotation, the description covers the what and where but is thin on failure modes, auth, and what 'signed' entails for the caller. Adequate to invoke correctly in the happy path, incomplete for edge cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for the single `domain` parameter, so the description must compensate. It does add meaning—the domain is the approved brand domain and appears in the resulting https://<domain>/.well-known/trust.json URL—but it never states format expectations (bare host vs. full URL) which matters for a 0%-coverage string param.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Uses a specific verb (Get) and a specific resource (signed CGBB Member trust.json) scoped to an approved domain, which is far more precise than the title alone. It does not explicitly distinguish itself from siblings like verify_brand or check_domain_verification, so an agent must infer that this one fetches an artifact rather than performing verification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for an approved domain' implies a precondition (domain must already be approved/verified), which is a useful usage hint. However, there is no explicit when-to-use, when-not-to-use, or routing to alternatives such as verify_brand when the domain is not yet approved.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check the live CGBB record for a domain, and whether a genuine trust.json is published on that website.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds crucial behavioral context by detailing the two specific aspects of the verification process—the database record status and the physical file existence on the live website. This adds necessary detail beyond the safety guarantees provided by the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and structured as a single direct sentence that front-loads the full functionality of the tool without any fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of an output schema, the description successfully defines the complete scope of the verification (CGBB record status + trust.json presence). This provides enough context for the agent to know exactly what outcome to expect based on the input domain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Since the schema description coverage is 0%, the description must define the function of the single 'domain' parameter. It does so clearly by linking the domain to the verification target. However, as there are no other parameters, it doesn't add information beyond defining the scope of the tool's action, placing it at the baseline score for low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states that the tool performs a dual check: verifying the live CGBB record and checking for the publication of the trust.json file. This is more specific than a general verification tool and clearly differentiates itself from siblings like get_trust_file or check_domain_verification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the description defines the scope, it does not explicitly state the conditions under which this tool should be prioritized over others. It is clear what it does, but guidance on when *not* to use it is absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
about_cgbbapply_for_membershipcheck_domain_verificationget_application_statusget_trust_fileverify_brandFree C2PA 2.4 triage and reproducible official trust snapshot. No media, keys, or payment.
Verified brand claims with receipts for agent commerce. Ranking is never paid; the engine is open.
Machine-Readable Company Profiles: find, search and read any company's Trust Profile, fact by fact.
Search and verify 360K+ business entities with trust scores and W3C credentials.
Add one secure layer between your agents and this server.
