torneo

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

With no annotations, the description carries the full disclosure burden and does add real behavioral facts: it is read-only, abstention strips only the verdict while evidence/reservations/gaps persist, no rank is emitted on overlapping intervals, and replay/attestation verdicts are as-of the last build. These are meaningful, but they are cryptic and omit permissions, cost, and what a consumer does with 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?

Four compact sentences with the primary operation front-loaded (read-only decision for one category) followed by behavior and caveats. It earns its length, though the density of version tags slightly blurs the 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 no output schema, the description usefully sketches the return shape (EVIDENCE/ABSTAIN plus reason_code), which is essential context. But given 4 parameters at 0% coverage and a nested object, the definition is still short of what an agent needs to invoke it 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 0% across 4 parameters, so the description must compensate and largely does not. "One category" loosely maps to `category` and "a declared context" hints at `constraints`, but `as_of` and `max_age_days` are never addressed, nor are the pattern constraints or the nested `constraints` object's value types.

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 does convey that this is a read-only decision engine producing an EVIDENCE or ABSTAIN verdict plus a reason_code for one category. However the core purpose is wrapped in opaque internal jargon ("decision.v1", "answer_rule.v3") that an outside agent cannot resolve, and it never plainly states the verb+resource. It distinguishes itself from siblings only implicitly.

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

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

There is no when-to-use or when-not-to-use guidance, and no sibling (explain_limits, get_need, get_results, etc.) is named as an alternative. The agent is left to infer entirely when this tool is preferable to get_results or get_run.

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 no annotations, the description carries the full behavioral burden. It signals read-only intent indirectly ('read before citing evidence') and names what it surfaces, but says nothing about error behavior, what happens if both or neither optional parameter is supplied, or the shape of the returned metadata.

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 short, front-loaded sentences with no filler; the payload enumeration leads and the usage cue follows. It is efficient, though the telegraphic noun-phrase style borders on under-specification rather than tight writing.

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?

A metadata-inspection tool with no annotations, no output schema, and fully undocumented parameters needs the description to explain invocation semantics, especially the both-optional parameter combination. The entry covers what it exposes but leaves how to call it correctly unresolved.

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 neither parameter is documented in the schema. The phrase 'of a category or run' loosely maps to the two parameters, but the description never explains their semantics, that both are optional, or how they interact. It adds only marginal meaning over the bare schema.

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

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

The description names the resource and the specific payload it returns (limits, freshness, conflicts, answer rule) for a category or run, which is more informative than a bare name. However, it is a noun phrase with no verb, and it never distinguishes itself from siblings like get_run or get_results that also concern runs. Purpose is implied rather than 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?

'Read before citing evidence' is a genuine usage cue that tells the agent when this tool belongs in a workflow. But it gives no alternative, no when-not condition, and no guidance for the category-vs-run choice the two parameters imply.

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 no annotations, the description carries the full burden, and it does disclose two useful traits: the source-selection fallback (private store vs published snapshot) and 'No execution is triggered,' which implies a safe read. It stops short of permissions, rate limits, or return shape, so it is only partially transparent for a tool with zero annotation coverage.

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 compact sentence with no wasted clauses, which is good, but the front-loaded fragment is cryptic jargon rather than a clear statement of purpose. Brevity here reads as under-specification rather than discipline.

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 tool with two undocumented parameters, no annotations, and no output schema, the description is too thin: it omits parameter meaning, expected return content, and any routing guidance. The one genuinely useful fact (no execution is triggered) is not enough to make the definition callable with confidence.

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

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

Schema description coverage is 0% for two parameters (run_id, category), and the description mentions neither one – not even that category is required or that run_id is optional. The only oblique hint ('when configured') does not map clearly to any parameter, so the description 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 the noun phrase 'Automatic attempts, including failures' – a restatement of the tool name's resource with no verb, so it never actually says what the tool does (retrieve? list? summarize?). It does not distinguish itself from siblings like get_results, get_run, or request_tournament, which an agent could easily confuse 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?

