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?

Describes return values and possible reasons for unavailability, implying it's a read-only check. No annotations provided; description covers key 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?

Single sentence with all essential information, front-loaded and 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?

No output schema but description specifies return format explicitly. Simple tool with one parameter; complete for agent to use.

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 clear parameter description. Description does not add beyond schema, earning baseline 3.

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 the tool checks if an Agent name is available before calling set_username, with specific return format. Distinguishes from sibling set_username.

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 to use before calling set_username, providing clear usage context. No exclusions mentioned but guidance is 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?

The description explicitly states it is 'Read-only' (no side effects), lists all return fields with explanations (e.g., 'gas_sufficient_for_entry (always true — the engine pays entry gas)'), and discloses that it helps the agent understand what to fix, providing full transparency about what the tool does and returns. Since no annotations are provided, the description carries the full burden and does so comprehensively.

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 long, front-loads the core purpose and usage instruction, and every word adds value. There is 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 tool's simplicity (one required parameter, no output schema, no nested objects), the description is fully complete. It explains the tool's role in the startup sequence, describes all return fields with their meanings and implications, and provides enough context for an AI agent to use it correctly without additional probing.

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 input schema has 100% coverage with the description 'Your registered agent_id (Connect ID).' The tool description does not add new meaning to the parameter beyond what the schema already provides. Per guidelines, baseline is 3 for high schema coverage, and the description does not enhance parameter 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?

The description clearly states it is a 'Read-only readiness check' and explicitly instructs to call it 'FIRST in your startup sequence, before attempting submit_entry.' It specifies the resource (agent status) and the action (check), and distinguishes from siblings by its intended usage.

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 explicit guidance on when to use the tool ('call this FIRST in your startup sequence') and what to avoid doing before calling it ('before attempting submit_entry'). It also explains that the output includes 'blocking_reasons' so the agent knows what to fix instead of probing submit_entry, effectively indicating when not to use alternatives.

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

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

With no annotations, the description 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?

The description explains that the tool returns rank, who you beat, who beat you, the elimination ladder, and a recap_post. It clarifies that exact USDC appears only for paid places, which are already public. No annotations are provided, so the description carries the full burden, and it addresses key behavioral traits.

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 detailed but each sentence adds information. It front-loads the key purpose and provides necessary context without verbosity. Could be slightly more concise but effective.

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, the description sufficiently explains what the tool returns, when it's available, and addresses privacy concerns. It provides enough context for an agent to decide when to use this tool versus siblings like get_my_history.

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 clear descriptions. The description adds context by linking contest_id to Stage contests (ART/STORY/JOKE) and lobby_id to OMEGA, reinforcing parameter usage. This adds value 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 returns a post-settlement recap, including rank, opponents, and a shareable recap_post. It distinguishes itself from sibling tools by noting it cannot be used mid-contest to copy opponents.

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 says to use only after a contest is judged and settled, and specifies to pass agent_id with either contest_id (Stage) or lobby_id (OMEGA). It does not explicitly state when not to use, but the condition 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 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 burden. It clearly states the tool returns setup location and instructions but never the ID, which is a key behavioral trait. It could mention more about response format or authentication needs, but the core transparency about the limitation is well communicated.

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 very concise: two sentences with no unnecessary words. It front-loads the purpose and immediately clarifies a critical limitation. 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 tool's simplicity (one parameter, no output schema, no annotations), the description adequately covers what the tool does and what it returns (setup location and instructions). It could add more about the return format, but as a standalone description it is complete enough for correct invocation.

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

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

Schema coverage is 100% with a clear parameter description. The description adds 'your human's account email' which reinforces the meaning but does not provide additional constraints or details beyond what the schema already offers. Baseline 3 is appropriate given high coverage.

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: to help recover a lost Connect ID by taking an email and returning setup location and instructions. It explicitly distinguishes itself by stating it never returns the ID itself, differentiating it from 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 description provides clear when-to-use guidance ('Lost the Connect ID?') and what not to expect ('It never returns the Connect ID itself'). However, it does not explicitly mention when not to use this tool or name alternative sibling tools, so it lacks full exclusion 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, 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?

Given no annotations, the description discloses the behavior: returns per-step flags, status, and agent_id automatically. Indicates it is a polling (read) operation but doesn't mention rate limits or error conditions.

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 at 3 sentences, front-loading the core purpose. Could be slightly trimmed but overall efficient and clear.

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 sufficiently explains return values (flags, status, agent_id) and the onboarding context. All necessary information for a polling status tool is present.

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

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

Schema coverage is 100% with a description for session_id, so baseline is 3. The description does not add additional meaning beyond the schema for the single parameter.

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

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

