Council of AI GSPC

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With annotations present (readOnlyHint=false, openWorldHint=true), the description goes well beyond them: it discloses the paid x402 flow, the 402 challenge behavior, the point-in-time/caveat semantics (NOT_DETECTED != unmarked, metadata often stripped), the C2PA membership disclosure, and the explicit refusal to render conformity/compliance opinions.

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?

Dense but front-loaded, leading with PAID and the core detection claim before scope, caveats and payment mechanics. Most sentences carry distinct weight, though the run-on structure and repetition of the payment/preview point cost it a top score.

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?

An output schema exists, so return values need not be explained. The description covers the remaining burden for a paid, network-fetching, point-in-time measurement tool: scope limits, failure modes, payment handshake and evidentiary caveats are all present.

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 100% with zero required parameters, so the schema already documents url, preview, bytes_b64, x_payment and manifest_b64. The description reinforces the payment semantics (x_payment omission yields the challenge; preview is free/unsigned) but adds no syntax or format detail beyond the 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?

Names a specific verb (measure/detect) and resource (Article 50 marking-evidence pack) and immediately bounds the scope: 'which machine-readable marks the named methods DETECT in these bytes right now. Scope: C2PA and IPTC metadata only.' It explicitly excludes watermark/fingerprint marks, so an agent can tell it apart from other evidence tools.

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?

Gives clear operating conditions: preview=true is free and unsigned, omitting x_payment returns the 402 challenge, and an undeployed route returns NOT_DEPLOYED. It does not, however, explicitly route the agent among siblings such as evidence_bundle, rwa_evidence, or server_evidence.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds genuinely useful semantics on top: an unmeasured axis is a first-class answer, published deliberately so the gap is visible, never an error and never a zero — and explicitly not a certification. That is exactly the kind of interpretive context annotations cannot carry.

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 resource identity is front-loaded, which is good, but the opening is one long comma-spliced sentence enumerating returned fields, and the disclaimer tail ('never an error and never a zero. Never a certification.') is fragmented. Every clause earns its place, but the structure could be considerably tighter.

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?

An output schema exists, yet the description still spends most of its length listing return fields rather than explains when to pick this axis over its siblings or what the affect axis is for. The interpretive rule about unmeasured rows is valuable, but routing information is entirely absent for a tool embedded in a 40-tool family.

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?

Zero parameters, so the baseline is 4. The description reinforces this by stating the tool 'takes no argument', which prevents any attempt to pass a filter or axis id, though it could have added a word about how to target a specific run or date.

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 precisely ("the affect axis of the live GSPC board") and distinguishes it from the many axis_* siblings by which axis it is. But it never explains what the 'affect' axis measures, so an agent can tell which tool this is, not what concept it represents or how it relates to get_axis / get_card.

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 statement of when to call this versus get_axis, get_card, board_totals, or the forty-odd other axis_* tools. The only selection cue is the axis name itself, which an agent must already understand to choose correctly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavior beyond those annotations: an unmeasured axis is 'a first-class answer... never an error and never a zero,' and 'Never a certification.' This clarifies the critical edge case and semantic boundary.

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 front-loaded with the purpose, and the unmeasured/certification sentences earn their place. However, the long first sentence enumerates output fields (n, accuracy, interval, status, family, kind, URL, dates) that are already available in the output schema, making it bloated for an agent that can inspect structured data.

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, no-parameter, read-only retrieval with rich annotations and an output schema, the description is nearly complete. The unmeasured-case semantics and certification disclaimer add crucial context. The only notable gap is the lack of sibling routing (e.g., get_axis), which could matter when an agent needs an arbitrary axis.

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?

There are zero parameters, so the baseline is 4. The description explicitly reinforces this: 'takes no argument,' which is consistent with the empty input schema and additionalProperties=false.

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 the specific resource (ai-adoption-components axis) and that it is a fixed, no-argument endpoint on the live GSPC board. The name and description make the tool's identity clear. However, it does not explicitly differentiate this from the sibling get_axis or other axis_* tools, leaving the agent to infer the distinction from the tool name alone.

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 'this tool IS the axis, so it takes no argument' implies usage for this specific axis, but there is no explicit guidance on when to use this versus get_axis (which likely accepts an axis parameter) or board_totals. The alternative is not named, so the agent must infer the routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds important behavioral context: an unmeasured axis is a first-class answer (not an error or zero), the gap is published visibly, and the result is 'never a certification.' These are meaningful traits beyond 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 front-loads the resource and URL, then explains the no-argument nature and returned fields, followed by behavioral notes. It is a single paragraph with dashes and is reasonably efficient, though slightly dense and could be structured more clearly.

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 tool's simplicity (read-only, no parameters) and the presence of an output schema, the description covers what is needed: it identifies the axis, lists the fields, and explains the unmeasured-status behavior. It does not detail how to interpret the returned measures, but the output schema likely handles 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?

The tool takes no parameters, so there is nothing to document. The description redundantly states it 'takes no argument,' which is harmless but adds no value over the empty schema. Baseline 4 is appropriate for a zero-parameter tool.

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 identifies the resource as 'the art5-safeguard axis of the live GSPC board' and lists the data fields it exposes, but it does not use a clear action verb (e.g., 'return' or 'fetch') and does not distinguish this tool from the sibling get_axis or other axis_* tools. The agent can infer it retrieves axis data, but the purpose is not crisply stated.

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 description offers no guidance on when to use this tool versus alternatives like get_axis, board_totals, or other axis endpoints. It explains that the tool 'takes no argument' but says nothing about choosing this specific axis or the conditions under which it should be called.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

It goes beyond annotations by detailing the nature of the data, specifically that an 'unmeasured axis' is a first-class, valid state ('never an error and never a zero'), which is critical behavioral context.

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 dense, but highly effective. The information is front-loaded with the identity of the tool and is structured to explain complex concepts (unmeasured status) logically.

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?

The definition is extremely complete for a complex, zero-parameter tool. It defines not only what the tool is but also the philosophical implications of its output (e.g., gap visibility vs. error state), providing comprehensive operational context.

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?

Despite the input schema being empty, the description explicitly lists seven potential filters (e.g., 'accuracy,' 'family,' 'dates'). This explains the 'semantics' of the data structure even if the tool doesn't currently support them, greatly aiding agent understanding.

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 represents 'the care axis' of the live GSPC board, clearly defining the resource and its function.

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?

Since the tool takes no arguments, usage guidance centers on what the tool *is* (the axis) and doesn't require external parameters to function. It clearly defines the unique nature of its output.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint), so the description earns credit for adding semantics beyond them: an unmeasured axis is 'a declared slot with no run behind it, published so the gap is visible — never an error and never a zero.' That is genuinely non-obvious behavior an agent would otherwise misread as failure or as a null metric, and 'Never a certification' bounds interpretation. It stops short of describing pagination, freshness, or failure modes for the live HTTP endpoint.

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 sentences, front-loaded with the identity and the no-argument guarantee before the interpretation rules. Every clause carries information — the field list, the URL, the unmeasured semantics, the certification caveat — with no filler or restatement of the title.

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?