'current private-store state when configured, otherwise a published snapshot' hints at which data source is returned but gives no when-to-use guidance, no prerequisites, and no alternatives among the nine sibling tools. An agent cannot tell from this text whether to call this or get_run/get_results.

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 no annotations, the description carries the full burden and does disclose genuine behavior: the source-resolution order (private-store state when configured, otherwise the published snapshot) and a failure-mode hint ('unknown or unavailable means partial, not refused'). It omits auth requirements and what a 'partial' result actually contains, so it adds context but is not complete.

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 that front-load the resolution rule, with no filler. However, the second sentence is dense and cryptic ('partial, not refused'), which costs readability without adding proportionate clarity.

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 no-output-schema, no-annotation getter, the description covers the unusual resolution and partial-result semantics reasonably well. It still leaves gaps around what a need is, the parameter format, and the returned content, so it is adequate but not 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 0% for the single required parameter, so the description must compensate. It only echoes 'need-id' without explaining the 'need-[0-9a-f]{16}' format or meaning, adding no real semantics beyond the parameter 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 name and the phrase 'Follow need-id' imply retrieval of a need by its identifier, and the description adds resolution-scope detail (private-store vs published snapshot). However, it never plainly states that it fetches/returns a need record, so the core purpose must be inferred from 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?

There is no explicit when-to-use guidance and no reference to any sibling tool (e.g., submit_need or explain_limits). The only conditional information concerns data-source resolution, not tool selection, so an agent gets no help choosing this 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?

With no annotations, the description carries the full burden, and it does add real behavioral color: the output carries observed_at, uncertainty and limits fields, and can return an INSUFFICIENT_EVIDENCE state that is not a ranking. It still omits read-only/permission expectations, error behavior, and return shape, so it is only partially transparent.

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 short sentences with no padding, and the resource statement is front-loaded ahead of the citation advice. However, the brevity comes at the cost of obscurity rather than efficiency — the second sentence mixes usage rules with output interpretation in a dense fragment.

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 no annotations, so the description's mention of observed_at, uncertainty, limits, and INSUFFICIENT_EVIDENCE is genuinely needed and partially fills the gap. Missing are the overall return structure, category discovery, and any relation to sibling tools, leaving the definition only minimally complete for a 1-param retrieval 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%, so the description must compensate for the required "category" parameter, and it does not explain valid category values, the slug format, or how to discover them (e.g., via list_categories). It only implicitly ties the input to "a category," which is already evident from the parameter 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?

"Canonical evidence for a category" names a resource and its scope (a category), so the agent knows it retrieves evidence-like output rather than, say, submitting a need. But the phrasing is cryptic jargon — it never says these are results/rankings/scores — and it draws no boundary against siblings such as get_run or explain_limits.

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 directive is about how to cite the output ("Cite observed_at, uncertainty and limits; never the best tool"), not when to call this tool versus the alternatives. There is no when-to-use, no precondition, and no named alternative among the seven siblings.

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?

No annotations are provided, so the description carries the full behavioral burden. The only disclosure is a return-value detail ('unknown cost is null / UNKNOWN'); nothing is said about read-only safety, side effects, errors, or permissions.

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 but telegraphic and jargon-laden, achieving brevity by omitting the essential action rather than by eliminating waste. The fragment is not front-loaded with the tool's 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 annotations, no output schema, and an undocumented required parameter, the description must do more. It leaves the agent without the action, prerequisites, or return shape needed to invoke the tool 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 0% and the single required run_id parameter has only a regex pattern with no prose. The description adds no meaning about what run_id is or where to obtain it, 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 is a noun-phrase fragment ('Canonical result bundle or explicit PRE_REGISTERED state') rather than a verb+resource statement, so it never actually says what get_run does. It hints at the returned payload but an agent cannot confidently distinguish it from sibling get_results.

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, when-not-to-use, or alternative guidance at all. Siblings like get_results and get_auto_tournament are not referenced, leaving selection entirely 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?