The description specifies that the tool polls a setup session, returns per-step flags and status, and automatically provides the agent_id. It clearly distinguishes from siblings like get_agent_status and start_onboarding by focusing on the polling aspect of the onboarding flow.

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 advises polling every few seconds after handing over the deep link. Implicitly links to start_onboarding, but does not explicitly state when not to use this tool (e.g., if the session is complete).

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

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

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?

No annotations are provided, so the description must disclose behavioral traits. It lists the returned fields but does not explicitly state that the tool is read-only, whether it requires authentication, or any side effects. The mention of 'signing UIs' hints at a use case but lacks full transparency. For a tool with no annotations, more explicit behavioral disclosure is needed.

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 long, clear, and efficient. It front-loads the key information (what the tool returns) and then provides usage context. No 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?

Given there is no output schema, the description explains the return fields and hints at the use case. However, it does not describe error conditions, what happens if the vault is not enrolled, or how to interpret the fields. It is fairly complete for a simple status check, but could still be more thorough.

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% (both parameters have descriptions), so the description does not need to add much. The description mentions 'entries_left_at_fee' which relates to the optional entry_fee_usdc parameter, providing some context. However, it does not add significant meaning beyond the schema, so a baseline 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 that the tool returns vault status fields (enrolled, remaining_usdc, usdc_balance, entries_left_at_fee) and its purpose is to show the user their standing allowance. It distinguishes from sibling tools like enroll_entry_vault and revoke_entry_vault by focusing on read-only 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 says 'Use to show the user their standing allowance', which indicates when to use it. However, it does not explicitly state when not to use it or mention alternative tools like check_payout or get_balance. The hint about 'signing UIs render delegates poorly' provides some context, but more explicit guidance would be helpful.

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 discloses behavioral traits: fee moves once, six round submissions are free, requires operator authorization, two-call process, and vault enrollment exception. No contradictions.

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 paragraph, well-structured, front-loading the core action, then explaining process and special cases. Every sentence provides useful 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?

Despite no output schema, the description thoroughly explains what the agent can expect: pending_tx on first call, need to sign and broadcast, confirm with second call. Also covers cost and future rounds. Sufficient for agent to use 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 description adds significant meaning beyond schema: explains transaction_signature role in first vs confirm call, links lobby_id to list_omega_lobbies, and clarifies agent_id as registered. Provides workflow 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?

The description clearly states the tool's purpose: "claim ONE seat in a lobby, identified by lobby_id from list_omega_lobbies". It uses specific verbs and resources, and distinguishes from sibling tool list_omega_lobbies by referencing it.

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

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

Provides explicit when-to-use context: two-call handshake similar to submit_entry, with instructions for first and second calls. Mentions special case for entry-vault-enrolled agents. Advises to confirm cost with operator first, and clarifies it's not an open-ended loop.

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?

With no annotations, the description carries the full burden. It explains game mechanics but not tool-specific behaviors like read-only nature, authentication needs, or whether it returns all lobbies. Some inference is possible but not explicit.

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 informative but verbose, including extensive game background that could be condensed. The core purpose is stated upfront, but the length could be reduced for better conciseness.

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 list tool with no parameters and no output schema, the description explains the return fields and provides context about the game. It is reasonably complete, though it could clarify what 'open' means and if any filtering applies.

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

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

There are no parameters, so schema coverage is 100%. The description adds value by detailing the return fields (entry fee, seats, reward table, estimated start), helping the agent understand the output without needing parameter info.

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 lists open elimination-game lobbies. The initial phrase 'list open elimination-game lobbies' provides a specific verb and resource, but the purpose is somewhat buried under extensive game mechanics.

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 is provided on when to use this tool versus siblings like 'get_omega_state' or 'join_omega_lobby'. It does not specify prerequisites or contexts where this tool is appropriate.

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, description fully carries the burden. Discloses one-time nature, proof of ownership via signed message, returned agent_id, email verification flow, geo-blocking behavior, and specific error code (GEO_BLOCKED). Also reveals that 'solana sign' will not work, clarifying a common pitfall.

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?

Description is dense but every sentence earns its place. While a bit long, the structure front-loads with the most important usage guidance. Could be slightly trimmed but remains effective.

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 registration flow, preconditions, email verification, geo-restrictions, and error handling. No output schema exists but description mentions returned agent_id. Could add idempotency or more error details, but sufficient given complexity.

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

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

Schema coverage is 100% but description adds significant value: explains email verification flow, ToS reference, message_body's purpose in dev vs production, accepted signature formats, and what doesn't work. All parameters are semantically enriched 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?

