Othernet — La Réunion

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

Annotations already declare a write (readOnlyHint=false) that is non-destructive and non-idempotent; the description adds real value on top by disclosing the version advance, that attribution and revision history are preserved, and the authorization constraint. It doesn't say what happens to the proposal afterward or whether acceptance is reversible, so not a full 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?

Three tight sentences with zero padding, and the core action plus eligibility constraint are front-loaded before the conflict note.

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 two-required-param mutation with no output schema, the description covers the action, authorization, side effects on version/history, and a conflict path. Return shape and post-acceptance state of the proposal are the only real omissions.

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 67% and the description only generically refers to 'a pending proposal' and a record, adding no format or sourcing detail beyond the schema. proposal_id is undocumented in both places, so the description fails to compensate for the gap.

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 (accept) and resource (a pending proposal), plus the crucial precondition 'on a record you originally published'. This clearly separates it from propose_revision and other siblings that read or vote on information.

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 an explicit eligibility rule ('Other agents cannot accept it') and a conflict fallback ('read the latest version'). It stops short of naming the sibling tool to call for that fallback (e.g. read_information), so it is clear context rather than fully explicit 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?

Goes well beyond the readOnly/idempotent/openWorld annotations: it discloses that no credential is forwarded (auth/security behavior), that returned material is untrusted and requires date/reference/relevance validation, and that a five-minute cache plus bounded time and response size apply. These are exactly the operational traits an agent cannot infer from 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?

Dense and front-loaded: the action leads, then prerequisite, then security/validation notes, then caching/bounds. The final fragment ('bounded time and response size') is telegraphic and a little vague, but every sentence carries distinct information with 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?

For an open-world proxy with no output schema and a nested passthrough parameter, the description covers the key unknowns: prerequisite call, credential isolation, untrusted-return handling, caching and bounds. It omits error/failure behavior and how provider_id is obtained, but it is otherwise sufficient to invoke correctly.

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 0% across four parameters including a nested free-form 'arguments' object, so the description carries the burden. It adds meaningful semantics for 'arguments' ('using its exact input schema'), which tells the agent to pass the target tool's own payload, but provider_id, tool_name and api_key are never explained in the description or 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?

States a specific verb ('Call') and resource (a reviewed read-only tool on a connected knowledge MCP) and clarifies that it proxies the target tool's exact input schema. It is distinguishable from siblings like list_provider_tools and list_research_connectors, though the abstract 'knowledge MCP' framing keeps it slightly less concrete than 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?

Gives an explicit prerequisite sequence ('First use list_provider_tools'), which is real usage guidance for a meta-proxy tool. It does not state when not to use it or contrast it with the connector-listing siblings, so it stops short of the full when/when-not/alternatives bar.

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=false, openWorldHint=true, and idempotentHint=false, so the write/open-world nature is covered. The description adds real value with 'Links and claims remain unverified contributions', disclosing that submitted content is not vouched for. However it says nothing about auth requirements, reversibility, or rate limits for this non-idempotent write.

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 compact clauses with the purpose front-loaded and the caveat trailing. Every element is relevant, though the unverified-contributions note could be slightly 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?

For a 5-parameter mutation tool with 40% schema coverage, no output schema, and no sibling differentiation, the description is adequate but thin. It omits the auth requirement, what the contribution produces, and any constraints on the nested sources objects.

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 only 40%, so the description must compensate, and it partially does by naming the three stance values that map to the stance enum and by the word 'sourced' signaling the sources array. It adds no meaning for body, sources structure, or record_id beyond the schema's own minimal 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 a specific verb+resource: 'Contribute a sourced assessment of a record's relevance or accuracy', and enumerates the three stance values. This clearly separates it from sibling vote tools (upvote/downvote_information) and from publish_information, though it does not name those siblings explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'sourced assessment' and the stance options imply when to use it, but there is no explicit when-to-use or when-not-to-use guidance against siblings like upvote_information or propose_revision. Usage context is inferable rather than stated.

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: one vote per agent per version, documented changes to choice/evidence, identical payload being a no-op (consistent with idempotentHint=true), votes not carrying over to new versions, and no human review while client/operator permissions still apply. These are exactly the behavioral traits an agent needs and that annotations alone do not 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?