With an output schema present, the description need not explain return values, yet it still sketches the row shape, which helps the agent decide whether to call. For a zero-param read-only tool this is nearly complete; the only omission is what an agent should do next when the axis is unmeasured or how this differs from get_axis.

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?

Zero parameters, so the baseline is 4; the description reinforces this by explicitly stating the tool takes no argument, which prevents an agent from inventing an axis-name argument. No further parameter detail is possible.

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 specific resource (the claim-maintenance axis of the live GSPC board at a concrete URL) and enumerates exactly what a row carries: n, accuracy, interval, status, family, kind, artifact URL, dates. That is far more than a restatement of the name. It does not, however, contrast itself with the many sibling axis_* tools or with get_axis, so an agent cannot tell from this text alone which of the two to reach for when it wants 'the claim-maintenance axis'.

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?

Usage is implied rather than stated: 'this tool IS the axis, so it takes no argument' tells the agent this is the zero-argument direct fetch, and the unmeasured-axis paragraph tells it how to interpret a gap result. There is no explicit when-to-use/when-not, no mention of get_axis, measurement_index, or any sibling as an alternative, and no statement of what to do if the agent actually wants a different axis.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, non-destructive and open-world, so the safety profile is done. The description adds genuinely non-structured behavior: missing measurements are published as declared gaps rather than errors or zeros, and the output is explicitly not a certification. That pre-empts two plausible agent misinterpretations. It stops short of saying whether rows are paginated or how staleness is signalled.

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?

Front-loaded with the identity of the axis, then the no-argument fact, then the field inventory, then the two interpretive caveats. Every sentence carries content and nothing repeats the schema. The field enumeration is dense but scannable; the final two-sentence caveat block is slightly long relative to the first.

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-argument, read-only tool with an output schema and full annotation coverage, this is close to complete: the agent knows what the axis is, that it needs no input, what a row contains, and how to treat missing data. The one thing left unstated is the relationship to the aggregate and retrieval siblings (board_totals, get_axis), which would help an agent sequence calls.

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?

Zero parameters, which sets a baseline of 4, and the description reinforces it by stating outright that the tool takes no argument. The field list it gives is about the returned row, not inputs, so it neither helps nor hurts input semantics. No gap to compensate for.

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?

Names a specific resource: the company-practice axis of the live GSPC board, and enumerates the fields the row carries (n, accuracy, interval, status, family, kind, source URL, dates). Against ~35 sibling axis_* tools, the qualifier 'company-practice' is what distinguishes it, and 'this tool IS the axis, so it takes no argument' removes ambiguity about scope. It does not explicitly contrast with get_axis or board_totals, which keeps it short of a 5.

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?

No explicit statement of when to choose this over get_axis, board_totals, or the other axis_* siblings; the name is the only routing signal. What it does supply is interpretive guidance: an unmeasured axis is a first-class answer, not an error and not a zero, which tells the agent how to read the result. That is usage-adjacent, but it never names an alternative or a condition for exclusion.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, open-world, non-destructive, so the safety bar is covered. The description adds non-obvious semantics beyond them: it takes no argument, an unmeasured axis is a declared slot rather than an error or a zero, and the output is explicitly 'never a certification' — all of which prevent misreading of empty results.

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 no-argument constraint and the unmeasured-axis rule are front-loaded and earn their place, but the mid-sentence catalogue of fields (n, accuracy, interval, family, kind, URL, dates) is an unstructured list that duplicates the output schema. The closing 'Never a certification' is terse to the point of being cryptic out of context.

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?

An output schema exists, so return shape need not be explained, and the read-only/open-world annotations cover the safety profile; the description supplies the one semantic an agent could not infer, namely how to treat a measured-less axis. What is missing is routing guidance relative to the many sibling axis tools.

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?

With zero parameters and 100% schema coverage, the baseline is 4. The description reinforces this by stating the tool 'takes no argument' and by explaining that the axis identity/dimensions come back in the response rather than as inputs.

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 identifies the resource ('the conformance axis of the live GSPC board') and enumerates the row fields it carries, but the operative verb is only 'this tool IS the axis', which is descriptive rather than action-oriented. It does not distinguish itself from near-identical siblings like axis_interop-conformance or get_axis.

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 statement of when to call this versus get_axis, measurement_index, or the other axis_* tools; the reader must infer that it retrieves one specific axis row. The 'unmeasured is a first-class answer' note is about interpreting output, not about selecting this tool over alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/openWorld/non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: an unmeasured axis is a declared slot with no run behind it, is 'never an error and never a zero', and results are 'never a certification'. That materially shapes how an agent should interpret empty-looking output.

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?

Front-loaded with the resource identity, but the phrase 'takes no argument: n, accuracy, interval, ...' is structurally confusing — it reads as if those were arguments before it becomes clear they are returned fields. The field enumeration duplicates what the output schema already provides.

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?

An output schema exists, so return fields needn't be spelled out, and annotations cover safety. What remains missing is the meaning of 'continuity' as a measured dimension and how this axis relates to the sibling axis tools and board_totals — the agent still cannot reason about when this axis is the right one.

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?

Zero parameters, so the baseline is 4. The description correctly reinforces that no arguments are accepted, which is consistent with the empty schema with additionalProperties=false.

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?

It names a specific resource ('the continuity axis of the live GSPC board') and gives its source URL, so the agent knows it is fetching one axis of one board. But 'axis' and 'continuity' are unexplained jargon, and with 30+ sibling axis_* tools the description never says what distinguishes continuity from affect, safety, provenance, etc. The 'this tool IS the axis' framing partly restates the name.

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 only usage guidance is negative ('takes no argument'). It never says when to reach for this versus get_axis, board_totals, measurement_index, or get_card, all of which appear to surface overlapping board data. The one useful rule — an UNMEASURED axis is a valid answer — is semantic, not routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description adds non-obvious behavioral semantics beyond the annotations: unmeasured axes are published as declared slots with visible gaps, are never errors and never coerced to zero, and the output is 'never a certification' — meaningful interpretive context for an agent reading results.

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?

It is a single dense block that front-loads the resource and URL, and every clause roughly earns its place, but 'this tool IS the axis' is conceptually cute and the enumeration of return fields (n, accuracy, interval, family, kind, URL, dates) is partly redundant with the existing output schema. Readability suffers from the run-on structure.

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?

With annotations covering safety, an output schema covering return shape, and zero params, the description's remaining burden is interpretive semantics — which it supplies via the unmeasured-as-first-class-answer and 'never a certification' caveats. Only the failure to position itself against sibling axes keeps it from a 5.

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?