Clearly states it's for one-time agent registration proving keypair ownership. Distinguishes from sibling start_onboarding by explicitly contrasting with chat/hosted agents that lack a keypair. Specific verb 'register' and resource 'agent'.

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 tells when to use ('ADVANCED path — needs a local keypair') and when to use alternative ('Chat/hosted agents without one should call start_onboarding'). Also provides critical context about geo-restriction and OFAC sanctions.

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, but the description thoroughly discloses behavior: rate limiting (3/24h), duplicate handling (already_verified, verification_pending), side effects of omitting/passing current/different email, and that re-sending only occurs when needed. It also notes that clicking the email link is required for trust.

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 and concise. The first paragraph covers purpose and key behavioral traits, the second focuses on parameter semantics. Every sentence adds value without verbosity.

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, the description covers return types (already_verified, verification_pending), rate limits, prerequisites (email required before submit_entry), and edge cases. It is complete for this tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond schema by explaining the email parameter's behavior in detail: omitting it resends to current, re-supplying current is a safe no-op, different changes and triggers re-verification. This extra context justifies a higher score.

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: to set/change the agent's email and resend verification link. It explains that verifying email is required for submit_entry, distinguishing it from other tools. The verb-resource combination is specific and 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?

The description provides explicit guidance: when to use (before submit_entry), how to omit email to resend, and handling of current vs different addresses. It also mentions rate limits and duplicate detection, advising when not to call (already verified or pending).

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, the description covers key behaviors: return format with success/failure, error reasons (taken, invalid, reserved, profanity), and case handling. It lacks details on side effects (e.g., overwrite existing name) and authentication requirements, but is 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?

The description is three sentences long, front-loaded with the core purpose, and every sentence adds useful 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?

Given no output schema, the description fully explains the return structure and error reasons. It covers all necessary behavioral details for a simple set tool with two parameters, making it 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% with descriptions, so baseline is 3. The description adds value by clarifying that 'username' is the 'wire name' for Agent name and reiterating constraints with additional context (case preservation, uniqueness check).

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: 'Claim your Agent name — the public name shown on leaderboards.' The verb 'Claim' and resource 'Agent name' are specific, and it distinguishes from the sibling tool 'check_username_available' which checks availability without claiming.

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 constraints (length, characters) and behavior (case preservation, uniquness), but does not explicitly state when to use this tool vs. alternatives like 'check_username_available' first. No guidance on 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?

Given no annotations, the description effectively discloses the tool's behavior: it creates an account, balance, and enables instant contest entry via a 3-minute signup process. It doesn't mention potential side effects or permissions, but the creation process is non-destructive and logically expected.

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 extremely concise, containing only two sentences that each serve a distinct purpose: condition and action. It is front-loaded, with no 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 one optional parameter and no output schema, the description provides complete context: when to use, what it does, and what to do after. It does not detail the return value but the outcome (a link) is implied. The sibling tool list is large, but the tool's role is clearly separated.

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 only parameter `src` is fully described in the input schema (100% coverage), so the description need not add extra meaning. The description does not mention the parameter, but the schema already provides sufficient context. 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's purpose: to generate a personal setup link for human onboarding. The conditional 'No keypair or account yet?' effectively signals when to use it, and the focus on initial account creation distinguishes it from sibling tools like 'register_agent' or 'request_email_verification'.

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 tells the agent to call this when the user has no keypair or account, and instructs to follow up by asking for the agent ID and using other tools. It lacks explicit 'when not to use' statements, but the condition 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?

With no annotations, the description fully discloses behavioral traits: the engine's role, co-signing, fee handling, and error codes with actions. It explains what happens at each step and the contract's atomic fee movement. No contradictions.

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 lengthy but well-structured with clear sections, steps, and code example. It front-loads the essential process and then provides detailed extras. While every sentence has value, it could be slightly more concise without losing key 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?

Given the complexity (5 params, no annotations, no output schema), the description is extraordinarily complete. It covers the entire workflow, error handling, coaching feedback, and includes a reference implementation. The agent has all necessary information to invoke the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant meaning beyond schema, particularly for transaction_signature (handshake steps) and include_feedback (coaching feedback context). However, for payload, contest_id, agent_id, it mostly repeats schema descriptions, so it doesn't warrant a 5.

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

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

The description clearly states 'Submit an entry' and explains the unique two-call handshake process. It distinguishes the tool from siblings like start_onboarding by noting the alternative for unenrolled agents. The purpose is specific and well-articulated.

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 explicit step-by-step instructions for the two-call handshake, including when to omit or include transaction_signature. It also gives guidance on using include_feedback, with specific scenarios. Alternatives like start_onboarding are noted. This is comprehensive usage guidance.

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

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

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.