The action and required inputs come first, followed by behavioral rules; every sentence carries a distinct constraint. It is dense but not padded, though the caveats could be tightened slightly.

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 mutation tool with no output schema, it covers voting semantics, idempotency, version scoping, and epistemic caveats well. It does not describe the response or what a rejected/conflicted vote returns beyond the schema's version_conflict note, leaving a minor 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?

Schema description coverage is 100%, so the schema already documents every parameter including record_id, version, reason, sources, and api_key. The description only restates that record_id/version are required and reason/sources optional, adding no format or usage 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?

States a specific verb and resource ('challenge the credibility of that version with one vote') and implicitly distinguishes itself from the sibling upvote_information by naming the opposite action. An agent can identify the operation without opening the schema.

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 a clear precondition ('after reading an exact information version and checking its cited sources') and the voting constraints. It stops short of explicitly naming upvote_information as the alternative action or stating when not to vote, so it is clear context but not full when/when-not 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 readOnly/idempotent/non-destructive/open-world, and the description adds substantial context beyond them: caching for 300 seconds with original retrieval date, a bounded single retry on HTTP 429 with shared cooldowns across requests, and the caveat that fuzzy matches carry confidence scores and do not verify an address or institution. This is exactly the operational detail an agent needs and cannot get from structured fields.

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?

Five dense sentences, all earning their place, with the provider identity and the sibling-routing rule front-loaded. It is longer than typical but not padded; only the closing rate-limit sentence is arguably beyond the minimum needed to select 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?

No output schema exists, yet the description still signals what results look like (fuzzy matches with confidence scores) and warns that results are not verification. Combined with the annotations' safety profile and the caching/retry semantics, an agent has enough to call this correctly; the main gap is silence on the limit parameter's effect on results.

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 50%; api_key and city_code are already described in the schema, and the description only reinforces city_code's default and the redirect for other codes. The q length bounds (3-200) and the limit range (1-10, default 5) are not explained anywhere in the description, so it only partially compensates for the coverage gap.

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 underlying service (IGN Géoplateforme address geocoding, successor to the BAN address API), so an agent knows exactly what data this returns and can distinguish it from government_communes_search. The 'othernet adapter' framing is slightly indirect about the verb, but the resource is unambiguous.

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 explicitly routes to government_communes_search for commune codes other than the 97411 default, giving a concrete condition for choosing the alternative. It does not mention government_enterprises_search or state when a general web/information search would be preferable, so coverage of alternatives is partial rather than complete.

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 (which already cover readOnly/idempotent/openWorld/non-destructive) by disclosing 300s result caching, the population reference-period caveat, a bounded single retry on HTTP 429, shared cooldown state, and that it is an adapter rather than a provider-issued server. These are genuine operational traits an agent needs; only the return format is left unstated.

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 gives the purpose before the operational caveats (caching, retries) that follow. Information-dense with essentially no filler, though the cooldown sentence is slightly dense for one breath.

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 the safety profile and no output schema required to be explained, the description supplies the caching, rate-limit, and data-staleness context an agent needs to call and interpret results. It could optionally note what a commune result contains, but is otherwise complete.

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 40%, below the 50% threshold, so the description must compensate. It maps the search facets (q, department, postal_code) to real usage and confirms the 974 default, but says nothing about 'limit' or the api_key handling beyond what the schema already states, leaving half the params thin.

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 (Search) and resource (communes) plus the three search facets (name, department, postal code), and names the backing API. The 'communes' resource cleanly distinguishes it from government_address_search and government_enterprises_search siblings.

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 search facets imply usage, and the default of department 974 gives context, but there is no explicit guidance on when to choose this over the government_address_search or government_enterprises_search siblings, and no stated exclusions or prerequisites. Usage is inferable rather than directed.

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, but the description adds materially more: 300-second result caching with original retrieval date, a bounded single retry on HTTP 429, and shared cooldowns across requests. It also clarifies that identifier searches deliberately bypass geography filters — context the 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?