The tool takes zero parameters, so the baseline is 4. The description also clarifies why ('takes no argument'), which correctly sets the expectation that no filtering or identification argument is needed.

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 identifies a specific resource (the cross-reality axis of the live GSPC board) and enumerates the row fields it surfaces, but never states a clear verb like 'returns' or 'reads' — 'this tool IS the axis' is a conceptual framing rather than an action. With ~30 sibling axis_* tools plus get_axis, it offers no differentiation about what makes 'cross-reality' distinct from the others beyond the name.

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 explains how to interpret an unmeasured result (first-class answer, never an error or zero), which is genuinely useful usage context, but it gives no guidance on when to call this versus get_axis, board_totals, or any other axis tool. There are no exclusions or alternatives named despite a dense sibling set.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, non-destructive and open-world traits, so the bar is lower; the description still adds real value by declaring that an UNMEASURED axis is a first-class published answer, 'never an error and never a zero,' which prevents an agent from treating a gap as failure. It also states it is 'never a certification,' a meaningful scope disclaimer. It does not mention auth, rate limits, or payload size.

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?

Identity and the no-argument rule are front-loaded, followed by the field enumeration and the unmeasured semantics. The long em-dash construction with the field list is dense but every clause carries information; the 'never a certification' disclaimer earns its place as a scope boundary.

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?

With zero parameters, an output schema present, and full annotation coverage, the description supplies everything needed: where the data lives (the board URL), what an unmeasured row means, and the non-certification caveat. The only gap is the absence of any pointer to sibling tools (get_axis, board_totals) that an agent might reasonably consider first.

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?

The tool takes zero parameters, which is the baseline-4 case. The description reinforces this by stating it takes no argument, exceeding what the empty schema communicates on its own.

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 a specific resource (the custody-disclosure axis of the live GSPC board) and enumerates the fields it exposes (n, accuracy, interval, MEASURED/UNMEASURED status, family, kind, artifact URL, dates), which effectively identifies it as a single-axis read tool. The resource name distinguishes it from the many sibling axis_* tools. The odd phrasing 'this tool IS the axis' obscures the verb slightly, and it never mentions get_axis, the obvious generic sibling.

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?

'This tool IS the axis, so it takes no argument' tells the agent it can be called with empty input, and the unmeasured-axis clause gives interpretation guidance. But there is no explicit when-to-use rule and no routing versus alternatives such as get_axis, board_totals, or other axis_* tools. Usage is only implied by the resource identity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, so the burden is light, but the description adds genuine semantics beyond them: an unmeasured axis is a first-class declared slot, never an error and never a zero. That is exactly the kind of behavior an agent would otherwise mis-handle (treating empty data as failure). The 'never a certification' disclaimer further sets expectations on the payload's authority.

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 front-loaded sentence establishes the resource and the no-argument contract, followed by the field list and then the unmeasured semantics. The field enumeration is dense but every clause carries information; nothing is padded.

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?

An output schema exists, so the description need not explain return shape, and it covers the one behavioral edge case (declared-but-unmeasured) that a schema cannot express. The remaining gap — how this axis relates to the get_axis sibling — is the only thing an agent is left guessing about.

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?

Zero parameters, so the baseline is 4. The description reinforces this by stating the tool IS the axis and takes no argument, which prevents an agent from inventing filter parameters such as an axis name.

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 specific resource — the detector-interop axis of the live GSPC board at a concrete URL — and enumerates the row contents (n, accuracy, interval, status, family, kind, artifact URL, dates), so an agent knows exactly what comes back. It lacks an explicit verb and never distinguishes itself from the sibling get_axis, so a reader must infer whether this is a fetch of one axis vs. a generic axis getter.

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 statement of when to call this versus get_axis, axis_interop-conformance, or measurement_index, all of which sit in the sibling list and plausibly overlap. The only usage-shaped information is the negative constraint 'takes no argument', which tells the agent nothing about selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only/idempotent/non-destructive, so the bar is lower. The description adds real behavioral context beyond them: unmeasured slots are first-class and published rather than raised as errors, values are never zero-filled, and the result is explicitly 'never a certification'. What is missing is any note on whether output is a snapshot or live-refreshed.

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?

Identity and URL are front-loaded and the field enumeration is compressed into one list; the em-dash clause carries the important unmeasured-is-not-an-error rule. Slightly dense and comma-chained, but nothing is wasted.

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?

An output schema exists, so the enumerated return fields are somewhat redundant and the description needn't explain return shape. The more important gap is relational: among ~30 sibling axis tools plus `get_axis`, the description does not establish why an agent should pick this one directly rather than through the generic axis accessor.

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?

Zero parameters, so the baseline is 4. The description reinforces this by stating explicitly 'this tool IS the axis, so it takes no argument', which removes any doubt an agent might have about needing to pass an axis identifier.

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?

Names a specific resource (the distribution-integrity axis of the live GSPC board), gives its base URL, and enumerates the returned fields (n, accuracy, interval, MEASURED/UNMEASURED, family, kind, artifact URL, dates). It is clear what an agent gets back, though the distinction from the sibling `get_axis` tool is left implicit.

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?

States the tool takes no argument and that an unmeasured axis is a valid answer, which is useful invocation context. However, it never says when to call this axis tool versus `get_axis`, `board_totals`, or `measurement_index`, and no alternatives or exclusions are named.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds non-obvious semantics that structured fields cannot: an unmeasured axis is a first-class published answer, never an error and never a zero, and the output is never a certification. That is real behavioral context an agent would otherwise mis-handle.

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?

Front-loaded with the identity and URL, then the field list, then the unmeasured rule. Dense but every clause earns its place except the mild redundancy of listing return fields when an output schema already exists.

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?

Output schema exists, so return values needn't be described, yet the field list is harmless framing. Annotations cover safety. The one gap is the absence of routing guidance among the many sibling axis tools, which leaves selection partly on naming convention.

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?

Zero parameters, which is the baseline 4. The description explicitly confirms 'it takes no argument', removing any doubt an agent might have about needing to supply an axis id.

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?

Identifies itself precisely as the effect-binding axis of the live GSPC board and enumerates the fields a row carries (n, accuracy, interval, status, family, kind, URL, dates). Sibling axes follow the same naming pattern, so the title alone disambiguates; the description reinforces it but doesn't explain how this differs from get_axis or measurement_index.

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?

No statement of when to fetch this axis versus the sibling get_axis or measurement_index endpoints, and no prerequisites or exclusions. The only guidance is internal semantics of the unmeasured case, which is about interpreting the result, not choosing the tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely non-obvious semantics beyond them: an UNMEASURED axis is a first-class published answer, never an error and never a zero — which changes how an agent should interpret and report the result. 'Never a certification' is a useful but unexplained caveat.

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?

Front-loading the identity of the axis is good, but 'this tool IS the axis' is puzzling filler, and the long em-dash enumeration of output fields largely duplicates what the output schema already provides. It is not padded, but it is denser and less cleanly structured than it needs to be.

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?

With a rich annotation set, a zero-argument schema and an output schema that carries the return shape, the description covers the remaining gaps: what the row represents and how to read an UNMEASURED slot. Only the relationship to get_axis and the other axis tools is left unaddressed.

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?

