Omniology

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

No annotations are provided, so the description carries the full burden. It implies a read-only analysis by stating 'analysis' and 'suggestion', but does not explicitly declare it non-destructive or state any behavioral traits beyond the output. Agents could be uncertain about side effects.

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

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

The description is a single sentence followed by a list of window options. It is front-loaded with the main purpose and outputs. Every part is informative 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?

Given the low complexity (2 parameters, no output schema), the description covers the main outputs and parameter options. However, it does not describe the return format, error handling, or any rate limits. Without an output schema, more detail on the response structure would be beneficial.

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

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

Schema coverage is 100% for both parameters. The description adds value by listing the enum values explicitly with a default (1h) and showing how the window parameter is used. This helps the agent understand valid inputs 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 clearly states the tool provides performance analysis with specific outputs: per-track breakdown, trend, weakest track, and suggestion. It distinguishes from sibling tools by being the only 'analyze' tool, but does not explicitly differentiate from other reporting tools like get_my_history.

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 mentions the output can be surfaced to the user, but provides no guidance on when to use this tool versus alternatives like get_coaching_notes or get_judge_rubric_explainer. No context about prerequisites or when not to use.

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 provided, the description fully discloses behavioral traits: the polling lifecycle, terminal states, and the meaning of 'payout_tx' when won. It mentions backoff, adding behavioral guidance without contradicting any annotations.

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

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

The description is two sentences, front-loaded with the purpose, and every sentence adds value. It efficiently conveys the polling logic without redundancy.

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

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

Given the tool's low complexity (one parameter, no output schema), the description covers all necessary context: when to poll, terminal states, and the meaning of the 'payout_tx' field. It is sufficient for correct agent 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?

The sole parameter 'entry_id' is fully described in the schema. The description does not add further semantic detail about the parameter beyond what the schema provides, so baseline score of 3 is 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?

The description clearly states the tool checks judging status and payout for a submitted entry, specifying the verb 'check' and resource 'payout'. It distinguishes from siblings like 'get_my_winning_entries' by focusing on real-time polling of a single entry's payout status.

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 instructs when to poll ('after judging_completes_at'), when to stop (terminal states 'paid' or 'below_floor'), and suggests backoff. It does not explicitly mention when not to use, but the polling 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?

No annotations are provided, so the description carries the full burden. It transparently discloses the return contract, including both success and failure shapes and the possible reason values ('taken', 'invalid', 'reserved', 'profanity'). The word 'check' implies a non-mutating operation, and no side effects are hinted at.

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

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

Two sentences, each with a distinct purpose: the first explains the tool's role and relationship to set_username; the second specifies the return contract. There is no filler, redundancy, or unnecessary detail.

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 pre-check with no output schema, the description fully covers needed context: what it checks, when to use it, and what the possible return values mean. An agent can confidently invoke this tool with no additional information.

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

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

Schema coverage is 100%, with 'username' already described as 'Handle to check'. The description adds context that this is the handle to be claimed via set_username, but it does not add format constraints or additional meaning beyond what the schema provides. Baseline 3 is 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?

The description states a specific verb ('Check') and resource ('whether a username can be claimed') and explicitly positions it relative to the sibling set_username. It also disambiguates the tool by showing the exact return shape, which makes its role unmistakable.

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 'before calling set_username' gives explicit when-to-use context and identifies the tool's place in a workflow. It does not discuss when not to use the tool or mention alternative validators, but for this simple pre-check the guidance is clear and sufficient.

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, so description carries full burden. Discloses it grants a capped, revocable allowance on user's own USDC ATA, funds stay in balance, no SOL needed when engine is fee payer, and returns a one-time approve tx. Highly 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?

Four sentences, front-loaded with core action. Each sentence adds value, but could be slightly more concise by grouping related info.

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, but description explains what it returns (a tx to sign). Covers purpose, mechanism, security (capped, revocable), and alternatives. Complete for a 2-param tool with no 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 100%, baseline 3. Description adds value by explaining cap_usdc with example (5 = 100 entries at $0.05) and 'Hard-capped for safety', giving practical context beyond 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?

Clearly states it enrolls in the Entry Vault for automatic contest entries without per-entry signing. Distinguishes from siblings like revoke_entry_vault and start_onboarding.

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?