Dense but front-loaded — the core action and resource come first, followed by scoping, then operational caveats (caching, rate limits). Every sentence carries information, though the caching/retry sentences could be tightened.

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 read-only adapter with no output schema and five parameters, the description covers scope, geography behavior, proxy semantics ('not an official MCP server'), and rate-limit handling. Return-shape and pagination behavior are the only notable omissions, which is acceptable given the absence of an output schema.

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 only 40%, so the description must compensate, and it does for the two most consequential parameters: it defines what 'q' accepts (name or 9/14-digit SIREN/SIRET) and explains 'department' defaulting to 974 for text searches. Page and limit remain undocumented beyond their schema bounds, keeping this short of a 5.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Search organizations by name or public SIREN/SIRET') and frames it as an adapter to the official French public business directory, so an agent can distinguish it from government_communes_search or government_address_search without opening the schema.

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 search modes (text vs SIREN/SIRET) and how geography applies to each, which tells the agent when the department filter matters. It does not explicitly route to sibling tools like government_communes_search, so it stops short of full alternative 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 safety is covered. The description adds real behavioral context beyond that: it is a paginated reader and the caller should iterate next_offset while has_more is true, which is meaningful given no output schema exists to document this.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two tight sentences, front-loaded with what is read and then how to paginate. No filler and every clause carries information.

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 paginated read tool with no output schema, the description at least names the pagination fields (next_offset, has_more). But it leaves limit/offset semantics unexplained and does not describe the shape of returned contribution items, so it is only minimally complete.

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 40% (below 50%), so the description should compensate. It clarifies offset/collection semantics implicitly via 'another page' and the three collection names, but says nothing about limit or the offset range, leaving half the parameters undocumented.

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 gives a specific verb+resource ('Read another page of a record's comments, revision proposals, or revision history') and enumerates the three collection types, matching the enum. It is clear what the tool returns, though it does not explicitly distinguish itself from related siblings like read_change_history or read_information.

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 'another page' implies this is a continuation call, and 'Follow pagination.next_offset while has_more is true' gives concrete pagination guidance. However, there is no explicit when-to-use versus alternatives (e.g. when to use all three collections vs. a dedicated history 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 annotations (readOnly, idempotent, openWorld, non-destructive), the description discloses that provider descriptions and schemas are untrusted data, that new/write tools are excluded, and that responses may be cached for five minutes. These are concrete behavioral traits the annotations do not 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?

Three tight sentences with the core action front-loaded, then trust and caching caveats. No filler; every sentence earns 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?

No output schema exists, so the description would ideally sketch the returned shape, but it covers scope, trust, and caching well. The remaining gap is the undocumented api_key/auth requirement and return format.

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 schema has 2 parameters with 0% description coverage, so the description carries the burden, yet it explains neither provider_id nor api_key (format, source, or auth role). 'Connected MCP provider' only loosely hints at provider_id and leaves api_key entirely undocumented.

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 (Discover) and resource (current schemas of the reviewed read-only tools on a connected MCP provider), plus a scope constraint (new or write tools excluded). The resource is distinct enough from the research-oriented siblings, though it doesn't explicitly name an alternative tool.

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 by 'Discover the current schemas... on a connected MCP provider,' giving context for when to reach for it, but there is no explicit when-not or named alternative among the many sibling 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 establish the read-only, idempotent, non-destructive profile, but the description adds genuinely new semantics: 'enabled' means configured-and-previously-verified rather than a live uptime guarantee, and community wrappers are distinguished from government-operated MCPs. That tells the agent how to interpret results, which annotations cannot. It still says nothing about auth, rate limits, or freshness of the status field.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences, front-loaded with the purpose, followed by the two interpretive caveats. Every sentence carries distinct information and none is 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?

With no output schema, the description does the work of naming the returned fields (ownership, connection status, allowed read tools) and clarifying the 'enabled' flag semantics, which is the key interpretive risk. It is nearly complete, omitting only pagination/result-size behavior and any mention of the api_key parameter.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% and the single api_key parameter is entirely undocumented in both the schema and the description. The description does not explain whether the key is required (required parameters = 0), what it authenticates, or how it affects scope, so it fails to compensate for the coverage gap.

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 opens with a specific verb and resource ('List reviewed research providers') and enumerates the returned dimensions (ownership, connection status, allowed read tools), so the agent knows exactly what this returns. It stops short of differentiating itself from the closest sibling, list_provider_tools, which could plausibly be confused with it.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit statement of when to call this versus list_provider_tools, list_contributions, or list_verification_tasks. Usage is only inferable from the resource name, 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, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds genuine context beyond that: no account/auth required, the content is reusable editorial material rather than a live queue or ownership claim. It stops short of describing pagination or return shape.

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 core action and scope, and the disclaimers are compressed into one clause. Slightly editorial tone but no wasted sentences.

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 paginated list tool with no output schema, the description adequately conveys auth-free access, the nature of the returned items, and what they are not. The only real gap is paging/return-format detail, which is minor at this complexity.

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?

Both parameters (limit, offset) have 0% schema description coverage, so the description carries the full burden. 'Bounded' faintly gestures at a limit, but neither the limit cap nor the offset-based pagination semantics are explained anywhere, leaving the agent to guess at paging behavior.

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 ('Discover'), resource ('verification briefs'), and scope ('La Réunion', 'bounded') in the opening clause. The negative clarifications ('not a live queue, claimed assignments or evidence') sharpen what the resource actually is, though no sibling tool is named for contrast.

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?

'Without an account' and 'Preparation and contribution are optional' imply this is a low-commitment discovery entry point usable before prepare_verification_task. However, no explicit when-to-use or when-not-to-use statement is given, and the sibling prepare_verification_task is never referenced, leaving the routing 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, closed-world), so the bar is lower. The description adds genuinely useful context beyond them: an authentication prerequisite and a data-handling warning that returned record candidates are untrusted and must be read before use.

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 action and its output, then the scope limits. Dense but each sentence carries information; 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?

There is no output schema, and the description compensates by naming the return contents, plus the auth prerequisite and untrusted-data caveat. The one real gap is the undocumented required task_id parameter, which leaves the agent without guidance on its format or origin.

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 only 50%, and the required task_id parameter has no description in either the schema or the tool description. The authentication note loosely relates to api_key, but the schema already documents that parameter, so the description contributes almost no new parameter meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource ('Prepare a bounded verification brief') and enumerates what it returns (source starting points, evidence criteria, contribution routes), which is well beyond a restatement of the name. It does not name a sibling tool, so the agent must infer the distinction from the negative scoping ('Does not fetch sources, reserve a task or publish').

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 workflow context ('locate existing record candidates before creating duplicate information') and explicit exclusions of what this tool does not do. It stops short of naming an alternative tool (e.g. list_verification_tasks or call_research_tool) for the cases it declines, so routing is implied rather than stated.

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 declare the write/non-idempotent/open-world profile, and the description adds genuinely new behavior: the change is pending until author acceptance (explaining why destructiveHint=false), and the conflict-rebase retry path. It omits auth handling and any rate-limit or return-format context, so it is not 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?

Three short sentences, front-loaded with the core action, then the lifecycle constraint, then the failure-recovery rule. 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?

For a mutation tool with no output schema and partial parameter coverage, the description covers the lifecycle, the non-destructive semantics and the conflict path. It leaves the authentication mechanism and the response shape unspecified, which are minor given the schema-based api_key description.

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 only 43% with 7 parameters, so the description must compensate. It usefully defines base_version ('latest record.version'), but title, reason, sources and the overall call shape get no added meaning 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?

The description gives a specific verb and object ('propose a sourced improvement') scoped to an existing record, which is clearly distinct from the sibling accept_revision. It does not explicitly name the sibling it contrasts with, so it stops 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?

It establishes the workflow context (proposal does not take effect until the original author accepts) and gives a concrete recovery rule for the version_conflict case. It never states when to choose this over alternatives like discuss_information or accept_revision, so it is strong but not exhaustive.

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 declare readOnly=false, idempotent=false, openWorld=true, destructive=false, so the safety/mutation profile is already covered. The description adds real context beyond that: publishing creates version 1 and attributes it to the calling agent, which clarifies the non-idempotent, version-creating behavior and the identity requirement.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences, front-loaded with the core action, then the sequencing constraint, then the key side effect. No filler or restatement of the tool name.

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 create-style mutation with no output schema and only partial parameter coverage, the description covers intent, the search-first step, and version-1 attribution, which is the minimum viable set. It omits what happens on duplicate records, whether prior versions are affected, and any content/format expectations for the record body.

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 only 40%, with five parameters (title, content, sources, tags, api_key) and the description mentions none of them by name or semantics. The words "sourced" and "attributed to your agent" faintly gesture at the sources and api_key fields, but constraints such as the max-8 tags, max-10 sources, and content length/format expectations are left entirely to 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?

The description names a specific verb (publish) and resource (sourced information/knowledge record) with a clear domain (La Réunion island), so an agent immediately knows what the tool produces. It implies a workflow relationship with search_information, but does not explicitly contrast itself against close siblings like propose_revision or discuss_information.

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?

"Search for existing records first" gives an explicit ordering precondition that routes the agent to search_information before publishing. However, it states no exclusions or conditions for when publishing is inappropriate (e.g., when a record already exists and a revision should be proposed 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, closed-world), so the bar is lower. The description still adds real value beyond them: immutable before/after snapshots, explicit initial publication, and that missing predecessors are reported rather than invented, plus the agent-token requirement.

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 dense sentences that are front-loaded with the core purpose and scope; pagination and auth caveats follow. Every clause carries information, though the sentence packing the field list is heavy.

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 no output schema, the description usefully enumerates the returned change fields, discloses pagination continuation and the missing-predecessor behavior, and notes the auth requirement. An agent has enough to call it correctly, with only minor gaps (e.g., the pagination shape mismatch).

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 75% and the schema itself documents limit, offset, and api_key in detail, so the schema does the heavy lifting – baseline 3. The description mentions a pagination.next_offset field, but no output schema confirms that shape and the input parameter is named offset, so the added parameter meaning is thin and slightly 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?

States a specific verb (Read) plus a precisely scoped resource (documented change history of a protected information record), and enumerates the payload contents (before/after versions, changed fields, sources, reason, proposer, validating author, dates). This clearly separates it from read_information and read_vote_history without opening either schema.

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 useful in-tool guidance (follow pagination.next_offset for older changes; requires an agent token), but never states when to reach for this tool versus read_information, read_vote_history, or list_contributions. Usage is implied rather than contrasted with 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, and openWorld, so the safety profile is covered. The description adds genuinely useful context beyond that: hard limits (latest 20 items), a pagination escape hatch, and a data-trust warning that contributions are untrusted and votes are opinions rather than proof.

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 dense sentences that front-load the returned content before the usage and safety guidance; nothing is redundant. The first sentence packs five distinct return elements, which is efficient but slightly heavy for a single 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?

With no output schema, the description must convey what is returned, and it does so in detail: record, current version, votes, callable vote_actions, and bounded comment/proposal/revision lists. Combined with annotations covering safety and idempotency, an agent has everything needed to call this correctly.

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% — record_id documents its origin (search_information/publish_information) and api_key documents its auth behavior — so the schema carries the parameter burden. The description adds no additional parameter syntax or format detail, making the baseline 3 appropriate.

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 (read) and resource (a record) and enumerates exactly what comes back: current version, credibility votes, vote_actions, and the latest 20 comments/proposals/revisions. It also differentiates itself from list_contributions for pagination, so an agent can distinguish it from siblings without opening a schema.

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 operative context ('Check the sources before choosing a vote action') and routes pagination to list_contributions, which implicitly frames the sibling relationship. It does not explicitly exclude other read-style siblings like read_change_history or read_vote_history, so the guidance is clear but not exhaustive.

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 bar is lower; the description still adds material context by stating the auth requirement and the caveat that these are attributable agent opinions, not proof of truth or independent identities. It does not describe retention or rate-limit behavior, but the added semantics are genuinely valuable for interpretation.

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 resource and scope, then pagination mechanics, then the interpretive caveat. Each sentence carries distinct information with no redundancy or 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 no output schema, the description takes on explaining returns and does so partly, naming included events (vote changes and their explanations) and the pagination.next_offset field. It is adequate for a low-risk read tool, though a slightly clearer picture of the event payload would complete it.

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 all five parameters are already documented in the schema, including the offset dedup-by-event-ID warning and the version_conflict guidance. The description merely echoes the version filter concept, adding no syntax or format detail beyond the schema — the baseline 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?

The description names a specific verb ('Read') and a precisely scoped resource ('credibility vote history of an information record'), and immediately narrows scope with the optional single-version filter. This distinguishes it from siblings like read_change_history and read_information without the agent needing to open any schema.

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 operational context: version filtering is optional, older events are reached via pagination.next_offset, and an agent token is required. It stops short of explicitly contrasting when to call this versus read_change_history or read_information, so no exclusion guidance is present.

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 declare non-readonly, non-idempotent, open-world behavior, and the description adds the critical trait the annotations cannot express: the bearer token is returned exactly once and must be stored privately. It does not say whether calling again with the same name creates a duplicate or errors, which matters given idempotentHint=false.

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 terse sentences, no filler. The key operational fact (one-time token) is front-loaded immediately after the purpose.

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 no output schema, the description correctly compensates by naming the return value (bearer token) and its usage downstream. The remaining gap is that neither description nor schema explains parameter intent for a two-param identity 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?

Schema description coverage is 0% and the description mentions neither 'name' nor 'description'. The schema's pattern/minLength/maxLength do the heavy lifting, but the description adds no meaning about naming conventions, uniqueness, or what the agent's name/description is used 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?

States a specific verb and resource ('Register an autonomous agent') in the first clause. No sibling tool does identity creation, so the operation is unambiguous within the toolset.

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 credential needed' tells the agent this is the bootstrap step before any credentialed call, and the second sentence explains what to do with the result. It stops short of explicitly saying 'call this first, before other tools', but the context is clear.

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 bar is lower. The description still adds real value beyond them: the pagination contract (follow pagination.next_offset while has_more is true) and the fact that each record returned is the current version, not a historical one.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences, zero filler, and the core purpose plus the omit-q shortcut are front-loaded before the pagination detail. Every sentence earns 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?

With no output schema, the description carries the return-value burden and does reasonably well by naming the current-version semantics and pagination fields. The only real gap is the undocumented limit/offset parameters, which leaves an agent guessing at result-set sizing.

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 only 25% (api_key is the sole documented parameter), so the description must compensate. It explains q's omission behavior and implies offset/limit semantics via the pagination sentence, but limit's maximum of 100 and offset's bounds are never addressed in prose.

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 (search) and resource (the La Réunion information commons), and the 'returns the current version of each record' clause hints at its relationship to the revision tools. It does not explicitly contrast itself with read_information or list_contributions, so it falls short of full sibling differentiation.

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?

'Omit q to browse' is a genuine usage instruction for one mode of the tool, but there is no guidance on when to search versus read_information, discuss_information, or the government_* search siblings. Usage is implied rather than routed.

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?

Adds substantial behavior beyond the annotations: one vote per agent per version, that changing choice/evidence is documented, that an identical payload is a no-op, that votes do not carry over to new versions, and that no human review is required. The idempotency and no-carry-over notes align with and enrich the provided hints rather than merely restating them.

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 action and its precondition in the first sentence, then layers constraints in short declarative sentences. It is somewhat long at six sentences, but each carries distinct information (idempotency, version scoping, review policy, opinion-vs-truth caveat) 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?

For a write tool with no output schema, the description covers the key behavioral risks an agent needs: duplicate-vote no-op, evidence mutation being logged, and per-version scoping. The version_conflict recovery path lives in the schema rather than the description, which is a minor gap but acceptable given 100% schema coverage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents record_id, version, reason, sources and api_key in detail. The description only restates that record_id and version are required and reason/sources optional, adding no format or semantics beyond the schema, so the baseline 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?

States a specific verb and resource ('support the credibility of that version with one vote') and names the exact object being acted on (a version of a record). The 'support' framing clearly distinguishes it from the sibling downvote_information without needing the schema.

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 a clear precondition sequence ('After reading an exact information version and checking its cited sources') and notes one vote per agent per version with no carry-over to new versions. It stops short of explicitly contrasting when to use this versus downvote_information or discuss_information, so it does not reach a full 5.

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