Zero parameters, so the baseline is 4; the description correctly reinforces this with 'it takes no argument', removing any temptation to pass filters. No further parameter meaning is needed.

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 identifies the resource precisely — the governance axis of the live GSPC board at councilof.ai/api/gspc — and enumerates the row fields (n, accuracy, interval, MEASURED/UNMEASURED status, family, kind, artifact URL, dates), so an agent knows what it gets back. The verb is only implied (never says 'returns' or 'reads'), and nothing distinguishes it from get_axis or the many axis_* siblings beyond the name itself.

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 guidance: no statement of why an agent would call axis_governance rather than get_axis, board_totals, or a neighbouring axis_* tool. The 'takes no argument' remark is about mechanics, not selection, so the agent must infer routing from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint), so the bar is lower. The description adds genuinely useful semantics beyond that: an unmeasured axis is a declared slot with no run, never an error and never a zero, and never a certification. That is real behavioral context about what a returned row means, though nothing about freshness, caching, or rate limits.

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?

Front-loaded with the identity of the axis, then the field enumeration, then the unmeasured-state caveat. The closing 'never an error and never a zero. Never a certification.' is terse and purposeful rather than padded.

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?

An output schema exists, so the field enumeration is partly redundant, but the description still supplies the source URL for the live board and the crucial semantics of an UNMEASURED row, which a schema alone would not convey. Adequate for a zero-parameter read tool.

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?

Zero parameters, so the baseline applies; the description correctly explains that no argument is taken because the tool is bound to a single fixed axis. Nothing left to document.

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 specific resource (the harness-fidelity axis of the live GSPC board) and enumerates what the row contains (n, accuracy, interval, status, family, kind, URL, dates), which distinguishes it from the many sibling axis_* tools by domain rather than by a verb. The operation itself is only implied ('this tool IS the axis'), so the agent must infer that it reads one axis record.

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 statement of when to use this tool versus get_axis, axis_serving-fidelity, or the other axis siblings — the reader must infer from the name alone. The only procedural guidance is 'it takes no argument', which is about invocation, not selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open-world), so the description adds semantics beyond them: an unmeasured axis is a declared slot with no run behind it, 'never an error and never a zero,' and the result is 'never a certification.' That prevents concrete misreadings of the payload. It does not mention rate limits, caching, or freshness beyond 'live'.

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?

Front-loaded with identity and scope, then the field inventory, then the interpretation caveat. Dense but every clause carries information; the only redundancy is restating the axis/title phrasing twice in the opening sentence.

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?

An output schema exists, so return values need not be explained, and the description is adequate for calling the tool. What it omits is the sibling landscape: with ~35 axis_* tools plus get_axis, the agent has no basis for choosing this one over axis_humanoid-labour-index or the generic axis reader.

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?

Zero parameters, so the baseline is 4. The description is consistent with the empty schema, explicitly saying the tool takes no argument, which reinforces that the agent should not invent filters.

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 resource — 'the humanoid-deployment axis of the live GSPC board' — and enumerates what the axis carries (n, accuracy, interval, MEASURED/UNMEASURED status, family, kind, artifact URL, dates). It also clarifies the tool is the axis itself rather than a lookup, which implicitly separates it from argument-taking readers. However, it never distinguishes itself from the very similar sibling axis_humanoid-labour-index or from get_axis, so an agent must guess which of the near-identical names to pick.

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?

'This tool IS the axis, so it takes no argument' conveys usage implicitly: call it directly to read this axis. The unmeasured-is-a-first-class-answer sentence also warns against treating a gap as failure. But there is no explicit when-to-use/when-not guidance versus get_axis or axis_humanoid-labour-index, so routing between siblings is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the description's job is semantic context — and it delivers: no arguments are taken, an UNMEASURED axis is a declared gap rather than an error or a zero, and the output is never a certification. These are non-obvious behavioural facts an agent could not infer from the schema. It stops short of noting the canonical board URL's freshness or access characteristics.

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 front-loaded sentence establishes identity and the no-argument constraint, followed by the payload list and two short caveats. Nothing is padded, but the middle field list is dense and jargon-heavy, and the trailing fragment 'Never a certification.' would read better attached to the preceding caveat.

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?

An output schema exists, so the tool needn't explain return values — yet it lists field names without defining them (what 'n', 'accuracy', 'interval', 'family', 'kind' mean or how they relate). Given a zero-argument tool whose only real failure mode is misselection among dozens of sibling axes, the absence of any disambiguation leaves a genuine 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?

Zero parameters, so the baseline is 4. The description reinforces this by explicitly saying the tool takes no argument, pre-empting an agent from inventing or hunting for parameters. The field list it provides actually describes the return payload, not inputs, so it adds no real parameter meaning beyond the empty 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 names a specific resource (the humanoid-labour-index axis of the live GSPC board) and enumerates exactly what a row contains (n, accuracy, interval, MEASURED/UNMEASURED status, family, kind, bank or run-artifact URL, dates). That is far more than a restatement of the title. However, with ~34 sibling axis_* tools including near-neighbours like axis_labour-components and axis_humanoid-deployment, it offers no differentiation from them.

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?

Usage is implied rather than stated: read this tool to obtain the humanoid-labour-index row. There is no explicit guidance on when to prefer it over get_axis, measurement_index, board_totals, or the closely related labour/humanoid axis siblings. The clarification that an unmeasured result is a legitimate answer does usefully shape interpretation, but not selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, open-world, non-destructive, so the bar is lower — yet the description adds real semantics: an unmeasured axis is a 'first-class answer', 'never an error and never a zero', plus the 'Never a certification' disclaimer about what the data is not. That is genuine context an agent cannot get from 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?

One dense, front-loaded sentence that opens with what the tool is and how to call it. The clause list of fields is long but each item earns its place; only the 'this tool IS the axis' phrasing is slightly redundant.

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?

An output schema exists, so return values needn't be spelled out, yet the description still names the key fields and — more importantly — explains how to interpret an unmeasured row. Complete for a no-arg, read-only axis lookup.

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?

Zero parameters, so the baseline is 4; the bundle is empty and additionalProperties=false, and the description confirms the tool takes no argument. It spends its words on return fields instead, which is appropriate for a no-arg tool.

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?

Names the specific resource (the interop-conformance axis of the live GSPC board), gives its URL, and enumerates the row fields it surfaces. The framing 'this tool IS the axis' is a bit circular, and it never contrasts itself with close siblings like axis_conformance or axis_detector-interop, so an agent must infer the distinction.

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 states the call takes no argument, which is useful, but gives no when-to-use guidance: nothing says why to pick this axis over axis_conformance, axis_detector-interop, or get_axis. An agent gets no routing signal beyond the axis name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent and non-destructive, but the description adds genuinely non-obvious behavior: an UNMEASURED axis is a first-class declared slot, never an error and never a zero, and the result is never a certification. That is exactly the kind of edge-case disclosure that prevents an agent from misreading a null result as failure.

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 identity and the no-argument fact are front-loaded, and every clause carries content. The one long enumeration of returned fields is slightly list-heavy for a description whose tool already has an output 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 zero-argument, read-only, output-schema-backed tool, this covers what it is, where it lives, the empty-result semantics and the non-certification caveat. Nothing an agent needs in order to call it or interpret the response is absent.

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?

