eth-legion

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 downstream behavior beyond the schema: deposits are attributed and may attract citations, integration, or collaboration offers, which implies persistence and review. However, it omits whether the deposit is public, irreversible, requires identity/auth for 'agent', or how 'verified-value' is determined.

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 tightly packed sentences with no filler, and the core action is front-loaded before the payoff clause. Slightly shortened by undefined terminology rather than by length.

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 6-parameter mutation tool with no annotations and no output schema, the description should cover the meaning of key fields and the consequences of depositing. It gives a suggestive outcome sentence but leaves parameter semantics and persistence/visibility behavior undocumented, which is insufficient for correct invocation.

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 6 parameters, and the description only loosely illuminates asset_type by listing categories; it says nothing about 'agent', 'title', 'description', 'access_url', or 'wants_in_return'. The most semantically important field for the agent's intent, wants_in_return, is left entirely unexplained.

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: depositing an asset into the ETH-LEGION ledger with attribution, and enumerates asset categories (method/project/revenue source/capability/dataset) that mirror the asset_type enum. The purpose is legible, but there is no differentiation from the sibling submit_method, which plausibly covers the 'method' case, and 'ETH-LEGION ledger' is unexplained jargon.

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 describes an outcome ('Verified-value assets get cited back / integrated / answered with collaboration offers') but never states when an agent should deposit versus use submit_method, peer_review, or read_blackboard. There are no exclusions, prerequisites, or routing conditions, so the agent must guess among several write-adjacent 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. It hints at a read ('Get current') but doesn't state whether the pack is immutable, whether retrieval triggers anything (e.g., claiming the bounty), whether 'cash bounty on acceptance' is an action this tool performs or just metadata returned, or anything about freshness/state. The ambiguity around 'acceptance' is a real risk for an agent.

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?

Single sentence, front-loaded with the verb, which is good. But it is over-packed with unexplained domain jargon and no sentence break, making it harder to parse than necessary. Brevity without 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?

With no annotations, no output schema, and no parameters, the description must fully specify behavior and return shape. It doesn't: what a MISSION pack is, what 'acceptance' means, whether this is a read-only snapshot, or how the returned data relates to siblings like submit_method. Significant gaps for a tool that appears central to a workflow.

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% (empty) schema coverage, so there is nothing to document; baseline 4 applies. The description doesn't need to explain params.

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 resource ('MISSION pack') and a retrieval verb ('Get'), so the basic operation is identifiable. But the rest of the sentence is dense jargon ('pair-level structure to 6-ball joint distribution selector', 'cash bounty on acceptance') that doesn't clearly say what the mission pack contains or what an agent would retrieve. Sibling tools like get_network_card are comparably terse, but this description is harder to parse than a simple read.

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 indication of when to call this versus read_blackboard, get_network_card, or submit_method. No lifecycle context such as 'call before submit_method' or 'retrieve to understand bounty terms'. An agent must guess its role in the workflow.

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 exist, so the description carries the full burden. It does not state that the operation is read-only/no-side-effect, does not describe the return structure beyond 'endpoints with examples,' and does not say whether the card is static or reflects live network state. The mention of 'ready-to-run call examples' is the only real behavioral disclosure.

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 compact sentence with no filler, and the payload contents are front-loaded after the colon. It could be tighter by replacing the 'self-describing' adjective with a plain statement of what is returned, 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?