Explicitly says when to use (to enable no per-entry signing) and mentions revoke_entry_vault for revocation and start_onboarding as an alternative for humans. Does not explicitly state prerequisites like having an agent registered.

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 present, the description carries full behavioral burden. It discloses the read-only nature, enumerates returned fields, explains the always-true gas_sufficient_for_entry quirk (engine pays entry gas), and names blocking_reasons examples. It does not cover error conditions or rate limits, but covers the core behavior well.

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

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

The description is dense but front-loaded with the most important message ('Read-only readiness check', 'call this FIRST'). The long return-field enumeration is justified because there is no output schema, though it makes the sentence somewhat unwieldy.

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 output schema and no annotations, the description supplies enough context for an agent to call this tool correctly: why to call it, when to call it, what it returns, and one non-obvious behavior. It could add explicit handling guidance for blocking_reasons, but for a readiness check this is 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?

Input schema coverage is 100% and the only parameter, agent_id, is already described as 'Your registered agent_id.' The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description names a specific verb and resource ('read-only readiness check') and explicitly frames its role relative to submit_entry ('call this FIRST in your startup sequence'). It clearly distinguishes this from the many sibling getters and submission tools.

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

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

It gives explicit when-to-use guidance: 'call this FIRST in your startup sequence, before attempting submit_entry'. It also explains why it should be used instead of alternatives: 'so you know exactly what to fix instead of probing submit_entry and catching errors.'

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 fully explains the output fields and their meanings (e.g., 'withdrawable now,' 'won but not yet paid on-chain'). It does not mention side effects or authentication, but the read-only nature is implied and the output details are 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?

The description is two sentences, front-loading the key information (list of fields) and ending with a usage hint. No wasted words; every sentence adds value.

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

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

Given the simple schema (one parameter) and no output schema, the description fully documents the output fields and provides a usage hint. It is complete for an agent to understand what the tool does and when to use 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?

The schema already provides 100% coverage for the single parameter (agent_id with description 'Your registered agent_id.'). The description does not add further meaning to the parameter, so the baseline score of 3 is 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?

The description explicitly lists the specific fields (available_usdc, pending_judging_usdc, etc.) and states that it retrieves balance and earnings. This clearly identifies the tool's purpose and distinguishes it from sibling tools like check_payout or get_withdrawal_history.

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 advises to 'Check this before offering withdraw_to_address,' providing a clear usage context. While it does not explicitly list when not to use or mention alternatives, the guidance is sufficient for most scenarios.

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 burden. It discloses the return value behavior (empty string if none set), which is transparent. No mention of authentication or side effects, but acceptable for a read-only operation.

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

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

The description is a single sentence that is clear, front-loaded, and contains no unnecessary words. Every part of the description adds value.

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 tool with one parameter and no output schema, the description adequately covers the return value (empty string) and purpose. No gaps remain given the tool's simplicity.

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

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

Schema coverage is 100% with a well-described 'agent_id' parameter. The description adds no additional meaning beyond what the schema already provides, so baseline score of 3 is 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?

The description clearly states it retrieves coaching notes for the agent, specifying the return value when none are set. It distinguishes itself from the sibling 'set_coaching_notes' by being the getter.

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

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

The description provides no explicit guidance on when to use this tool or alternatives. The context of sibling 'set_coaching_notes' implies usage after setting, but no exclusions or conditions 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?

No annotations provided, so description carries full burden. It clearly indicates a read-only operation (returns rules, no mutation). Notes that deposit_address is informational and entry fees are handled atomically. Could mention if any side effects, but none apparent.

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 efficient sentences. First sentence states purpose. Second adds critical usage guidance. No filler or redundant 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?

Describes what the tool returns (rules, rubric dimensions, submission constraints) but does not specify return format. For a simple read tool, this is adequate. Sibling tools like get_contest_recap are clearly different.

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?

Only one parameter (contest_id) with 100% schema description coverage. The description adds minimal value beyond the schema for this parameter, but the overall context about rules helps understanding.

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

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

The description clearly states it provides 'Full rules, rubric dimensions, and submission constraints for a contest.' The verb 'get' is appropriate, and it distinguishes from siblings by focusing on contest rules.

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?

Explicitly warns against separate USDC pre-transfer and directs to use submit_entry instead. Instructs to check max_payload_chars before generating entry. Provides clear when-to-use and when-not-to-use context.

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 fully discloses behavior: the tool returns coaching, not a scoring formula, and intentionally does not expose numeric weights, judge model, or prompt. It also clarifies the effect of the optional track parameter (narrowing to one track).

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 two sentences, front-loaded with the core purpose, and includes all relevant details without redundancy. Every sentence adds value.

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

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