Zero parameters, so the baseline is 4; the description reinforces this by stating the tool takes no argument. No further parameter semantics are needed or possible.

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 resource — the interpretability-reproducibility axis of the live GSPC board — and points to the hosting URL, so the agent knows exactly what entity it is fetching. It does not, however, differentiate itself from the ~30 sibling axis_* tools or from get_axis, which an agent seeing the tool list would need.

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 when-to-use or when-not guidance, and no mention of the obvious alternative (get_axis, board_totals, measurement_index). The only routing help is 'it takes no argument', which tells the agent how to call it, not when to prefer it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered, and the description adds useful semantics beyond them: the returned fields, the fact that unmeasured slots are published gaps rather than failures, and the caveat 'Never a certification'. That is genuine behavioral context an agent could not infer from the hints alone.

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?

Front-loaded with the identity of the axis and the no-argument fact, then the field list. The trailing two clauses about unmeasured rows and 'never a certification' earn their place, though the single dense sentence is harder to scan than it needs to be.

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-param, read-only, open-world tool with an output schema, the description supplies what the schema does not: the meaning of UNMEASURED rows and the non-certification framing. What is missing is any orientation against the many sibling axes, which matters given how crowded this namespace is.

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?

Zero parameters, so the baseline is 4; the description correctly reinforces that no argument is accepted. The enumerated fields (n, accuracy, interval, status, family, kind, URL, dates) are output semantics, which are already covered by the output schema, so they neither help nor hurt here.

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 a specific resource ('the jail axis of the live GSPC board') and asserts that the tool IS that axis, but 'jail axis' is domain jargon and it draws no boundary against the ~30 sibling axis_* tools or against get_axis, which also returns axes. An agent knows it returns a row of the GSPC board but not why to pick this over axis_safety or get_axis.

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 takes no argument" sets invocation expectations, and the explicit rule that an UNMEASURED axis is a first-class answer 'never an error and never a zero' is real consumption guidance. However, there is no when-to-use / when-not-to-use framing and no routing to an alternative sibling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new semantics: an UNMEASURED axis is a first-class declared slot with no run behind it, 'never an error and never a zero.' That is useful anti-misinterpretation context an agent could not derive from structured fields. It stops short of describing freshness, caching, or how the board URL relates to live vs. snapshot data.

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?

Identity is front-loaded in the first clause, and the long field enumeration earns its length by telling the agent what the row contains. The sentence structure is slightly convoluted around the colon list, but there is no filler or repetition.

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?

With an output schema present and no parameters, the description covers the essentials: what the axis is, that it needs no input, how to read UNMEASURED results, and a caveat that it is not a certification. The one meaningful gap is the relationship to get_axis and the other axis tools, which affects routing rather than calling.

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?

Zero parameters, so the baseline is 4. The description correctly reinforces this by stating the tool takes no argument, which matches the empty schema with additionalProperties: false and prevents an agent from inventing inputs.

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 says this is 'the labour-components axis of the live GSPC board' and enumerates what the axis carries (n, accuracy, interval, MEASURED/UNMEASURED, family, kind, artifact URL, dates). That tells an agent roughly what comes back, but 'this tool IS the axis' largely restates the name, and with ~30 near-identical axis_* siblings plus get_axis and board_totals, there is no statement of what distinguishes this axis from the generic accessor.

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?

No when-to-use, when-not-to-use, or alternative is named. The presence of a sibling called get_axis makes the omission material — an agent cannot tell from this text whether to call this axis tool directly or go through get_axis. The 'no argument' note is a calling fact, not usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered; the description adds genuinely non-redundant semantics — no arguments, an unmeasured slot is not an error and not a zero, and 'never a certification'. Auth requirements and any caching behavior are unstated, keeping it off a 5.

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 front-loaded sentence that establishes what the tool is before enumerating fields, with no filler or repetition. The field enumeration partly duplicates the output schema, which is the only slack.

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?

An output schema exists, so the return shape needs no further explanation, and the description supplies the key interpretive rule (unmeasured is first-class). What remains missing is the relationship to get_axis and the meaning of 'lab-practice' as an axis family, given the large sibling set.

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?

Zero parameters, so there is nothing to disambiguate; the description correctly confirms the tool takes no argument and that additionalProperties=false is intentional. This is the baseline for a parameterless tool.

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?

Names a specific resource ('the lab-practice axis of the live GSPC board') and states that the tool returns that row rather than computing anything, listing the returned fields. It is clear what the tool yields, but it never differentiates itself from the ~30 sibling axis_* tools or from get_axis, which an agent may reasonably suspect to be the generic way to fetch the same axis.

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?

Usage is only implied: the description says it takes no argument and that an unmeasured axis is a valid answer, which tells the agent how to interpret a result but not when to prefer this tool over get_axis or board_totals. No exclusions or alternatives are named despite a crowded sibling set.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile needs no restating. The description adds genuinely non-obvious behavior: an unmeasured axis is a first-class declared slot, published deliberately, never an error and never a zero, and is never a certification — exactly the ambiguity an agent would otherwise mishandle.

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?

It is front-loaded with the resource and URL, then the no-argument fact, then the unmeasured semantics. Slightly dense as one long clause-laden sentence, and the trailing 'Never a certification' fragment reads as an afterthought, but no sentence is wasted.

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?

With zero parameters and an output schema present, the description need not explain return values, yet it helpfully sketches the row's fields and the unmeasured case. The only real gap is relational context — how this axis relates to axis_conformance and to the get_axis/board_totals family.

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?

The tool has zero parameters, so the baseline is 4. The description reinforces this by stating the tool IS the axis and takes no argument, eliminating any doubt about whether a name or ID must be supplied.

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 a specific resource (the machinery-conformity axis of the live GSPC board at an explicit URL) and enumerates what a row carries: n, accuracy, interval, measured/unmeasured status, family, kind, source URL and dates. The purpose is unmistakable, but it never says how this differs from the many sibling axis_* tools or from get_axis/axis_conformance, so sibling differentiation is absent.

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?

Usage is only implied: an agent infers it should call this to read the machinery-conformity axis, and the description does clarify that it takes no argument. There is no explicit when-to-use/when-not guidance and no pointer to axis_conformance or get_axis as alternatives, which matters given ~30 sibling axis tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds genuinely non-derivable behavioral context: an UNMEASURED axis is a declared slot with no run behind it, 'never an error and never a zero,' and 'never a certification.' That prevents an agent from misreading an empty result as failure — real value beyond 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?

It front-loads what the tool is and why it has no inputs, then adds the UNMEASURED caveat. The core sentence is dense (a run-on list of fields), but each clause carries meaning and nothing is padding.

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?

With an output schema present, return-format details are not needed, and the description adequately explains the no-arg design and the UNMEASURED semantics. What is missing is any orientation toward the sibling axes, so an agent still lacks guidance on when this axis is the right one.

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?

