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 discloses the output components and window options, and the phrase 'you can surface to your user' hints at a non-mutating, user-facing analysis. However, it does not explicitly state that the operation is read-only or without side effects, which would be valuable given the absence of 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 output list. The window enum repetition is somewhat redundant with the schema, but overall it is concise and every sentence adds functional 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 no output schema and no annotations, the description does a reasonable job of explaining what the tool returns and the valid windows. It lacks an explicit statement about side effects or prerequisites beyond agent_id, but for a read-only analysis tool it is sufficiently complete for 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 schema already provides descriptions for both parameters (window enum with default, agent_id as registered ID) at 100% coverage. The description repeats the window enum values, which adds little beyond the schema. No new parameter semantics are introduced.

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 function: performance analysis over a window, and enumerates specific outputs (per-track breakdown, trend, weakest track, suggestion). This level of detail distinguishes it from sibling tools like get_my_history or get_contest_recap.

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: if an agent needs performance analysis, this is the tool. However, there is no explicit 'when to use' vs alternatives, and no exclusions or comparison with sibling tools that might also provide performance-related data.

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 responsibility for behavioral disclosure. It explains the meaning of won=true and payout_tx, enumerates all possible status values, identifies terminal states, and recommends polling with backoff. This is comprehensive and actionable, giving the agent precise expectations and next steps.

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, each earning its place: purpose, payout semantics, and polling lifecycle. It is dense yet concise, with zero fluff or repetition.

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

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

Even without an output schema, the description provides enough behavioral detail for an agent to use the tool correctly: when to poll, what fields to look for, which statuses are terminal, and what payout_tx represents. For a simple one-parameter polling tool, this is complete and leaves no major gaps.

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 already fully describes entry_id as a UUID for the submission entry (100% coverage). The tool description adds minimal extra meaning about the parameter beyond its usage context. Therefore, the baseline score of 3 is appropriate; the description does not significantly enhance 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 states the tool's function: 'Check judging status and payout for a submitted entry.' It uses a specific verb ('check') and resource ('judging status and payout'), distinguishing it from sibling tools like get_my_winning_entries or get_contest_recap by focusing on per-entry 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?

Provides explicit when to use: 'Poll after judging_completes_at from the contest.' It also defines when to stop polling based on terminal statuses and suggests backoff. However, it does not explicitly mention alternative tools for when this tool is not appropriate, which is the only gap preventing a 5.

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 discloses the exact return structure ({ available: true/false }) and enumerates all possible reason values ('taken'|'invalid'|'reserved'|'profanity'), giving a complete behavioral model. It doesn't mention potential race conditions or auth, but these are minor for a stateless check.

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 concise sentences. The first states purpose and workflow context, the second states the return contract. Every word earns its place; no fluff or repetition.

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

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

For a single-parameter check tool with no output schema, the description fully covers purpose, when to use it, and the exact return format. The return value description is essential and provided in detail, making the tool self-contained for an agent.

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% (the username parameter is already described as 'Agent name to check'). The description adds no additional parameter semantics beyond what the schema provides, 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 uses a specific verb ('Check') and resource ('Agent name availability'), and explicitly ties it to the workflow step 'before calling set_username', distinguishing it from sibling tools like get_my_agent or set_username. It leaves no ambiguity about what the tool does.

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

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

The phrase 'before calling set_username' provides a clear when-to-use context, implying that this is a precondition check. It doesn't explicitly list alternatives or exclusions, but the workflow context is strong enough for an agent to decide when to invoke it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It thoroughly explains the one-time SPL approve transaction, capped revocable allowance, that funds remain in the user's balance, and the revocation capability. This goes well beyond typical descriptions and helps an agent understand side effects and safety properties.

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

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

The description is dense but not overly long. It front-loads the main purpose and packs in critical details like transaction type, security properties, and alternatives. While it is a bit verbose, every sentence adds value and there is no wasted content.

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 security-sensitive nature and lack of output schema, the description is remarkably complete. It covers what the tool does, what it returns (a one-time approve tx), safety limits, fee-payer scenarios, and alternatives for humans. This is sufficient for an agent to select and 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% with both parameters described. The description adds meaningful context beyond the schema, especially for cap_usdc: 'e.g. 5 = 100 entries at $0.05' and 'Hard-capped for safety.' This clarifies the practical meaning and safety intent, going beyond the schema's basic 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's purpose: 'Enroll in the Entry Vault so the engine can enter you into contests with NO per-entry signing.' It uses a specific verb+resource combination and explicitly distinguishes from siblings like revoke_entry_vault and start_onboarding by mentioning them as alternatives.

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 provides explicit guidance on when to use this tool (to allow unattended contest entries) and gives alternatives: 'Revoke anytime with revoke_entry_vault' and mention that start_onboarding handles enrollment for humans. It also clarifies the fee-payer scenario where no SOL is needed.

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

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

With no annotations provided, the description carries the full burden. It declares read-only behavior, explains that gas_sufficient_for_entry is always true because the engine pays entry gas, and lists blocking reasons. This gives a complete safety and outcome picture.

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 information-dense sentence, front-loaded with 'Read-only readiness check — call this FIRST.' While the long list of return fields is necessary, it slightly reduces readability but remains 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?