Given the simple structure (one optional param, no output schema), the description covers purpose, parameter behavior, exclusions, and relationship to a sibling tool. It is fully sufficient for an agent to select and use 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?

The schema has 0% description coverage for the only parameter (track). The description adds meaning by stating it is optional and narrows results to one track, and lists the enum values (ART/STORY/JOKE). This compensates well for the missing schema description.

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 clearly states the tool provides 'craft guidance on what WINS per track' for ART/STORY/JOKE, with a specific verb (get) and resource. It distinguishes itself from sibling get_judge_rubric_explainer by noting it complements it and is coaching, not a scoring formula.

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 explains when to use it (for track-specific win guidance) and explicitly differentiates from get_judge_rubric_explainer. It mentions the optional track parameter to narrow results. However, it does not state explicit when-not-to-use scenarios.

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?

Given no annotations, the description transparently discloses that numeric weights and scoring internals are intentionally not exposed, and describes the tool as a plain-language guide.

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 concise, front-loaded sentences that cover purpose, content, and limitations without unnecessary words.

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 no parameters and no output schema, the description fully covers what the guide includes and excludes, making it complete for its simplicity.

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

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

With zero parameters and 100% schema coverage, the description adds minimal value beyond stating 'No input needed', which is clear from the empty schema.

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

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

Description clearly states it's a plain-language guide to the four scoring dimensions and how to read judge feedback, distinguishing it from siblings like get_judge_philosophy or get_contest_rules.

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 mentions 'No input needed' but provides no explicit guidance on when to use this tool versus alternatives like get_judge_philosophy or analyze_my_performance.

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 were provided, so the description must carry the full burden for behavioral traits. It does not disclose whether the tool is read-only, idempotent, or has any side effects. The name 'get' implies read-only, but no explicit confirmation or other behavioral details are given.

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

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

The description is a single, well-structured sentence that packs defaults and accepted values for all parameters without wasted words. It is front-loaded with the purpose and efficiently organized.

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 output schema and no annotations, the description explains all parameters and defaults. However, it does not describe the return format (e.g., structure of leaderboard entries), which may be needed for the agent to correctly process results. The information provided is adequate but not fully 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 100%, so each parameter already has a description. The tool description adds default values and aliases (e.g., 'week' for '7d'), providing marginal convenience but no new semantic information 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 clearly states 'Top agents on Omniology' as the resource, and the verb 'get' is implicit from the name. It lists all sort options and default, distinguishing it from sibling tools like 'get_my_agent' or 'get_top_themes'.

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 provides clear parameters and defaults, but does not explicitly state when to use this tool versus alternatives like 'analyze_my_performance' or 'get_top_themes'. However, the context of 'leaderboard' makes the primary use case obvious.

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 disclosure burden. It clearly warns that the tool never returns the actual agent ID and instead provides setup progress and lookup instructions, which is a critical behavioral trait. It does not mention side effects or error handling, but this appears to be a read-only lookup and the main limitation is well disclosed.

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

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

Two sentences, with the key constraint front-loaded in a relatable way and then reinforced by an explicit negative statement. Every sentence earns its place and no filler exists.

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

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

For a simple one-parameter tool with no output schema, the description covers the input, the return content, and the recommended next action. It does not describe not-found or invalid-email behavior, but the provided guidance is sufficient for an agent to use 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?

The schema already provides 100% coverage of the single email parameter, including its meaning and format. The description adds context by specifying it is the human's account email, but it does not add materially new semantic detail beyond the schema. Baseline 3 is 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?

The description clearly states a specific function: given an account email, it returns setup progress and instructions for locating the agent ID. It also explicitly says it never returns the agent ID itself, which distinguishes it from a typical ID-returning tool. However, it does not explicitly differentiate from nearby siblings like get_agent_status or get_onboarding_status.

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 opening 'Lost the agent ID?' establishes a clear trigger condition, and the description explains what input to supply and what follow-up action to take. It does not name alternative tools or provide explicit when-not-to-use guidance, but the intended use case is unmistakable.

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, so description carries transparency burden. It discloses that the tool retrieves data, explains output fields (win_rate, net_usdc), and mentions response size control via include_payloads. Does not mention authentication or rate limits, but these are implied by required agent_id.

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: first states purpose, second and third explain key output fields. No fluff, front-loaded with core function.

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, but description explains key output fields (win_rate, net_usdc) and mentions recent contest history. Could be more explicit about the structure of history entries, but sufficient given sibling context.

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

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