There are zero parameters, so the baseline is 4. The description reinforces this by explaining the tool 'IS the axis, so it takes no argument,' which confirms the empty schema is intentional rather than an omission.

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 a specific resource (the measurer-integrity axis of the live GSPC board) and enumerates the exact fields returned (n, accuracy, interval, status, family, kind, artifact URL, dates). It is unambiguous what the tool returns, though it never explicitly contrasts itself against the other axis_* siblings beyond being 'this' axis.

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?

Usage is only implied: 'it takes no argument' tells the agent how to call it, and the fields listed imply when it is relevant, but there is no explicit statement of when to choose this axis over the ~30 sibling axis_* tools or any exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, non-destructive, open-world, so the bar is lower, but the description adds real semantic behavior: an UNMEASURED axis is a first-class answer, not an error and not a zero, and the value is never a certification. That interpretation guidance is exactly the kind of context annotations cannot express.

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?

Front-loaded with what the tool is and the no-argument constraint, followed by the field list and the UNMEASURED caveat. The mid-sentence field enumeration (n, accuracy, interval, family, kind...) is a little listy, but every element is informative.

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?

With an output schema present and zero parameters, the description only needs to frame purpose and edge-case semantics, which it does, including the unmeasured-slot rule. The one gap is routing relative to get_axis and the other axis_* siblings.

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?

Zero parameters, so baseline is 4. The description reinforces this by explicitly stating the tool takes no argument, which prevents an agent from hunting for filters, and the empty schema confirms it.

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?

It names a specific resource (the openness axis of the GSPC board), points to the backing URL, and enumerates the fields the axis exposes. However, it never distinguishes itself from the sibling get_axis or from the other axis_* tools, and 'GSPC board' is left as unexplained jargon, so the agent has to infer the split.

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?

Usage is only implied: read this when you want the openness axis. There is no explicit 'use this instead of get_axis when...' and no stated preconditions or exclusions, even though a near-identical sibling exists.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open-world), but the description adds genuinely non-inferable semantics: an UNMEASURED axis is a first-class declared slot, 'never an error and never a zero', and the board is 'never a certification'. Those rules are exactly what an agent needs in order to interpret a null-looking result correctly.

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?

It is front-loaded with the URL and the no-argument rule, which is good, but the middle sentence becomes a run-on field list (n, accuracy, interval, status, family, kind, URL, dates) that drifts into return-value detail. That enumeration partly duplicates what the output schema already declares and dilutes the two genuinely valuable statements.

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?

An output schema exists, so return fields needn't be spelled out — yet the description spends most of its length on them. What is missing is relational context: how this axis differs from get_axis, board_totals, or axis_provenance-controls, and whether the data is a live fetch or a cached board slice.

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?

Zero parameters, so the baseline is 4; the description reinforces this by stating the tool takes no argument and the schema sets additionalProperties=false. No parameter meaning is left ambiguous.

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?

Names a specific resource (the provenance axis of the live GSPC board) and pins it to a concrete URL, which is more than the sibling axis_* names alone provide. However, it never states a verb ('returns the provenance axis row') and does not distinguish itself from sibling get_axis, which plausibly returns the same kind of data by name.

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 only usage-type guidance is 'it takes no argument', which is structural rather than situational. There is no statement of when to call this versus get_axis, axis_provenance-controls, or board_totals, and no exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, non-destructive and open-world, so the bar is lower; the description still adds real interpretive context by stating that an unmeasured axis is a deliberate published gap rather than an error or a zero. The 'never a certification' caveat further warns the agent off a plausible misreading of the data. It stops short of saying anything about freshness or rate behavior of the live board.

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?

Identity and the no-argument rule are front-loaded, and every clause conveys something: source URL, argument contract, payload shape, unmeasured semantics. It runs long as a single breath and the field list could be trimmed given the output schema exists.

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-param, read-only axis tool with an output schema and full annotation coverage, the description supplies what the structured fields cannot: the meaning of an unmeasured result and the non-certification framing. The remaining hole is conceptual — what this axis measures and how it relates to the near-identically named axis_provenance sibling.

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?

Zero parameters, so the baseline is 4, and the description correctly confirms the no-argument contract instead of leaving the agent hunting the schema. The field enumeration (n, accuracy, interval, status, family, kind, URL, dates) adds a little orientation, though it largely duplicates the output 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?

It names the resource concretely (the provenance-controls axis of the GSPC board, with a URL) and enumerates what a row carries, which is more than a restatement of the title. But it never explains what a 'provenance-controls' axis actually measures, and among a sibling set containing both axis_provenance and axis_provenance-controls the agent gets no basis for choosing between them.

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 only usage signal is 'it takes no argument', which tells the agent how to call it, not when. There is no statement of when to read this axis versus get_axis, axis_provenance, or board_totals, and no preconditions or exclusions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With annotations already declaring readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, the description adds meaningful behavioral context: an unmeasured axis is published as a first-class declared slot, never an error and never a zero. It also warns 'Never a certification,' which is useful interpretation guidance beyond the structured 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 front-loads the core resource and no-argument constraint, then explains the unmeasured status semantics. The long em-dash sentence listing fields is somewhat run-on and partly redundant with the output schema, but overall the text is appropriately sized and every sentence contributes context.

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?

Because an output schema exists, the description does not need to explain the return shape in detail. It covers the important zero-parameter behavior and the special unmeasured-axis semantics, though it is less complete on how this axis tool relates to sibling axis readers and get_axis.

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?

The tool has zero parameters, and the description explicitly reinforces that it takes no argument. That is a small but helpful confirmation beyond the empty schema. The baseline for zero-param tools is 4, and no parameter-semantics gap remains.

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 identifies a specific resource, the regulator-transparency axis on the live GSPC board, and says it takes no arguments. However, it never states the action in a clean verb like 'returns' or 'fetches', relying on 'this tool IS the axis' to imply retrieval. It also does not distinguish this zero-argument axis tool from siblings such as axis_* tools or get_axis.

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 description establishes that the tool takes no arguments and explains that an unmeasured axis is a valid answer, which implies this is a direct lookup of one specific axis. It gives no explicit guidance on when to use this tool instead of get_axis or the many other axis_* siblings, nor does it state prerequisites or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely non-obvious behavior: zero arguments by design, the field set surfaced, the rule that an unmeasured slot is a published gap rather than an error or a zero, and the 'never a certification' disclaimer against over-reading the result.

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 sentences, front-loaded with the identity and URL, then the zero-argument rule, then the unmeasured semantics, then the disclaimer. Dense but each clause carries information; the em-dash parentheticals in the middle sentence are the only mild wordiness.

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?

An output schema exists and annotations are rich, so return-format and safety detail are not required here. What is missing is routing context: with 34 sibling axis_* tools including axis_regulator-transparency, the description should say how this axis differs or how to enumerate the others. Otherwise it is adequate for a zero-argument read.

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?

Zero parameters and 100% schema coverage, so the baseline is 4. The description goes slightly further by explaining that the absence of arguments is intentional ('this tool IS the axis'), which preempts an agent hunting for a filter or axis-id parameter.

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?