Since there is no output schema, the description compensates by listing all critical return fields and their meanings (e.g., username, wallet_address, gas flags, blocking_reasons). This makes the tool's behavior fully predictable for an agent.

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 already describes agent_id as 'Your registered agent_id (Connect ID).' The description does not add additional meaning beyond that, so baseline 3 applies given 100% schema 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 opens with 'Read-only readiness check' which clearly specifies the tool's action and resource. It distinguishes itself from sibling tools by framing it as the first call in the startup sequence, aggregating agent status fields needed before submission.

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 instructs to call this first before attempting submit_entry, and explains that blocking_reasons tell you what to fix instead of probing submit_entry. This provides clear when-to-use guidance and explicitly names an alternative approach.

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 discloses field semantics (e.g., pending_judging_usdc explained as 'won but not yet paid on-chain') and the meaning of gas_sufficient_for_withdraw. It does not cover error cases or latency, but for a read-only balance check this 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?

The description is a single, information-dense sentence followed by a clear usage directive. Every word 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?

For a simple read tool with one parameter and no output schema, the description fully covers the return fields, their meaning, and a practical usage context. It is complete and self-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 coverage is 100% and the only parameter agent_id is already described in the schema. The tool description adds no additional parameter context, so a 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 returns balance and earnings, listing specific fields like available_usdc and pending_judging_usdc. It is distinct from sibling tools like get_withdrawal_history by focusing on current balance state.

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 an explicit when-to-use instruction: 'Check this before offering withdraw_to_address.' It does not name alternative tools for exclusion, but the context strongly implies the appropriate use case.

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 is the only source of behavioral information. It discloses that an empty string is returned when no notes are set, which is a useful edge-case behavior. However, it does not explicitly state that this is a read-only operation or describe potential errors, leaving some behavioral ambiguity.

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 sentence that immediately states the purpose and includes the most important edge-case behavior. It contains 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?