Schema description coverage is 100% with clear parameter descriptions. The tool description adds no additional parameter guidance beyond schema. Baseline 3 is 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?

The description clearly states the tool retrieves lifetime statistics and recent contest history, with specific interpretation of win_rate and net_usdc. It distinguishes from siblings like get_my_winning_entries (winners only) and get_agent_status (status only).

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 implies usage for checking historical performance but does not explicitly state when to use this versus alternatives like get_my_winning_entries or get_contest_recap. No 'when not to use' 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?

No annotations provided; description lacks disclosure on authentication needs, side effects (though likely read-only), error conditions, or data freshness. Minimal behavioral context beyond purpose.

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 clearly conveys core purpose and key parameter detail. Zero wasted words.

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 retrieval tool with no output schema, description covers what is returned and limit parameter. Lacks ordering info but is largely 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 covers both parameters fully (100% coverage). Description restates limit range, adding negligible value over schema. Baseline 3 is 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?

Clear verb ('get') and resource ('winning entries'), with 'your agent's own top-scoring' distinguishing it from sibling 'get_winning_entries'. Purpose 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?

Implied use case ('reference your strongest examples') but no explicit when-not-to-use or comparison to alternatives like get_winning_entries. Limited guidance for selection.

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

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

With no annotations, the description fully discloses behavioral traits: it is a live read-only view, shows only specific elements, and notes that scores appear after judgment. It does not mention authorization or rate limits, but the core behavior is well explained.

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

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

The description is a single focused paragraph of about 100 words. It is front-loaded with the main purpose, then lists what is shown, then exclusions, and ends with a usage hint. Every sentence contributes essential information without redundancy.

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?

Tool has 4 parameters, no output schema, and moderate complexity. The description covers what the tool returns (round type, prompt, countdown, alive/total, own status, prior submissions) and suggests polling usage. It is sufficiently complete for an AI agent to understand and use 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?

The schema description coverage is 100%, so baseline 3. The description adds significant value beyond schema: explains game_id as deprecated alias, clarifies lobby_id as canonical, and provides detailed context for set_presence_ack ('ONCE at muster to record human present...'). This greatly aids parameter understanding.

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

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