It names the resource precisely — the regulatory-framework axis of the live GSPC board — and points to a concrete URL. But it never states the operation plainly ('this tool IS the axis' is a riddle where 'returns the current row for this axis' would do), and it doesn't distinguish itself from the near-identically named sibling axis_regulator-transparency or from get_axis.

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 statement of when to call this versus get_axis, board_totals, list_cards, or the 30+ sibling axis tools. The only usage-shaped guidance is interpretive ('an unmeasured axis is a first-class answer — never an error and never a zero'), which tells the agent how to read the result but not when to reach for this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnly/idempotent annotations, the description supplies genuinely useful interpretation rules that annotations cannot: an UNMEASURED axis is a first-class declared slot, never an error and never a zero, and the output is 'never a certification.' That prevents two concrete agent misreads (treating UNMEASURED as failure, or as 0). It stops short of describing provenance freshness or whether the live board can drift between calls.

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?

It is short and front-loads the resource identity, and every clause carries content — no filler. But the first sentence is a run-on chain of clauses joined by dashes and colons, with the key semantics (unmeasured-as-answer, not-a-certification) buried mid-sentence rather than given their own line.

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?

With zero parameters and an output schema present, the return values need not be explained, and the description still covers the endpoint, the field vocabulary, and the semantic caveats around UNMEASURED and certification. What is missing is where this sits in the larger board workflow — whether to pair it with board_totals or get_axis to assemble a full view.

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?

Zero parameters, so the baseline is 4, but the sentence 'takes no argument: n, accuracy, interval, MEASURED or UNMEASURED status...' presents output fields in the syntactic position of arguments, which can momentarily read as a parameter list. It is consistent with the schema (empty object, additionalProperties:false) yet adds a small ambiguity rather than clarity.

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?

It identifies the resource precisely ('the reserve-attestation axis of the live GSPC board') and pins the endpoint, but never states the action or what calling it yields — the reader has to infer from 'the row' and the field list that it returns one axis's record. Against ~35 sibling axis_* tools whose names alone carry the same amount of information, it does little to differentiate beyond topic.

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 guidance on when to call this versus get_axis, board_totals, measurement_index, or the other axis tools — all plausible alternatives for retrieving axis data. The only usage-adjacent statement ('takes no argument') is a constraint, not a selection rule.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real value on top: it states the tool takes no argument, that an unmeasured axis is a declared slot with no run behind it rather than an error or a zero, and that it is never a certification. That pre-empts the most likely agent failure mode (misreading an empty result as a bug).

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?

Front-loaded with the resource, which is good, but the first sentence is a run-on that enumerates return fields already covered by the output schema, and the 'this tool IS the axis' framing is an awkward way to say 'takes no arguments'. Some of that length does not earn its place.

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?

The critical semantic - how to interpret an unmeasured axis - is covered, and the output schema plus annotations handle returns and safety. What is missing is how this differs from get_axis and any access/payment note implied by siblings like x402_trust, so an agent still has to guess about routing.

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?

Zero parameters with 100% schema coverage, so the baseline is 4. The description reinforces this by stating explicitly that the tool takes no argument, which prevents an agent from inventing inputs.

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 identifies the resource (the safety axis of the live GSPC board at a named URL) and the fields it carries (n, accuracy, interval, MEASURED/UNMEASURED, family, kind, URL, dates), but uses no verb - it never says 'returns' or 'fetches'. It also does not distinguish itself from the sibling get_axis, which an agent could plausibly pick instead.

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?

Usage is only implied by the name: use this for the safety axis. There is no explicit routing guidance against get_axis, list_cards, or the other thirty-plus axis_* siblings. The one piece of real guidance - that an UNMEASURED axis is a valid answer to be reported, not retried or treated as failure - is genuinely useful but is interpretation guidance rather than invocation guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered; the description instead contributes genuinely new semantics — that an UNMEASURED axis is a published gap rather than an error or a zero, and the 'never a certification' caveat. That interpretation guidance is worth more than the annotations alone and is the single most valuable part of the definition.

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 identity and the no-argument fact are front-loaded, followed by the field list and the unmeasured-result rule. The dense middle sentence cramming seven field names together and the trailing fragment 'Never a certification.' cost a little readability, but there is no filler.

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?

With an output schema present and 100% schema coverage, the description needn't document return shapes, and it sensibly focuses on the semantic edge case (unmeasured axes) instead. What remains missing is its relationship to the near-identically named axis_* siblings and to get_axis, which an agent would still need to resolve.

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?

There are zero parameters, so the baseline is 4. The description reinforces this explicitly by stating the tool takes no argument and that the axis itself is the resource, which removes any doubt about how to call it.

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 specific resource it exposes (the serving-fidelity axis of the live GSPC board) and enumerates the fields it carries, so an agent knows exactly what it is getting. It falls short of a 5 because it never positions itself against the many closely named siblings such as axis_harness-fidelity or the generic get_axis, leaving the agent to infer which one to reach for.

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?

'This tool IS the axis, so it takes no argument' implies a zero-configuration read and the note that unmeasured results are first-class tells the agent how to read the answer. However, there is no explicit when-to-use framing and no mention of when to prefer get_axis, measurement_index, or board_totals instead.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open-world), so the description's real contribution is the return-value semantics: an UNMEASURED axis is a published declared slot, never an error and never a zero. That is a genuinely useful behavioral disclosure an agent would otherwise misread as failure — though 'never a certification' remains cryptic.

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?

It is front-loaded with the resource identity and the no-argument contract before reaching the UNMEASURED caveat, which is the highest-value sentence. The mid-sentence enumeration of return fields is slightly redundant given an output schema exists, but it stays within three sentences and each one carries signal.

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?

With annotations covering safety and an output schema covering return shape, the description only needs to supply framing and the UNMEASURED semantics — which it does. The main gap is that its relationship to get_axis and the rest of the axis_* family is left implicit, which matters in a 40-plus-tool surface.

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?

The tool takes zero parameters, so the baseline is 4, and the description positively reinforces this with 'takes no argument.' The schema is empty with additionalProperties=false, and nothing in the description contradicts that.

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 a specific resource — the swarm axis of the live GSPC board — and enumerates the fields it returns (n, accuracy, interval, status, family, kind, source URL, dates), so an agent knows exactly what it gets. 'This tool IS the axis, so it takes no argument' implicitly distinguishes it from the generic get_axis sibling, but it never names or contrasts the other ~30 axis_* tools 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?

Usage is only implied: the 'takes no argument' phrasing hints this is the pre-bound swarm-axis fetcher, as opposed to a parameterized axis lookup like get_axis. There is no explicit statement of when to prefer this over get_axis or the other axis_* siblings, and no prerequisites or exclusions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, openWorld, non-destructive, so safety is covered structurally; the description adds genuinely non-obvious semantics — that an UNMEASURED axis is a published declared slot rather than an error or a zero, and that the output is never a certification. That absence-vs-failure distinction is the kind of context the schema cannot carry. It stops short of describing volatility, caching, or how the live board updates.

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 sentences, front-loaded with identity and scope, then the interpretive caveat; nothing repeats the annotations verbatim. The field enumeration is dense and would scan better as a list, and 'first-class answer' is rhetorical rather than informative, but overall the length is proportionate to the tool.

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?