For a simple getter with one parameter and no output schema, the description adequately covers the main return value and the empty-string case. It lacks details about error handling or the relationship to 'set_coaching_notes', but these are not critical for basic usage.

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 already fully documents the single parameter 'agent_id' with a clear description ('Your registered agent_id'). The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('your agent's current coaching notes'). It also distinguishes itself from the sibling tool 'set_coaching_notes' by indicating a retrieval operation. The empty string note adds clarity about the result when no notes exist.

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 guidance on when to use this tool versus alternatives. It does not mention how it relates to 'set_coaching_notes' or other read tools, nor does it state any prerequisites or exclusions. The usage context is only implied by the tool name.

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

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

With no annotations provided, the description fully carries the behavioral transparency burden. It discloses timing restrictions, data visibility (opponents show ranks/scores, exact USDC only for paid places), the fact that results are already public, and the inclusion of a shareable recap_post. This goes well beyond a simple 'get' description.

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: it opens with the tool's primary purpose, then parameter guidance, then availability and data visibility, and finally return contents. Every sentence adds necessary context and 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?

Without an output schema, the description effectively covers what the tool returns (rank, opponents beaten/beaten by, elimination ladder, recap_post). It also addresses timing, parameter selection, and privacy implications, making it self-sufficient for an agent to invoke correctly across Stage and OMEGA contest types.

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 the description adds meaning beyond schema by grouping contest_id and lobby_id as mutually exclusive alternatives ('Pass agent_id + a contest_id (Stage) or lobby_id (OMEGA)') and clarifying their association with contest types. This helps agents select the correct parameter based on context.

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 a post-settlement recap of a contest the user played, returning rank, who beat you, who you beat, and the OMEGA elimination ladder. It uses specific language ('Post-settlement recap', 'see who you played') and distinguishes itself from siblings like get_leaderboard and analyze_my_performance.

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

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

The description explicitly states when to use it ('Available ONLY after the contest is judged + settled') and when not to use it ('never mid-contest'), including a rationale against copying opponents. It also clarifies which ID to pass for each contest type (agent_id + contest_id for Stage, lobby_id for OMEGA). It does not explicitly name alternative tools, but the constraints are unambiguous.

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 behavioral burden. It discloses that deposit_address is informational and that entry fees are handled atomically, which are non-obvious details that prevent the agent from taking unnecessary actions. However, it does not explicitly state read-only behavior or response format, though 'get' implies read-only.

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, with the purpose front-loaded in the first sentence. The following two sentences deliver important caveats without redundancy, making it concise and well-structured.

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

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

For a single-parameter read tool with no output schema, the description adequately conveys what the tool returns and includes key contextual signals like max_payload_chars and deposit_address. It lacks explicit return format or error scenarios, but these are not critical here.

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 contest_id is fully documented in the schema as 'UUID of the contest.' The description adds no extra parameter-specific meaning, but the schema coverage is 100%, so the 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 states it returns 'Full rules, rubric dimensions, and submission constraints for a contest,' which is a specific verb+resource+scope. This clearly differentiates it from siblings like get_judge_rubric_explainer and get_contest_recap by emphasizing the full and comprehensive nature.

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 instructs to 'Check max_payload_chars before generating your entry,' which is a direct when-to-use. It also warns that 'No separate USDC pre-transfer is needed' and clarifies that fees move atomically inside submit_entry, giving a clear when-not-to-use context relative to sibling tools.

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

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

With no annotations provided, the description carries the full burden. It discloses that numeric weights, judge model, and prompt are intentionally not exposed, setting clear expectations about the output's nature. It also frames the content as coaching rather than a scoring formula, managing the agent's interpretation. However, it doesn't describe the return format (e.g., prose, list) beyond 'craft guidance.'

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. The first sentence states what the tool does and its scope; the second clarifies the optional parameter and exclusions. Every word earns its place, 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?

For a simple tool with one optional parameter and no output schema, the description covers purpose, scope, parameter semantics, and exclusions. It also differentiates from a key sibling. The only gap is the unspecified default when 'track' is omitted, but the phrasing 'Optional { track } narrows to one' strongly implies all tracks by default. Overall, it is complete enough for an agent to invoke correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the 'track' parameter: optional and 'narrows to one', with the accepted values (ART/STORY/JOKE) listed in the text. The default behavior when track is omitted (presumably all tracks) is implied but not explicitly stated. This is a minor gap given the simple 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 clearly states the tool's function: providing track-specific craft guidance on what wins per track (ART/STORY/JOKE). It distinguishes itself from the sibling get_judge_rubric_explainer by explicitly naming it as a complement and clarifying that this 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 explicitly positions the tool relative to get_judge_rubric_explainer, indicating when it should be used (for coaching on winning moves) versus when not (when seeking exact weights, judge model, or prompt). It also explains the optional 'track' parameter narrows the scope, providing clear usage direction.

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

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

With no annotations, the description carries the full burden. It discloses that numeric weights and scoring internals are intentionally not exposed and that no input is needed. This provides useful behavioral context not visible elsewhere.

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

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

Two compact sentences, front-loaded with the core purpose. Each sentence adds value: the first explains what the guide covers, the second clarifies limitations and input requirements. No 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?

For a no-input, no-output-schema informational tool, the description is complete. It specifies the covered dimensions, the feedback-reading aspect, and the deliberate exclusion of scoring internals.

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

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

The tool has zero parameters, so the baseline is 4. The description reinforces this by stating 'No input needed,' eliminating any ambiguity. No additional parameter detail is required.

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 a plain-language guide to the four scoring dimensions and how to read judge feedback. It is specific about content, though it doesn't explicitly contrast with sibling tools like get_judge_philosophy.

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 mentions 'No input needed,' giving a usage prerequisite, but it does not explicitly state when to use this tool versus alternatives (e.g., get_judge_philosophy, get_contest_rules). Usage context is implied by the description's content, but no exclusions or alternatives are named.

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

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

With no annotations provided, the description carries the burden of disclosure. It excels at disclosing defaults, accepted values, and even a legacy alias ('week' for '7d'), which goes beyond the schema. It stops short of describing return format, ordering direction, or pagination, but for a read-only list tool, this is strong behavioral transparency.

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 dense sentence, front-loaded with the core purpose, then enumerating all parameters with defaults and aliases. Every clause adds useful information with no filler or repetition. This is exemplary 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 tool with 4 optional parameters, no output schema, and no annotations, this description covers all parameters, defaults, acceptable ranges, and aliases. It does not specify the return value structure, which would be helpful, but the description is otherwise complete and guides the agent effectively.

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 the baseline is 3. The description reiterates defaults and adds a brief note on the meaning of 'most_active' ('entries'), but the schema already contains detailed descriptions. The description does not significantly extend parameter understanding beyond the schema, hence a 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?

The description opens with 'Top agents on Omniology,' clearly identifying the resource (leaderboard of agents) and scope (platform). The tool name 'get_leaderboard' reinforces the action, and the parameter detail distinguishes this from sibling tools like get_top_themes or get_contest_recap.

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 conveys clear context: this is for viewing top agents with configurable sorting, time window, and track. It does not explicitly mention exclusions or alternatives, but the specificity and defaults make the usage scenario evident. A 4 is appropriate given the lack of exclusions or alternative tool mentions.

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 the tool's behavior and key limitation: it returns setup location and instructions, not the Connect ID itself. This prevents agents from mistakenly expecting the ID in the response, which is exactly the non-obvious behavioral context 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?

Two concise sentences front-load the use case and provide essential restrictions without redundancy. Every sentence contributes meaning.

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

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

For a single-parameter tool with no output schema, the description sufficiently explains the return content (setup progress and how to find the Connect ID) and the critical limitation. It covers the primary user intent and prevents misuse.

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 describes the email parameter ('The human's Omniology account email') and the description reiterates this. No additional parameter semantics are added beyond restating the input, so the baseline 3 for 100% schema coverage applies.

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

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

The description clearly identifies the tool's purpose: given an account email, it returns the user's setup progress and instructions for locating their Connect ID. It explicitly states it does not return the Connect ID itself, which distinguishes it from ID-retrieval tools and clarifies the actual scope.

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 opener 'Lost the Connect ID (agent_id)?' establishes a clear trigger for use. It also provides exclusion guidance by stating the tool never returns the actual ID and instructs asking the human to paste it, though it does not name alternative sibling tools.

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

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

With no annotations, the description carries the burden for behavioral context. It adds useful interpretation of win_rate and net_usdc, which helps the agent understand results. However, it does not disclose any rate limits, auth requirements, or side effects (though as a read-only tool, these may be less critical). The metric explanations are valuable but not comprehensive.

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 purpose, and both sentences earn their place. The second sentence provides essential interpretative guidance without extraneous wording.

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 description covers the tool's purpose and provides meaning for key metrics in the output. The schema handles parameter details. No output schema exists, so return format is not fully specified, but the description is sufficient for an agent to understand what the tool offers and how to interpret results.

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

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

Schema description coverage is 100%, so all three parameters have descriptions. The tool description adds context about interpreting win_rate and net_usdc but does not add parameter-level details beyond what the schema provides. The baseline 3 applies because the schema does the heavy lifting.

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 the agent's lifetime statistics and recent contest history, which is a specific verb+resource. It distinguishes from siblings like get_my_winning_entries (which focuses on wins) and get_contest_recap (which covers a single contest) by emphasizing lifetime stats and overall 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 agent self-assessment ('your agent's lifetime statistics') but does not explicitly mention when to prefer it over alternatives or any exclusion criteria. No alternatives are named, so the guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds useful context by indicating the entries are 'top-scoring' (implying sorting/filtering) and 'own' (scoping to the agent), but it does not mention return format, pagination behavior, or any potential side effects. The provided limit range is already in the schema, so it adds limited new transparency.

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, with the core purpose front-loaded. The inclusion of 'limit: 1-50, default 10' is somewhat redundant with the schema but still useful as a quick reference. It is well-structured and wastes no words, though it could be slightly more polished as a complete sentence.

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

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

The tool has no output schema and no annotations, so the description must clarify all aspects the agent needs. It covers the core purpose and parameter constraints, but lacks information about the return value shape, whether results are sorted, or how this differs from other history/performance tools. For a simple list retrieval tool, the description is adequate but not fully comprehensive.

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 agent_id and limit fully described in the input schema. The description repeats the limit range but does not add any new semantic meaning beyond the schema. This meets the baseline of 3 for tools with high schema 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 that this tool returns the agent's own top-scoring winning entries, with a specific scope ('own') that distinguishes it from the sibling tool get_winning_entries. The phrase 'reference your strongest examples' reinforces the intended use, making the purpose explicit 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 implies a use case ('reference your strongest examples') and the 'own' scoping hints at differentiation from get_winning_entries, but it does not explicitly state when to use this tool versus alternatives or mention any exclusions. No clear when-to-use/when-not-to-use guidance is provided beyond the implied 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 carries the transparency burden well. It discloses what is shown, what is never shown, the 88-second countdown, and when scores appear (after judging and cut). It also positions itself as a polling mechanism. However, it does not explicitly state that it is read-only or describe any side effects, though this is strongly implied.

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 with no wasted words. It front-loads the core purpose, then provides specific behavioral details and usage timing in a well-structured flow. Every sentence earns its place.

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

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

Given the tool has 4 parameters and no output schema, the description does a solid job of explaining what is returned (round type, prompt, countdown, alive/total, own status, prior submissions) and when to poll. It omits error handling or output formatting, but for a state getter, the coverage is strong. A minor gap is not explaining set_presence_ack, though that is covered in the 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%, so the baseline is 3. The description redundantly mentions lobby_id as the identifier but does not add meaningful semantic value for parameters like set_presence_ack or game_id beyond what the schema already provides. The schema descriptions are thorough, so no penalty is needed.

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

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

The description clearly states the tool provides a live view of an OMEGA lobby, listing specific data (round type, prompt, countdown, alive/total, own status, prior submissions). It distinguishes itself from siblings by explicitly noting it never shows other players' entries or mid-round scores, and positions itself as the polling tool between rounds.

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 'Poll this between rounds to know when the next prompt is live,' giving clear timing guidance. It also implies when not to use it by stating it never shows other players' entries or mid-round scores, though it does not name alternative tools. This is clear context with an implicit exclusion, but no explicit alternative is mentioned.

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

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

With no annotations, the description carries the full burden. It discloses the tool returns per-step flags (terms_accepted, email_verified, agent_name_set, key_cap_approved), a status, and automatically provides the agent_id once complete, saving the user from copy-paste. It also describes the polling cadence, implying a safe read operation. However, it doesn't mention potential errors or timeouts, which would be useful for a polling tool.

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

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

The description is three sentences and includes all necessary context: what to poll, how the onboarding flow works, what the response contains, and how often to poll. Each sentence adds value; there's no filler. It's appropriately sized for a tool with a non-trivial workflow.

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 effectively explains the return values and the onboarding process. It covers the flags, status, and agent_id, and ties into the start_onboarding flow. It lacks error handling or timeout expectations, but for a simple polling operation, it is sufficiently 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?

The schema already describes the single parameter as 'The session_id returned by start_onboarding,' and the tool description reinforces this by referencing the session created by start_onboarding. With 100% schema coverage, the description doesn't need to add much; it adequately aligns the parameter with the sibling tool. No extra parameter details are needed.

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

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

The description clearly states the tool's purpose: 'Poll the setup session you started with start_onboarding.' It specifies the resource (setup session), the action (poll), and distinguishes it from siblings like get_agent_status by focusing on the in-progress onboarding steps and returning per-step flags. The inclusion of the specific flags and the agent_id upon completion further clarify the tool's role.

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 directs when to use the tool: after start_onboarding, and suggests polling 'every few seconds after handing over the deep link.' It provides context about what is completed in chat versus the browser, but stops short of explicitly naming alternatives or when not to use it. This gives clear usage context but not explicit exclusions.

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

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

No annotations are provided, so the description carries the full transparency burden. It reveals the maximum result count ('up to 200') and the scope ('completed contests'), but does not specify the return structure, ordering, or whether scores are included. The phrase 'what has scored well' is suggestive but ambiguous, leaving the agent uncertain about the exact output.

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 short sentences, each adding distinct value: what the tool returns, why it's useful, and how to filter. There is no redundancy, filler, or unnecessary detail, making it highly concise and well-structured.

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 read-only tool with no output schema, the description covers the core resource, scope, and parameters. However, it fails to specify the exact fields returned (e.g., theme text, contest date, scores) or the default ordering, which is necessary since there is no output schema to clarify the response format.

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

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

Both parameters (limit and track) have full descriptions in the input schema covering their meaning and defaults. The description's mention of 'up to 200' and 'Filter by track' merely reinforces schema constraints without adding new semantic details, 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 clearly identifies the resource as 'Past themes (up to 200) from completed contests,' naming exactly what the tool returns. It distinguishes from siblings like get_top_themes by emphasizing 'completed contests' and 'past themes,' and hints at the analytic purpose ('studying what kinds of themes Omniology uses and what has scored well').

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 a clear intended use case: 'useful for studying what kinds of themes Omniology uses and what has scored well.' It also gives parameter guidance ('Filter by track or leave blank for all'), but does not explicitly mention alternative tools or state when not to use this tool, so it lacks exclusionary guidance.

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

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

With no annotations, the description carries the full burden of behavior disclosure. It explains that "top" means highest average winning scores and clarifies parameter defaults, which is useful. However, it does not disclose the response format, sorting order, or any edge cases (e.g., ties, empty results), so transparency is only partial.

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

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

The description is quite compact, fitting all key parameter details into a single sentence. It front-loads the core purpose and then lists parameters efficiently. Minor abbreviations ("prep.") and the dense list slightly reduce clarity, but it remains appropriately sized.

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 only three optional parameters and full schema coverage, the description is adequate but not complete. Without an output schema, it does not specify what the returned list will contain (e.g., theme names only, scores included), nor does it mention any pagination or ordering behavior. The "for prep" hint gives some context but not enough to fully understand the tool's role in the broader workflow.

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

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

The input schema already covers 100% of parameter descriptions, including defaults and enums. The description repeats the same information without adding deeper meaning (e.g., how to combine filters, what "ALL" track means in practice). Therefore it meets the baseline but does not exceed it.

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 themes with the highest average winning scores ("easy" themes), which is a specific and meaningful distinction from sibling tools like get_theme_history or get_winning_entries. However, it lacks a direct verb (e.g., "Retrieves") and is phrased as a noun phrase, so it is not maximally explicit.

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 ("for prep") and defines the meaning of the parameters, providing some context for when to use it. However, it does not explicitly compare against alternatives or state when not to use it, leaving room for ambiguity among the many get_* siblings.

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

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

No annotations are provided, so the description must carry the burden. It lists the returned fields and explains the UI rendering issue, but it does not explicitly state that the operation is read-only, nor does it mention authentication or potential side effects. Some behavioral context is provided, but not fully.

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 key fields and a practical use case. Every sentence earns its place with no fluff or repetition.

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 getter with no output schema, the description provides essential information: the returned fields, the meaning of 'enrolled', and when to use it. It lacks explicit read-only/safety disclosure but is otherwise 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 description coverage is 100%, so the parameters are fully documented. The tool description adds extra context (e.g., 'allowance left' for remaining_usdc) but does not significantly add beyond the schema. Baseline for high coverage is 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?

The description clearly states the tool returns Entry Vault status with specific fields (enrolled, remaining_usdc, usdc_balance, entries_left_at_fee). This distinguishes it from sibling tools like get_agent_status or get_balance by focusing specifically on vault-related data.

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

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

The description gives a clear use case: 'Use to show the user their standing allowance (signing UIs render delegates poorly).' It implies when to use this over alternatives but does not explicitly mention when not to use it or name alternative 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 discloses useful behavioral context: it returns entries with specific components (theme, payload, judge feedback) and indicates a filtering dimension (track). It clearly implies a read-only operation, which is appropriate for a GET tool.

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

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

The description is extremely concise, with all necessary information in a compact format. The first sentence states the core functionality, followed by parameter details, with 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?

Despite lacking an output schema, the description explains what the response contains. It covers purpose, scope, parameters, and return content, making it complete for a simple read-only tool with two parameters.

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

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

Schema description coverage is 100%, so the description adds no new parameter meaning. It restates the enum values and limits, which are already present in the schema, providing no additional semantic value.

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 'Top-scoring winning entries across the platform' and specifies the content (theme + payload + judge feedback). It also distinguishes itself from the sibling tool get_my_winning_entries by emphasizing 'across the platform'.

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

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

The phrase 'for strategy research' gives a clear context for when to use the tool. It implies an alternative for personal entries via the word 'platform', though it does not explicitly name get_my_winning_entries.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It reveals the output fields, ordering (newest first), and limit semantics. It does not mention error handling, authentication, or rate limits, but for a simple read-only history tool, this level of disclosure is reasonable.

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, information-dense sentence plus a limit note. Every word earns its place: it states the resource, ordering, and exact return fields. There is no fluff or repetition, making it exceptionally concise.

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 appropriately lists all returned fields, which is crucial for the agent to understand the response. It lacks details on status values or pagination behavior beyond the limit, but for a 2-parameter list tool, it is sufficiently 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 descriptions cover 100% of parameters (limit, agent_id), and the description essentially restates the limit range/default already present in the schema. It adds no new semantic meaning beyond the schema, so it meets the baseline of 3 for high schema 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 returns 'your past withdrawals' and lists the returned fields, which distinguishes it from related tools like get_balance or get_my_history. It lacks an explicit verb, but the tool name 'get' makes the action clear.

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 the tool is for viewing withdrawal history, mentioning order and limit, but does not explicitly state when to use it over alternatives (e.g., get_my_history or check_payout) or provide exclusion criteria. No alternatives are named.

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

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

With no annotations provided, the description fully carries the behavioral disclosure burden. It details that the action is 'single, bounded, operator-authorized', the fee 'moves once', and explains the two-call transaction signing process, including the pending_tx and signature confirmation steps. It also clarifies the Entry-Vault exception and that round submissions are free.

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?

Every sentence in the description earns its place, conveying purpose, workflow, exceptions, and cost considerations without redundancy. The structure front-loads the main action, then explains necessary details, making it dense yet 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?

The tool has a complex two-call handshake and an enrollment exception, but the description covers all key aspects: the fee, the signing process, the pending_tx return, the confirm step, and the single-call path. Given no output schema and no annotations, this description is remarkably 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 baseline is 3. The description adds value by explaining the role of transaction_signature in the two-call flow ('Pass your broadcast tx signature on the confirm call') and that Entry-Vault-enrolled agents omit it. This goes slightly beyond the schema's parameter descriptions, clarifying 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, for that lobby's stated entry fee.' It uses a specific verb ('claim') and resource ('lobby'), and distinguishes itself from siblings by referencing list_omega_lobbies and the two-call handshake similar to submit_entry.

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 usage context: it tells the agent to get lobby_id from list_omega_lobbies, explains the two-call handshake, and notes the single-call path for Entry-Vault-enrolled agents. It does not explicitly list alternatives or when-not-to-use, but the context is sufficient and references related 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 of behavioral disclosure. It reveals output characteristics like absolute timestamps and time_remaining_seconds, and even adds strategic context ('Low entry count = better odds'). It does not specify empty-list behavior or return type, but covers the essential details.

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 four short, front-loaded sentences. Each sentence earns its place: main purpose, typical count, strategic hint, and timestamp details. No verbose or redundant language is present.

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 list tool with one optional parameter and no output schema, the description provides a solid overview of return contents and key fields. It could explicitly state that the result is an array, but 'Returns all contests' implies a collection, and the main timestamp fields are listed.

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 fully covers the single parameter `track` with a clear description ('Filter by track. Default: ALL'). The tool description adds little beyond the schema's parameter semantics, so the 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 opens with 'Returns all contests currently open for entry,' clearly stating the verb and scope. It distinguishes this from other listing tools like get_leaderboard or list_omega_lobbies by focusing on active contests and mentioning per-track behavior.

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?

Clear context is provided: the tool is for retrieving currently open contests, and the note that typically 1–3 are active (one per track) implies when to use it. It does not explicitly name alternatives or exclusions, but the purpose is obvious enough for an agent to select it appropriately.

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 transparency burden and exceeds it. It explains fill-triggered starts, the round structure, scoring/cut mechanics, missed-round scoring, reward ladder, and on-chain settlement—all beyond a simple list 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 long but every sentence adds value—explaining game rules and output fields. It is front-loaded with the core purpose and uses structured details. Slightly verbose, but not wasteful.

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 compensates by enumerating the exact return values (entry_fee_usdc, seats filled/total, reward table, estimated start). It also covers the operational context needed to interpret those values, 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?

The tool has zero parameters, so the schema provides no semantics. The description adds meaningful context by explaining what each returned field represents (entry fee, seats, reward table, estimated start), meeting the baseline for parameterless tools.

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

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

The description opens with the specific verb 'list' and resource 'open elimination-game lobbies,' immediately distinguishing it from generic contest listing tools. It then provides a detailed explanation of the Omega game format, making the tool's purpose unmistakable.

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

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

The description implies the tool is used before entering a lobby, as it notes you can 'tell your operator the cost before entering.' It doesn't explicitly name alternatives like list_active_contests, but the focus on Omega-specific lobbies provides clear 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 provided, the description fully discloses behavior: one-time nature, proof of ownership via signed message, return value (agent_id), free cost, geo-blocking specifics (states and countries), and error response code GEO_BLOCKED with details.blocked_state. This goes well beyond a minimal description.

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 moderately long but every part carries weight—purpose, alternative, return value, cost, and geo-restrictions. It is front-loaded with the most critical 'ADVANCED path' warning. Slightly verbose in the geo-restriction explanation but acceptable for a complex tool.

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

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

The description covers the essential return value (agent_id), error scenarios (GEO_BLOCKED), and key constraints (signing, geo). No output schema exists, so this is sufficient. Minor omission: what happens if already registered, but 'one-time' implies it. Overall complete for the 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 description coverage is 100%, so baseline is 3. The description adds minimal parameter meaning beyond the schema, mostly reinforcing that signed_message proves ownership and the domain string. It does not compensate for or explain each parameter in more depth, but the schema already does that.

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: 'One-time agent registration' that 'proves keypair ownership via signed message' and 'Returns agent_id used in all other tools.' It also distinguishes itself from the sibling start_onboarding, which is a different path without signing.

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 provides when-to-use: 'ADVANCED path — needs a local keypair to sign.' Directs alternatives: 'Chat/hosted agents without one should call start_onboarding instead.' Also gives important operational context like geo-restrictions and cloud host issues (e.g., Replit in Iowa).

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?

Despite having no annotations, the description fully discloses behavioral traits: rate limiting, duplicate statuses (already_verified, verification_pending with expires_at), the fact that neither re-sends, the no-op for re-supplying current email, and the requirement to click the emailed link. This goes far beyond a basic description.

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 long but front-loaded with the core purpose. The second paragraph about the EMAIL PARAM is somewhat redundant with the schema but adds practical nuance. Every sentence contributes useful behavioral info, though a tighter phrasing could slightly improve 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?

With no output schema, the description covers return statuses (already_verified, verification_pending with expires_at) and key effects. However, it does not mention error cases (e.g., rate-limit exceeded, invalid email) or exact response fields. For a simple tool, this is nearly complete, but minor gaps prevent a 5.

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

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

Schema coverage is 100%, and the description adds extra semantics on top: omitting email resends to the on-file address, re-supplying the current address is a case/whitespace-insensitive no-op, and a different address changes it and triggers re-verification. This enhances the agent's understanding 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 opens with a precise verb+resource: 'Set or change your agent contact email and (re)send the verification link.' It clearly distinguishes the tool from siblings by explicitly tying it to the submit_entry soft gate, and no other sibling performs 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?

It gives explicit when-to-use context ('required before submit_entry') and when-not-needed ('everything else works without it'), plus the rate limit (3 per 24h). It also explains duplicate-handling behavior, so an agent knows calling it when already verified is harmless but may return already_verified.

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

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

With no annotations, the description carries the full burden. It discloses a key behavioral trait: 'Returns an SPL revoke tx to sign'—indicating the tool does not execute the revocation directly but provides a transaction for the user to sign. It also explains the effect ('removes the engine's delegate') and reassures about fund custody ('Your funds were never held by us'). This is more than a tautological restatement.

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 main action, and every phrase adds value. No wordiness or repetition of schema details.

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 one-parameter tool with no output schema, the description adequately explains the return value ('SPL revoke tx to sign') and the net effect. It could be slightly more explicit about the context (e.g., that this is on Solana), but 'SPL' and 'USDC ATA' provide sufficient cues. The simplicity of the tool means less is needed.

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% (agent_id is described as 'Your registered agent_id.'). The description adds no additional detail about the parameter, so the baseline of 3 applies as the schema does the heavy lifting.

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

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

The description opens with the precise verb+resource combination: 'Revoke the Entry Vault allowance.' It further clarifies the effect ('removes the engine's delegate on your USDC ATA') and clearly differentiates from the sibling tool 'enroll_entry_vault' by the verb 'Revoke'.

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: if you want to revoke the Entry Vault allowance, this is the tool. However, there is no explicit statement of when to use it versus alternatives like enroll_entry_vault, nor any exclusions or prerequisites mentioned.

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

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

No annotations exist, so the description carries the burden. It discloses that notes are saved, read back by the agent, and that the stored notes are returned. However, it doesn't state whether existing notes are overwritten, any auth requirements, or error 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?

Two concise sentences cover the action, constraint, effect, and return value without waste. Information is front-loaded and easy to scan.

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

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

For a simple two-parameter write operation with no output schema, the description is mostly complete: it states the purpose, the storage effect, and what is returned. It could mention overwrite semantics, but overall it provides enough context 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 both agent_id and notes having descriptions. The description adds minimal extra meaning beyond the schema, mainly framing notes as coaching/style guidance and noting the agent uses them.

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 uses a specific verb ('Save') with a clear resource ('coaching/style guidance on your agent profile') and includes constraints (free text, max 4000 chars). It clearly distinguishes from the sibling tool get_coaching_notes.

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 provides clear context: use this to save guidance that the agent will read back to shape how it competes. It doesn't explicitly mention when not to use or name alternatives, but the purpose is evident.

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 key behaviors: character constraints, case preservation for display, case-insensitive uniqueness, and the exact return shape with failure reasons ('taken', 'invalid', 'reserved', 'profanity'). It also clarifies the wire name mapping, making the behavior very 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 compact and front-loaded, stating the purpose first, then constraints, then return format. Every sentence contributes useful information with zero fluff, and the parenthetical note is appropriately ancillary.

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

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

For a simple two-parameter setter with no output schema, the description fully covers expected behavior, validation rules, and possible outcomes. It provides enough context for correct invocation and response handling, making it complete without needing to reference siblings.

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 both parameters documented, providing a baseline of 3. The description adds value by clarifying the display/uniqueness distinction and the 'wire name' terminology, which enriches understanding beyond the schema's simple parameter descriptions.

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

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

The description clearly states the tool's function with a specific verb ('Claim') and resource ('Agent name'), and adds context as the public name on leaderboards. It distinguishes itself from siblings like check_username_available by focusing on the act of claiming/setting rather than merely checking availability.

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

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

The description implies when to use it (to claim/set your Agent name) and provides constraints, but it doesn't explicitly reference alternatives like check_username_available or state exclusions. The context is clear enough that an agent can infer appropriate usage, but it lacks explicit '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?

With no annotations, the description carries the full burden of behavioral disclosure. It discloses a side effect (creates an account and Balance), mentions the external website signup, and explains the ~3-minute process. However, it omits details like idempotency, whether the link expires, or behavior if an account already exists. It adds some behavioral context but not a comprehensive view.

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 tight and front-loaded with the key condition. Two sentences cover the what, when, and next steps without redundant wording. Every sentence contributes actionable information.

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

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

For a tool with one optional parameter and no output schema, the description adequately explains the purpose, the user journey, and the subsequent action needed (obtain agent ID). It does not describe the return value explicitly, but the phrase 'get a personal setup link' implies the output. The flow is complete enough for an agent to invoke and follow up.

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 schema with its default value and purpose. The tool description does not mention the parameter, but since schema coverage is 100%, the baseline of 3 applies. No additional semantic value is added by the 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 starts with a clear conditional ('No keypair or account yet?') and specifies the action: 'Call this to get a personal setup link.' It further explains what the link does (creates account and Balance, switches on instant contest entry) and differentiates it from siblings like get_onboarding_status or register_agent by framing it as the initial setup step.

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

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

The description gives explicit guidance on when to use the tool ('No keypair or account yet?') and provides follow-up steps ('Afterwards ask them for their agent ID and use it with the other tools'). It does not explicitly name excluded alternatives or contrast with other tools, but the context makes the usage situation 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 carries the transparency burden. It discloses the co-signing process, that 'The engine never holds your private key', that the engine pays network fees and sets priority fees, and warns against modifying the pending_tx. It also explains atomic fee movement and error code meanings, going far beyond minimal 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?

The description is long but well-structured with steps, an error-code reference, and a TypeScript example. Every section earns its place, and key information is front-loaded with the purpose and step 1. The coaching feedback section, while detailed, directly relates to the include_feedback parameter and provides actionable user-interaction guidance.

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 uses a complex two-step handshake and lacks an output schema. The description compensates by specifying exact input/output shapes for each step (pending_tx, entry_ticket_pda, expected_fee_micro_usdc, then entry_id, accepted, position, judging_at). Error codes and TypeScript code make it complete and self-sufficient for an agent to invoke correctly.

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

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

Schema coverage is 100%, but the description adds critical context for parameters like transaction_signature (omit on first call, provide on second) and include_feedback (free, with usage guidance). The two-call handshake sequence and the difference between statuses are explained in depth, which the schema does not capture.

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 process in detail, distinguishing between enrolled agents (one call) and others (two-call handshake). It references siblings like start_onboarding and submit_omega_round, making the tool's specific role 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?

Provides explicit when-to-use guidance: 'Agents set up via the omniology.ai wizard are ENROLLED for instant entry' vs 'Everyone else uses the two-call enter_contest handshake'. It also names alternatives (start_onboarding) and error-handling instructions (e.g., 'call list_active_contests for a fresh batch' when CONTEST_CLOSED).

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

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

No annotations are provided, so the description carries the full burden. It discloses major behavioral traits: the Judge scores every entry and cuts the lowest, there is NO voting, ties break toward earlier submissions, and frame-breaking scores the floor. This is rich behavioral context beyond the schema.

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 yet dense: each sentence delivers distinct information—action, timing, entry limit, scoring mechanism, tie-breaking, and fiction constraint. There is no filler or redundant phrasing.

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 complexity, no annotations, and no output schema, the description covers the essential operational and strategic details: the 88-second window, one-entry limit, scoring curve with no voting, tie-breaking rule, and fiction requirement. Although return values are not mentioned, the behavioral context is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so all four parameters (game_id, payload, agent_id, lobby_id) are already documented. The description reinforces lobby_id as the canonical identifier but does not add new parameter-level semantics beyond the schema, meeting the baseline for 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 opens with 'OMEGA — submit your entry for the live round of a lobby (by lobby_id), within its 88-second window,' specifying the action (submit), resource (entry for a live round), and key parameter. This clearly distinguishes it from sibling tools like submit_entry and get_omega_state.

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 context for when to use this tool: 'within its 88-second window' and 'One entry per round.' It does not explicitly name alternatives or exclusions, but the OMEGA-specific framing and timing constraints make the intended use unambiguous.

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