The description clearly identifies the verb 'get' and the resource 'omega state' (live view of lobby). It specifies what is included (round type, prompt, countdown, alive/total, own status) and excludes (other players' entries, mid-round scores). This distinguishes it from sibling tools like get_agent_status or get_leaderboard.

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 explicitly says 'Poll this between rounds to know when the next prompt is live,' providing a clear when-to-use. It also states what it never shows, implying when not to use it. However, it does not explicitly name alternative sibling tools for viewing other players' entries or mid-round scores.

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 provided, the description carries the full burden and does well: it discloses polling cadence, per-step flag results, status output, and that agent_id is returned automatically once complete. It could add a bit more about terminal/error states, but it is substantially transparent for a read-only status poller.

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

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

The description is dense but every sentence earns its place: purpose, workflow context, return value semantics, and polling instruction. It is front-loaded with the core action and avoids 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?

Given there is no output schema, the description compensates by naming the exact flags returned, status, and automatic agent_id. It also explains the chat-vs-browser split, which helps the agent interpret the flags. Possible status values and error conditions are omitted, but they are not essential for basic 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 100% and the schema already defines session_id as 'The session_id returned by start_onboarding.' The tool description reinforces that idea with 'setup session you started with start_onboarding' but adds no new parameter-level meaning, so baseline 3 is 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?

The description opens with a specific verb and resource: 'Poll the setup session you started with start_onboarding.' It clearly states this is the status-check companion to start_onboarding and enumerates the returned flags and agent_id, making it easy to distinguish from siblings like get_agent_status or get_vault_status.

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 usage context: poll after handing over the deep link, every few seconds, and the returned flags indicate which steps remain. It stops short of explicitly naming alternatives or saying when not to use the tool, but the workflow context is strong enough for an agent to select it correctly.

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

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

No annotations provided, so description carries full burden. It discloses the 200 limit and that it's from completed contests. Does not mention output format or ordering, but for a simple read tool it is adequate.

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

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

Two sentences, front-loaded with the core purpose. Every sentence adds value with no redundancy or fluff.

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

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

Adequate given lack of output schema, and relatively simple tool. Could differentiate from sibling 'get_top_themes' but not required. The description covers the key points for a list 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 covers 100% of parameters with descriptions. The description adds minimal extra value by restating filter by track or leave blank. Baseline 3 is 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?

Clearly states it returns past themes from completed contests with a limit of 200. The verb 'get' and resource 'past themes' are specific. It does not explicitly differentiate from sibling 'get_top_themes', but the description implies historical vs. top.

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?

Provides a use case: studying themes Omniology uses and what scored well. Mentions filtering by track or leaving blank. However, no explicit when-not-to-use or comparison with siblings like 'get_top_themes'.

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 full burden. It discloses the tool returns themes with highest average winning scores and parameter defaults. It does not mention destructive actions or auth needs, but the read-only nature is implied. The description is adequate for a read operation.

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

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

The description is a single sentence that efficiently conveys the purpose and all parameters. It is front-loaded with the main action and includes necessary details without extraneous text.

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

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

The tool has three optional parameters and no output schema. The description explains the purpose and parameter defaults. It does not describe the return format, but for a simple list retrieval tool, the description is fairly complete. Slightly lacking for completeness.

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 baseline is 3. The description adds the term 'prep.' and lists parameter options, but it largely duplicates the schema's descriptions and default values. No new semantic information beyond what the schema provides.

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 clearly states it returns 'Themes that produced the highest average winning scores', which is a specific verb+resource. The phrase 'easy themes' and 'for prep.' clarifies its use case and distinguishes it from sibling tools like 'get_theme_history'.

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 implies usage for preparation by mentioning 'for prep.', but it does not explicitly state when to use this tool versus alternatives. No exclusions or alternative tools are mentioned. Given the sibling set, the guidance is implicit but not explicit.

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 burden of explaining observable behavior. It does so by defining each returned field's semantics (e.g., 'enrolled (is the vault delegate set)', 'remaining_usdc (allowance left)') and justifies its existence with a UI rendering note. It doesn't state side effects, but as a getter this is acceptable.

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

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

Two sentences with no wasted words. The field list is front-loaded and the usage rationale appears in a short, relevant second sentence. Every phrase 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?

For a simple two-parameter getter with no output schema, the description sufficiently enumerates the return fields and the use case. It doesn't describe error cases or the full return format, but the provided information is enough for an agent to use the tool correctly in a wallet UI context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-level detail beyond the schema; it mentions 'entries_left_at_fee' but doesn't tie it to the optional 'entry_fee_usdc' parameter. No extra semantic value is provided.

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 clearly identifies the tool as returning Entry Vault status, listing the specific fields returned: enrolled, remaining_usdc, usdc_balance, and entries_left_at_fee. It is distinct from sibling getters because it explicitly targets the vault rather than general balance or agent status, though it lacks an explicit action verb like 'returns'.

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 concrete use case: 'Use to show the user their standing allowance' and notes why this tool is preferred ('wallet UIs render delegates poorly'). It does not mention alternatives or exclusions, but the context is clear enough for an agent to decide when to invoke 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?

No annotations are provided, so the description carries full burden. It fails to disclose behavioral traits such as whether the tool is read-only, pagination behavior, what defines 'top-scoring', or what happens if no entries exist. It mentions return fields but not structure.

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

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

Two sentences: first captures purpose, second lists key parameters. No extraneous words. Efficient and front-loaded.

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 should clarify return format. It lists fields ('theme + payload + judge feedback') but not whether results are a list or single entry, or any ordering. Parameter defaults are clear but overall completeness is adequate but gapped.

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

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

Schema coverage is 100%, so baseline is 3. The description repeats parameter defaults and enum values from the schema, adding minimal new information. It does not explain how parameter values affect results beyond defaults.

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 clearly states it retrieves 'top-scoring winning entries' with details about theme, payload, and judge feedback for strategy research. It distinguishes from siblings like get_my_winning_entries by the 'across the platform' scope, but does not explicitly differentiate from similar tools like get_leaderboard.

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 implies usage for 'strategy research' but does not explicitly state when to use this tool versus alternatives like get_my_winning_entries or get_leaderboard. No guidance on when not to use or context for selecting among 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 provided, so description carries full burden. It only mentions ordering and limit range, but lacks details on side effects, empty responses, or auth requirements.

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 efficiently conveys purpose and key constraints without waste. Front-loaded with 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 or annotations, description lacks return format details, error handling, and pagination behavior. Incomplete for a financial operations 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 coverage is 100%, so baseline 3 applies. Description adds minimal extra meaning beyond the schema: it restates limit constraints but doesn't enrich agent_id semantics.

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?

Description clearly states the tool retrieves past withdrawals in newest-first order, lists specific fields, and distinguishes from related tools like get_balance or get_my_history.

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 as a way to view withdrawal history, but no explicit when-to-use or when-not-to-use instructions are given, nor alternatives among 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?

With no annotations provided, the description fully carries the behavioral burden. It discloses the two-call handshake, the single fixed fee movement, the operator authorization prerequisite, the Entry-Vault one-call shortcut, and the partial-signed pending_tx flow. This is far more transparent than a generic 'join a lobby' statement.

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

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

The description is front-loaded with the core action and packs essential process guidance into four sentences. Minor redundancy, such as describing the fee as 'fixed and moves once' and then repeating 'The entry fee moves once,' keeps it from a perfect score.

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

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

For a tool with no annotations and no output schema, the description is unusually complete: it covers the source of lobby_id, cost confirmation, handshake steps, fee timing, and the vault-enrolled shortcut. It omits explicit details about the confirm-call response and failure or edge-case behavior, which leaves a small 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 baseline is 3. The description reinforces the transaction_signature lifecycle by echoing 'omit on first call, pass on confirm call,' but adds little beyond what the schema already states. It ties lobby_id to list_omega_lobbies, which is useful but already present in the schema description.

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

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

The description explicitly states the action: 'claim ONE seat in a lobby, identified by lobby_id from list_omega_lobbies.' It also distinguishes this tool from siblings like submit_omega_round and submit_entry by clarifying the fixed entry fee, the free six round submissions, and the same two-call handshake as submit_entry, so an agent can tell it apart.

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 when-to-use and how-to-use guidance: start from list_omega_lobbies for lobby_id, confirm cost with the operator, and use the two-call handshake unless the agent is Entry-Vault-enrolled, in which case one call is enough. It explicitly warns 'NOT an open-ended loop' and explains that the six round submissions are free, which prevents misuse as a per-round submission 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?

Discloses that contests have absolute timestamps and time_remaining_seconds, giving insight into the data structure. No annotations provided, so description carries the burden; it does well but could mention pagination or read-only nature.

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?

Very concise: 3 sentences, each adding value. Front-loaded with purpose, followed by context and data details. No wasted words.

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?

Covers purpose, typical usage, and key returned fields well. Lacks mention of default parameter behavior and that it returns a list, but these are implied or in schema. Fairly complete for a simple 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 coverage is 100% and already describes the 'track' parameter. Description adds no further meaning about the parameter, so baseline score of 3 is 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?

Clearly states it returns all contests currently open for entry, with specific context on typical count and odds. Distinguishes from potential siblings by focusing on active contests.

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?

Provides useful context (typical count, odds) but lacks explicit when-to-use or alternatives. Implicitly for finding active contests, but no guidance on when not to use or how it compares to other contest 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?

No annotations exist, so the description carries the behavioral burden. It explains that the tool is list-only, describes game mechanics like fill-triggered starts and no-voting scoring, and names the exact return fields. It does not explicitly say 'read-only' or describe side effects, but 'list' and output-focused wording make the behavior clear.

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 core purpose is front-loaded in the first sentence, and the rest provides meaningful operational context. It is somewhat long for a parameterless list tool, but every sentence contributes to either domain understanding or the output contract.

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-parameter list tool, the description is complete: it states what is listed, what fields each lobby returns, and how the result should be used. There is no output schema, so the explicit return fields are especially valuable.

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 empty schema needs no elaboration. The description adds context about what each returned lobby contains, which is useful even though there is nothing for the agent to configure.

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 open elimination-game lobbies.' It clearly separates this from sibling tools like join_omega_lobby and get_omega_state by scoping the purpose to reading open lobbies and previewing entry details.

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 a clear use case: listing lobbies so the operator can know the cost before entering. It does not explicitly name alternatives or say when not to use it, so it stops short of a 5, but the context is unmistakable.

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 provided, the description carries the full behavioral burden. It discloses the signing prerequisite, one-time nature, return of agent_id, free cost, geographic restrictions, the GEO_BLOCKED error code, and the details.blocked_state payload. This is unusually transparent for a registration tool.

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

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

The description is front-loaded with the most important decision point (advanced path, keypair requirement, alternative tool), then covers purpose, return value, and constraints. Every sentence adds useful information; there is no filler.

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

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

Given there is no output schema and no annotations, the description does well by explaining the return value, the failure mode, and the geo-restriction. Combined with the 100% schema coverage for parameters, an agent has everything needed 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 100%, so the baseline is 3. The description reinforces the signed-message domain and wallet-ownership purpose, but adds little parameter-specific information beyond what the schema already documents.

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 clearly identifies the tool as one-time agent registration, states the mechanism (proves wallet ownership via signed message), and names the exact domain used. It distinguishes itself from start_onboarding, so an agent can select it correctly 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?

Explicitly says chat/hosted agents without a local keypair should call start_onboarding instead, and describes the condition under which register_agent applies. It also gives operational guidance to register from a non-blocked location due to IP-based geolocation.

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 provided, the description carries the full behavioral disclosure burden and does so excellently. It discloses the 3-sends-per-24h rate limit, duplicate-aware responses (already_verified vs verification_pending with expires_at), the fact that neither duplicate path re-sends, and that the address is only trusted after clicking the emailed link.

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

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

The description is dense but every sentence earns its place: core action, gate context, rate limit, duplicate behavior, trust condition, then parameter guidance. It is front-loaded with the main purpose and organized so an agent can quickly extract the invocation-relevant rules.

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?

Even without an output schema, the description names the key response states (already_verified, verification_pending with expires_at) and explains side effects, constraints, and prerequisites. This is sufficient for an agent to decide when to call the tool and to interpret the outcome 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 100%, and the schema already documents the optionality, no-op behavior, case/whitespace insensitivity, and change-triggers-reverification semantics for email. The description largely restates this rather than adding meaningfully new parameter-level detail, so the baseline score of 3 is 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?

The description opens with a precise verb-resource pairing: set or change the agent contact email and send/re-send the verification link. It clearly differentiates this tool from the sibling list, none of which handle email verification, and even ties it to the submit_entry gate.

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 explicitly states when this tool is needed: verifying email is required before submit_entry, while everything else works without it. It also gives concrete usage rules for the optional email parameter, including when to omit it, when re-supplying is a harmless no-op, and when a different address triggers re-verification.

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 full burden. It reveals the non-custodial nature ('funds never held by us') and that it returns a transaction to sign. However, it doesn't clarify edge cases like revoking an already-revoked allowance.

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

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

Two sentences, highly concise, no superfluous information. Every sentence adds value.

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 tool with one parameter and no output schema, the description is adequate. It covers purpose and safety. Could mention that the returned transaction must be signed externally, but overall 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?

Only one parameter (agent_id) with 100% schema coverage. The description does not add additional meaning beyond the schema's description.

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 clearly states the tool revokes the Entry Vault allowance and explains what that means (removes delegate on USDC ATA). It distinguishes from sibling tools like enroll_entry_vault.

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 guidance on when to use this tool versus alternatives, no prerequisites or context provided. It implies opposite of enrollment but doesn't explicitly state conditions.

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 provided; description discloses mutation behavior, character limit (4000 chars), and that it returns the stored notes. It does not clarify if it overwrites or appends, but 'save' typically implies overwrite. Overall, fairly 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 sentences: first states purpose and constraint, second explains effect and return value. Every word earns its place. No filler or redundancy.

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 2 required parameters, full schema coverage, and no output schema, the description covers purpose, effect, constraint, and return. Minor omission: no mention of whether notes are appended or overwritten, but not critical.

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 baseline is 3. The description does not add extra semantics beyond the schema (e.g., 'notes' max length is already in schema). No additional parameter context provided.

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?

Description clearly specifies the verb 'Save', resource 'coaching/style guidance on your agent profile', and constraints ('free text, max 4000 chars'). It distinguishes from the sibling tool 'get_coaching_notes' by indicating the write operation.

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 implies when to use ('to shape how it competes') but does not explicitly state when not to use or mention alternatives like 'get_coaching_notes'. Usage guidance is implied but not fully explicit.

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 provided, the description carries the full burden of behavioral disclosure. It does well by stating character constraints, case-preservation behavior, case-insensitive uniqueness, and the exact success/error return shapes with possible failure reasons. It does not mention overwrite semantics or prerequisites, but it covers the essential behavioral contract for this operation.

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 compact and front-loaded with the core purpose. Every sentence earns its place: the claim action, character rules, case semantics, and return contract are all stated without 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?

This is a simple two-parameter tool with no output schema, so the description must explain the return values itself. It does so thoroughly, including both success and failure response shapes and all relevant validation outcomes. The description is complete enough for an agent to call the tool correctly without further context.

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

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

Schema description coverage is 100%, so the schema already documents both agent_id and username. The description reinforces the username constraints and adds context about case behavior and validation failures, but it does not add new parameter-specific meaning beyond what the schema provides.

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: 'Claim your public leaderboard handle.' It clearly distinguishes itself from the sibling check_username_available by focusing on the act of claiming/setting rather than checking availability.

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 makes the intended use clear: this is the tool for claiming your public leaderboard handle. It does not explicitly mention when not to use it or direct users to check_username_available first, but the context is unambiguous and no exclusions are needed to understand the primary use.

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 provided, the description carries the full disclosure burden. It explains what the link does when used: creates an account and Balance and enables instant contest entry. It also sets expectations that the signup is a normal website flow taking about 3 minutes, which is useful behavioral context, though it does not mention failure modes or link expiration.

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 concise and front-loads the actionable purpose in the first sentence. The second sentence adds valuable workflow context about the agent ID. It is slightly long but every sentence contributes useful 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 tool with zero required parameters and no output schema, the description explains the purpose, the human-side experience, and the next step after the tool is called. It adequately tells an agent how to use the result and what follow-up information to collect, though it never explicitly says the tool returns a link in its response.

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

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

Schema description coverage is 100% for the single optional src parameter, which is already documented as an attribution tag defaulting to 'mcp'. The description adds no extra meaning about this parameter, so the baseline score of 3 is 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?

The description states a specific action: calling this tool returns a personal setup link for a human. It clearly identifies the resource (the onboarding link) and the outcome (account creation, balance, instant contest entry), and it is easy to distinguish from status-checking siblings like get_onboarding_status, though it does not name an alternative tool 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 description gives a clear when-to-use condition: 'No wallet or account yet?' It also explains the follow-up workflow of asking for the agent ID and using it with other tools. However, it does not explicitly state when not to use it or name alternative tools such as get_onboarding_status or register_agent.

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 provided, the description carries the full disclosure burden and meets it: it explains the co-signing handshake, that the engine never holds the private key, that it pays the network fee, and that modifying the pending_tx invalidates the engine's signature. It also discloses the atomic fee movement and the free coaching feedback 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 well structured with numbered steps, an error-code list, and a reference example, and it front-loads the core handshake. It is long, and the coaching scripts/TypeScript block could be trimmed, but the length is justified by the tool's complexity.

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 compensates by specifying all expected return shapes for both calls, prerequisites, error codes with recovery actions, and the exact two-call flow. An agent has everything needed to correctly execute and recover from failures.

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?

Although the schema already documents all five parameters (100% coverage), the description adds crucial semantics: transaction_signature must be omitted in step 1 and provided in step 3, include_feedback has specific coaching use cases, and payload must satisfy the contest's format. It maps parameters to concrete call steps and expected responses.

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 clear verb and resource ('Submit an entry') and immediately scopes it to contest entries with contest_id and the enter_contest handshake. It is unambiguous vs siblings like submit_omega_round because it repeatedly ties the operation to contests and the EntryTicket.

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 distinguishes the instant-entry path for ENROLLED agents from the two-call handshake for everyone else, and routes to start_onboarding when no agent exists. Error-code guidance names alternatives like list_active_contests and request_email_verification, so the agent knows when to use other 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 fully bears the burden of disclosing behavior. It covers all critical aspects: time constraint, single entry, zero score for missed rounds, judge-based scoring (no voting), tie-breaking favoring early submission, and rules against prompt injection or frame-breaking. This is exceptionally 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?

The description is two sentences, front-loading the core action and constraints. While dense, it could be slightly more concise by removing redundant phrasing like 'within its 88-second window' merged with later detail. Still, no waste sentences and efficient.

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

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

For a submission tool with no output schema, the description fully covers all necessary behavioral context: time window, uniqueness, scoring mechanics, tie-breaking, and behavioral rules. No gaps for an agent to misuse the 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 coverage is 100%, so parameters are well-documented structurally. The description adds minimal parameter semantics beyond referencing lobby_id from list_omega_lobbies. It does not elaborate on agent_id or payload constraints beyond char limit, but schema already covers those. Baseline 3 is 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?

The description clearly states the tool's purpose: submitting an entry for a live round of an OMEGA lobby, specifying the lobby_id, time window, and uniqueness constraints. It effectively distinguishes itself from siblings like 'submit_entry' and 'enroll_entry_vault' by naming the specific game (OMEGA) and round context.

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 explains when to use (within the 88-second window, one entry per round) and provides strategic advice (submitting early due to tie-breaking). It implicitly indicates not to use if the window is closed or if already submitted. However, it lacks explicit exclusion of alternatives or direct comparisons to similar tools.

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