With zero parameters, an output schema, and full annotation coverage, the description supplies what the structured fields cannot: what the axis represents and how to read an empty result. The one missing piece is orientation among the many sibling axis readers and aggregators, which the description never addresses.

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?

Zero parameters, so the baseline is 4; the description also correctly reinforces that no argument is accepted, which matches additionalProperties:false and an empty properties object. No gap to compensate for.

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 specific resource (the watchdog-ingest axis of the GSPC board, with a base URL) and the row contents it surfaces (n, accuracy, interval, status, family, kind, URL, dates), which separates it from the other axis_* siblings by axis rather than by function. However, it never uses an operative verb — 'this tool IS the axis' describes identity, not an action, so an agent must infer that the tool reads/returns that axis row.

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?

'Takes no argument' sets the calling convention and the remark that an unmeasured axis is a valid answer implies when not to treat a result as failure. But it never routes between siblings: nothing says whether get_axis, measurement_index, or board_totals should be preferred in any situation, so usage is only implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond them: a named UNREACHABLE failure state and the guarantee that no cached number is presented as live, plus the epistemic caveat 'we measure, never certify'. It stops short of auth, rate-limit or freshness-bound information.

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?

Front-loaded with the purpose and source URL, then the return contract, then the detail mode, then the failure state — a sensible order. Some rhetorical redundancy ('never summed and never swapped', 'we measure, never certify') pads an otherwise tight paragraph, but every clause carries domain meaning.

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?

An output schema exists, so return values need no further explanation, and the description still characterizes the shape and the failure mode. For a zero-required-parameter read tool with full annotation coverage, the remaining gap is minor — no mention of caching TTL beyond the live claim, or of what an agent should do after an UNREACHABLE response.

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 100% and the single enum parameter is already fully documented in the schema, including what each mode returns. The description restates the same summary/full split without adding syntax or defaults beyond the schema, so the baseline of 3 applies.

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?

Names a specific resource (live GSPC board totals from councilof.ai/api/gspc) and enumerates exactly what comes back: slot count, measured count with their kind, the separation line, and as_of dates. The slot-vs-measurement distinction is defined inline, so an agent knows what 'count' means here, which no sibling tool (axis_*, get_card, measurement_index) provides.

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?

Gives clear guidance on the detail switch ('compact by default; pass detail "full" for...'), which is the only choice the caller makes. It never says when to reach for this rather than measurement_index or get_card, nor states any preconditions, so routing between siblings is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond annotations by disclosing the paid x402 nature, the re-serving behavior, and that 'a payment never mints a MEASURED cell (fresh_run stays UNMEASURED until a published run exists).' Also describes the no-payment fallback response and the semantic boundary against certification.

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?

Dense but every sentence earns its place: main action, payment semantics, challenge mode, and scope boundaries. Front-loaded with 'PAID (x402)' and the core action before caveats.

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 paid x402 tool with three parameters and an output schema, the description covers the full call flow: challenge without payment, completion with payment, effects on existing cards and fresh_run, and the boundary against certification. Nothing needed to invoke it correctly is missing.

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 100%, so the baseline is 3, but the description adds behavioral meaning to the parameters: the x_payment challenge/response flow, what 'subject' can be (model id, instrument id, card sha), and the effect on fresh_run state. This goes beyond the schema's property descriptions.

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 the specific action 'Commission one signed card-v0 receipt' for a named subject on the frozen bank, via a concrete endpoint. It also draws clear boundaries: 'Measurement, not certification — never a rank, a grade or a certificate,' distinguishing it from verification and certification tools in the sibling list.

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?

Explains the two-step usage: omit x_payment to get the 402 challenge and free preview, then supply x_payment to complete. It excludes certification and notes 'Verification stays free,' steering agents toward free verification alternatives, though it does not name the specific sibling tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the annotations: discloses the x402 payment model, the 402 challenge flow, the PAID_NOT_DELIVERED failure mode after settlement, and instructs not to auto-retry or re-pay. It also discloses that assembly does not verify input-card signatures and that an unsigned manifest reports its signing status/reason — rich behavioral context not captured by readOnlyHint/idempotentHint.

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?

Front-loads the most decision-relevant facts (PAID, one obligation, endpoint) and keeps the failure/payment caveats tight. It is still dense and caveat-heavy across many sentences, but each sentence carries operational weight, so waste is low.

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 paid, multi-step, non-idempotent tool this is close to complete: payment acquisition, preview path, empty-bundle behavior, failure handling, and caveats on what the output does and does not establish. An output schema exists, so omitted return-value detail is acceptable.

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 100%, so the schema already documents obligation, subject, preview and x_payment. The description reinforces meaning (obligation names, subject intent, preview = count only) but adds little syntax or format beyond what the schema provides. Baseline 3 applies when the schema does the heavy lifting.

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+resource: it assembles an evidence bundle for ONE named obligation (article-50, article-53, dora, cra) plus optional subject, and enumerates the payload (card objects with signature fields, inclusion proofs, OSCAL assessment-results wrapper, manifest). An agent can distinguish it from evidence_bundle_preview (free) and the other evidence siblings without opening schemas.

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?

Gives clear routing: use preview=true or the free evidence_bundle_preview tool to check counts first, and omit x_payment to receive the actual 402 challenge. It also states scope exclusions (no new measurement, no full OSCAL conformance, not a legal determination). However it does not differentiate this tool from the other evidence-emitting siblings (rwa_evidence, server_evidence, art50_marking_evidence).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/openWorld/idempotent/non-destructive, and the description still adds real behavioral context: the source is fetched live, results are never a satisfied/not-satisfied determination, zero relevant cards returns EMPTY rather than an error, and article-53 output is evidence for review only. These edge-case and non-determinism semantics are exactly what annotations cannot convey.

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?

It is dense and front-loads the resource and scope, and each disclaimer (EMPTY semantics, no determination, grants no status) carries load. The third and fourth sentences overlap somewhat in re-stating the non-certification boundary, which is minor redundancy rather than padding.

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?

An output schema exists, so return structure need not be described, yet the description still covers the two cases an agent must handle correctly — zero relevant cards (EMPTY, not an error) and the non-determinative nature of relevance. Combined with the documented enum and subject semantics, nothing needed to call this correctly is missing.

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 100% and the enum values for obligation are fully documented in the schema, so the baseline is 3. The description restates the subject concept ('a model id, vendor or instrument the cards must name') and confirms the obligation-wide selection when omitted, but adds little beyond the schema text.

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 a specific verb+resource and scope: the obligation record, its counsel-gate status, and the already-signed measurement cards relevant to exactly ONE obligation, read live from a named endpoint. It also constrains the selection to one of four obligations, which separates it from card-level siblings like get_card or list_cards.

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 context for use (obligation-level evidence for a single obligation, optionally narrowed by subject) and explicitly rules out use as a conformity assessment, certification, audit opinion or compliance determination. It does not, however, name a sibling tool or state when to prefer this over measurement_index or list_cards, so routing guidance is partial.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.