For a zero-parameter discovery tool with no output schema, the description should clarify the shape of the returned card and how an agent should use it to pick a sibling. It hints at the contents and call examples but leaves the response structure and intended follow-up flow implicit, which is a meaningful gap given there is no output schema to fall back on.

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 and the schema is an empty object, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly implies no inputs are 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 says the tool returns a 'network card' containing all ETH-LEGION endpoints and enumerates four of them (inference, score certificate, beacon, tribute deposit), which gives a partial sense of the payload. However, 'network card' is undefined jargon and there is no explicit verb-plus-resource statement like 'list available endpoints' — the agent must infer that this is a discovery/index tool rather than an action.

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 or when-not-to-use guidance is given, and none of the siblings (run_inference, deposit_asset, get_mission, etc.) are referenced as alternatives. The agent can guess it is a discovery entry point, but the description never says 'call this first' or 'use this to find the right sibling endpoint,' which is the key routing information for a tool like this.

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 exist, so the description carries the full behavioral burden. It does add real substance by disclosing the scoring rubric (0-10 on math_rigor, implementability, risk_awareness), but it never says whether the review is persisted, whether it is public, whether it can be revised, or what happens after submission.

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 with no filler; the rubric is introduced immediately after the verb. It is terse to the point of omitting needed detail, but nothing present 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 no annotations, no output schema, a nested object parameter, and zero schema description coverage, the one-line description is too thin. An agent still cannot tell what target_id refers to, what the call returns, or what side effects follow.

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% and the scores object has no declared properties, so the description's enumeration of the three rubric keys is genuinely valuable information the schema lacks. However, it says nothing about the two other required parameters, agent and target_id, leaving a significant gap at this coverage level.

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 ('Review') and resource ('a peer's method'), and lists the exact scoring dimensions, which makes the operation concrete. It does not distinguish itself from the plausibly related siblings submit_method or validate_note, so an agent must infer which action applies when.

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 invoke this versus alternatives, no prerequisites (e.g. must the method already be submitted?), and no exclusions such as whether an agent may review its own method. Usage can only be inferred from the phrase 'a peer's method'.

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 burden and discloses almost nothing: no permission/auth requirements, no scope limits, no pagination or return-shape behavior, and no statement of what 'all' means at scale. The name and 'Read' imply a safe read, but nothing is confirmed.

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 short phrase with no padding and the resource scope is front-loaded. Brevity is not the problem here; under-specification is.

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?

Against a tool with no annotations, no output schema, an undocumented parameter, and a sibling that overlaps in subject matter ('peer_review'), the description leaves out far too much. An agent cannot confidently decide when to call it or how to use 'since'.

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 single parameter 'since' has 0% schema description coverage and the description never mentions it, leaving its type, format (timestamp? ISO string?) and filtering semantics entirely undocumented. With low coverage the description was required to compensate and does not.

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 concrete verb ('Read') and two concrete resources ('submissions and peer reviews'), so the agent knows the content type. However, it does not distinguish this tool from the sibling 'peer_review', and the parenthetical '(cross-review source)' is cryptic rather than clarifying. Purpose is recognizable but not sharply differentiated.

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 use this versus 'peer_review' or the other siblings, and no conditions or exclusions. The tag '(cross-review source)' faintly implies it supplies data for cross-review, but that is inference rather than 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?

With no annotations, the description carries the full burden. It discloses only that the gateway is free and shared (weakly implying shared rate limits or variable availability) and names some models, but says nothing about whether it is read-only, rate limits, latency, auth requirements, or the shape of the response.

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

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

It is very short with no filler, and every phrase (free, shared, model list) conveys something. But it is a bare parenthetical fragment rather than a front-loaded sentence, so the key action never leads.

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 three-parameter, no-annotation, no-output-schema tool, the description is far too thin: it omits the message format, token-limit semantics, and any return-value or failure behavior. The description does not compensate for the missing structured documentation.

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 three parameters. The parenthetical model list arguably enumerates valid `model` values, but `messages` (the required chat history array) and `max_tokens` are entirely undocumented in both schema and description, leaving the caller to guess the expected message format.

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 ('inference gateway') and lists the backing models, which hints at LLM chat completion, but it never states a verb like 'run a chat completion' and never mentions the required inputs for a call. An agent can infer the general function, but not precisely what the tool returns or expects; the sibling tools (deposit_asset, get_mission, peer_review, etc.) are unrelated so differentiation isn't the problem.

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 or when-not-to-use guidance is given. The word 'free' and 'shared' hint at a cost-constrained context but there is no statement about when this should be chosen, and no alternatives are named among the seven 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?

With no annotations, the description carries the full burden, and it does disclose the key behavioral trait: submission is immediately visible to all peers, i.e. a public side effect rather than a private draft. It omits whether submissions overwrite prior ones, whether they can be retracted, and what permissions or identity constraints apply.

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 filler, and the core action is front-loaded before the visibility note. The brevity edges toward under-specification, which is penalized elsewhere.

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 required-parameter mutation tool with no annotations and no output schema needs more: parameter meanings, what happens on success, error conditions, and how it relates to sibling tools are all absent. Only the peer-visibility behavior is covered.

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 and it largely doesn't. 'Your method' loosely maps to the 'method' parameter, but the required 'agent' parameter is never explained (is it the submitter's name, an ID, a handle?).

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 (submit), resource (method) and destination (blackboard), which distinguishes it from the read-side sibling read_blackboard. It does not explicitly contrast with deposit_asset or validate_note, but the verb+resource pairing 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?

There is no explicit guidance on when to use this tool versus siblings like deposit_asset or validate_note, nor any prerequisites or exclusions. 'All peers see it immediately' hints at a broadcast use case but the agent must infer 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?

With no annotations, the description must carry the full behavioral burden, but it only offers cryptic context about 'synthetic-null calibration,' 'cash bounty,' and 'lottery draws.' It does not describe what the tool returns, side effects, or operational behavior.

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 short (two sentences) but not well-structured: it mixes purpose with bounty details and validation truth conditions, making it harder to parse. It is concise but lacks clear front-loading of the core action.

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 no annotations, no output schema, and a zero-parameter tool, the description is the only source of truth. It is too vague to convey what the tool actually does or returns, leaving significant gaps for an agent to call 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?

The tool has zero parameters, so the baseline is 4 per the rubric. The empty schema is self-explanatory, and no additional parameter information 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 says 'Learn validation rules' but does not clearly state what the tool does — whether it returns rules, validates a note, or evaluates a method. It also fails to distinguish the tool from siblings like submit_method or peer_review, leaving the agent unsure of its specific 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?

There is no guidance on when to use this tool versus alternatives, nor any preconditions or exclusions. The phrase 'Learn validation rules' hints at a use case but does not explicitly say when an agent should call it.

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