With no annotations, the description carries the full behavioral burden. It does add real value by disclosing data provenance — fixtures are synthetic and never real evidence — which prevents an agent from treating fixture rows as fact. It still omits the read-only nature, ordering, pagination, and result shape, so the disclosure is partial.

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 short sentences with no padding, and the functional statement is front-loaded ahead of the caveat. The terms used are underexplained rather than verbose, so structure is fine but the phrasing could be sharper.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter list tool with no annotations and no output schema, the description should at least sketch the returned shape and the meaning of 'fixture flags'. It gestures at two returned fields but leaves 'dated status', ordering, and completeness unaddressed, leaving the agent guessing about the payload.

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 per the rubric the baseline is 4. The description correctly implies a parameterless enumerate operation and adds no misleading argument hints.

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 verb ('Discover') and resource ('categories') and names two attributes returned (dated status, fixture flags), so the basic intent is inferable. However, 'dated status' and 'fixture flags' are idiosyncratic internal terms that are never defined, so an agent cannot fully predict what a category is. It also does no work to distinguish this from the tournament/need/run 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?

There is no statement of when to call this tool, no prerequisites, and no reference to any alternative sibling tool. The only guidance-adjacent content is the fixture caveat, which is about data meaning rather than when-to-use. An agent must infer usage purely from the 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?

With no annotations, the description carries the full behavioral burden, and it does disclose the most important trait: this is non-executing and non-spending ('Advisory only; never starts a run or spends'). It also reveals the return contract (an id) despite there being no output schema. It omits auth requirements, error behavior, and whether requests are persisted.

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, each earning its place: what it does, its safety posture, and the required follow-up call. The safety constraint is front-loaded and 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?

It compensates well for the missing output schema by naming the returned id and the follow-up tool, and it covers the non-execution semantics. It does not help the agent populate the rich, required 'need' payload, which is the main remaining gap for a tool whose only argument is that object.

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 'need' parameter is a deeply nested object with many enum-constrained fields (requester.kind, adaptation.kind, priorities, constraints). The description only names the schema version ('need.v1') and adds no meaning to any of these fields, leaving the schema to do all the work.

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 ('Request a tournament') and names the contract ('need.v1'), so the operation is unambiguous. It does not differentiate itself from the similarly named sibling submit_need or explain how it relates to get_auto_tournament, 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?

'Advisory only; never starts a run or spends' implies the context in which this is appropriate, and 'Follow the returned id with get_need' gives the next step. However, it never states when to prefer this over submit_need or get_auto_tournament, so the routing decision is left implicit.

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 no annotations, the description carries the full behavioral burden, and it does disclose two non-obvious traits: it returns a need-id, and persistence is 'partial until private ingestion and publication.' The privacy warning is also useful. It omits idempotency, whether the submission is binding or purely advisory in effect, and any auth/rate-limit 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?

Two compact sentences with the action front-loaded and no filler. It is terse rather than padded, though the 'advisory need.v1' phrasing is dense jargon that a first-time caller may not parse.

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 single-parameter tool wrapping a complex nested payload with zero schema descriptions and no output schema, the definition leaves major gaps: what a 'need' represents, how it differs from a tournament request, and what fields like requester.kind or priorities actually control. The return value mention is helpful but far from sufficient.

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

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

Schema description coverage is 0% for a deeply nested 'need' object with required sub-fields (requester, task_class, schema const) and constrained values (priority 0-1 weights, task_class pattern, latency/cost constraints). The description adds only the schema version name and a sensitivity warning; it explains none of the nested field meanings, so the agent must infer them from raw types.

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 concrete verb and resource: 'Log an advisory need.v1 request.' That is a clear action on an identifiable object and pairs sensibly with the sibling get_need. It stops short of distinguishing itself from request_tournament, the other write-style sibling, leaving the agent to infer the boundary.

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 this tool should be invoked versus get_need or request_tournament, and no listed preconditions. The 'Do not include personal or secret data' line is a data-handling constraint, not usage guidance. The agent must guess the intended entry point of the workflow.

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