directory

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 explains the workflow (fill as much as possible, leave the rest), advises asking about images early, and clarifies that asset fields accept local paths. This is strong, though it doesn't detail all mutation effects or prerequisites.

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

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

A single dense paragraph where every sentence contributes value. It is somewhat long but not bloated, and it front-loads the core action ('Store a product') before diving into 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?

Given the complexity (nested pack/facts objects), no output schema, and minimal annotations, the description covers the workflow, inputs, and behavioral expectations effectively. It doesn't describe return values, but that isn't critical for a creation tool with this level of guidance.

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 only 40%, but the description compensates by explaining the pack vs facts distinction and the local-path handling for assets. It doesn't explicitly mention pitch, but the schema covers that; overall the description adds meaningful semantics beyond the raw 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 'Store a product on the account,' clearly identifying a create operation. It also contrasts with sibling update_project, making the tool's scope 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?

It explicitly instructs the agent to use existing context (README, metadata, site copy) before asking, and names update_project as the follow-up tool for changes. This gives clear when-to-use and when-not-to-use signals.

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 return payload structure, the conditional presence of agentPrompt based on token, and the null behavior without a token. It also explains the relationship to submission_playbook. It doesn't cover errors or auth specifics but is notably transparent for a read operation.

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

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

The description is compact, using two sentences to convey purpose, content, and a conditional behavior, plus a sibling comparison. The second sentence is dense but each clause is informative and doesn't waste words. It is well-structured with the core purpose first.

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

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

Given there is no output schema, the description compensates by enumerating the fields in the record (eligibility, disqualifiers, instructions, requirements, gotchas, expected outcome) and the conditional agentPrompt field. It also clarifies the edge case of missing tokens and points to submission_playbook for filled values. This is sufficient for a straightforward get-by-slug tool.

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

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

The schema already provides full coverage for the single 'slug' parameter with an example. The description adds no additional parameter-specific details. Since schema coverage is 100%, 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 clearly specifies the tool's purpose: retrieving a full record for one platform, with a detailed list of content (eligibility, disqualifiers, instructions, etc.). It distinguishes itself from search_platforms (which presumably lists/summarizes platforms) and from the sibling submission_playbook, which fills values for a stored project.

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 to submission_playbook when a stored project exists and pre-filled values are needed, which provides a clear when-not-to-use signal. It does not explicitly enumerate other alternatives (e.g., search_platforms for searching), but the primary differentiator is clearly stated.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does describe the output contents (projects with facts, pack, and missing items), but does not explicitly state that it is a read-only operation or mention any side effects. This is adequate for a simple listing tool but lacks depth.

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, efficient sentence that uses parentheticals to clarify terms. It is concise and every phrase adds value, though it could be slightly more direct.

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 parameterless list tool with no output schema, this description adequately covers the key components of the response. It does not mention ordering or pagination, but such details are not critical for this simple use case.

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

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

There are zero parameters, so the schema is fully covered. The description adds meaning by explaining what each project includes (facts, pack, missing items), which goes beyond the empty schema.

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

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

Description clearly identifies the resource (projects) and scope (on this account), and differentiates from siblings like list_submissions by detailing the payload (facts, pack, missing items). However, the verb 'list' is only implied by the tool name, not explicitly stated.

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

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

Provides no guidance on when to use this tool versus alternatives such as list_submissions or get_platform. The intended use is implied as a read-only listing, but no when-to-use or when-not-to-use context is given.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It does not explicitly state that the tool is read-only or that it has no side effects, nor does it mention any limitations such as pagination or ordering. The name 'list_' implies a read operation, but the description itself does not confirm safety or behavior beyond the core listing function.

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 front-loads the purpose ('What has been submitted for a project') and adds a practical use case. There is no redundancy or fluff; every word contributes to understanding the tool's function.

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

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

For a tool with one optional parameter and no output schema, the description provides the essential information: it lists submissions and their statuses for a project, and it gives a user-oriented use case. It does not specify possible status values or response structure, but that is not strictly necessary given the tool's simplicity and the schema's clarity.

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

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

Schema description coverage is 100%, and the schema itself explains the only parameter well: 'Omit it when the account has one project, which is the free tier.' The tool description adds no additional parameter context, but since the schema fully defines the parameter, a 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 conveys that the tool returns submissions for a project along with their statuses ('what has been submitted... and where each one stands'). This distinguishes it from sibling tools like record_submission, which writes submissions. However, it does not use a direct 'List submissions' phrasing, so it is slightly less explicit than ideal.

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 use case: 'so you can answer "what is still pending" without asking the maker.' This gives contextual guidance on when to use the tool, but it does not explicitly mention alternatives or exclusions among the sibling tools, so it falls short of 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 provided, the description carries the full burden. It discloses two key behaviors: the plan appears as a self-ticking checklist on the dashboard, and already tracked items are reordered rather than reset. These are important side effects and state-change semantics that go beyond a simple 'create'. The phrase 'using what it told you' also signals dependency on qualify_project's output. It does not mention permission requirements or error cases, but the disclosed behaviors are substantive.

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 the primary purpose front-loaded in the first clause. Each sentence adds necessary context: the first defines the tool's function and input requirements; the second explains the output behavior and when to call it. No filler or redundant information 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 tool with 4 parameters and no output schema or annotations, the description adequately covers the core purpose, the workflow placement, and notable behaviors (checklist ticking, non-destructive reordering). It does not describe return values or error handling, but that may not be essential given the dashboard side effect. The schema covers parameter details, so the description is sufficiently complete for an agent to invoke it correctly in most scenarios.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces that 'items' must be in work order ('Pass the platforms in the order they should be worked') and that 'summary' captures the strategy, but it does not add meaning beyond the schema. The checklist parameter's role is implicitly referenced ('appears on the maker's dashboard as a checklist'), but the schema already describes it well. No additional parameter-level detail is provided.

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

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

The description opens with a specific verb phrase 'Write the run order for a project' and clarifies the resource (project) and the content (platforms, sequence, reasons). It clearly distinguishes from siblings like qualify_project (which qualifies) and record_submission (which records actual submissions) by focusing on planning a sequence. The checklist behavior is also stated, removing any ambiguity about what the tool creates.

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?

Explicit guidance is given: 'Call it after qualify_project, using what it told you.' This tells the agent when in the workflow to use the tool. It also notes that already tracked items are reordered rather than reset, which implies a non-destructive update and provides context for idempotent planning. It doesn't explicitly exclude alternatives, but the sequencing guidance and focus on 'run order' are strong enough to guide selection.

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

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

With no annotations provided, the description carries the full burden. It discloses the key behaviors: the three-tier outcome classification, the fact that unanswered fields become gaps rather than rejections, and that no account is needed. This is meaningful behavioral context, though it doesn't describe the exact response structure or any side effects.

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

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

The description is three sentences, front-loaded with the core purpose and no filler. Every sentence adds value: the first defines purpose, the second notes no account is needed, the third explains the optionality semantics.

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 18 parameters and no output schema, the description covers the essential context: the tool's decision logic, input flexibility, and the gap-filling behavior. It could be more complete by describing the output format or giving an example, but overall it's adequate 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 only 6% (only categories has a description). The description compensates globally by stating 'Every field is optional and an unanswered field becomes a gap to fill rather than a rejection,' which clarifies the collective parameter behavior. However, it doesn't explain individual parameter meanings beyond the self-explanatory names, and the categories description is the only one in 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 specific verb and resource: 'work out which platforms it qualifies for' – clearly a product qualification tool, distinct from siblings like create_project or search_platforms. It further specifies three outcome categories (qualifies now, could qualify after supplying something, structurally out of reach), leaving no ambiguity about the tool's purpose.

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 states when to use it: 'Given a product... Needs no account: describe the product inline.' This indicates it's a self-contained qualification tool requiring no pre-existing context. It doesn't explicitly mention alternatives or exclusions, but the context is clear enough for an agent to choose it over sibling tools like plan_submissions or submission_playbook.

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 of disclosing behavioral traits. It does not explain whether calling the tool creates a new record, updates an existing one, or handles duplicate submissions, nor does it mention permission requirements or side effects. The description focuses on intent and timing but omits critical behavioral details for a write 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 two sentences, front-loaded with the core purpose and followed by essential usage timing. Every word earns its place, with no redundancy or filler.

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

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

With 7 parameters, no annotations, and no output schema, this tool needs more context to be fully understood. The description covers the 'why' and 'when' but fails to disclose important operational details like idempotency, status semantics, or what happens after logging. It is incomplete for a tool with this 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 57%, so the schema already documents several parameters (launchAt, projectId, listingUrl, submittedAt). The description adds some context by mapping fields to 'listing URL, when it was sent, when it goes live,' which helps relate the parameters, but it does not clarify the status enum or the relationship between 'queued for review' and status values. Overall, it adds modest value beyond the schema.

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

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

The description clearly states the tool's function: 'Log what happened to the dashboard' with specific details (listing URL, when sent, when live). The verb 'log' is specific and the resource (submission events) is distinct from sibling tools like list_submissions or plan_submissions.

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 timing guidance: 'Call it as soon as a submission lands, including when it is only queued for review.' This clarifies when to use it, but it does not explicitly mention alternatives or when not to use it, which would push it to 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 the full burden of behavioral disclosure. It reveals that the tool only returns summaries, not full records, and points to get_platform for complete details including submission steps. It does not mention pagination or exact summary fields, but for a read-only search tool, this provides sufficient 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 two sentences with no filler. It front-loads the tool's purpose and packs the filter parameters into a compact list. The second sentence provides an essential pointer to get_platform without unnecessary detail.

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

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

Given six optional parameters and no output schema, the description covers the tool's purpose, filter options, and the summary-only return type. It also directs users to get_platform for full details, which fills a likely gap. It stops short of describing summary fields or behavior with no filters, but the pointer to get_platform mitigates that.

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 83%, above the 80% threshold, so the baseline is 3. The description adds synonyms like 'link type' for dofollow and 'approval speed' for maxApprovalDays, but most parameters already have clear schema descriptions. The pricing parameter remains undocumented beyond its enum, and the description does not elaborate on 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 uses the specific verb 'Search' and identifies the exact resource: the SubmitMap directory of startup launch platforms. It also clearly distinguishes itself from the sibling get_platform by noting it returns summaries and directing users to get_platform for full records.

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 the agent to call get_platform when full records including submission steps are needed, which serves as a clear alternative. The list of filter dimensions and the summary-only return clearly define when to use this tool versus siblings.

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

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

With no annotations, the description carries the full burden and does so thoroughly. It discloses the output's structure (preflight, sign-in rule, pack values mapped to fields, steps, gotchas, call to make) and adds a critical usage rule (read preflight first). This is rich behavioral context that goes far beyond a simple action statement.

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

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

The description is two sentences, front-loaded with the core purpose ('Everything needed to submit...'). The first sentence packs a dense enumeration of contents without being verbose, and the second sentence gives a direct, actionable instruction. Every clause adds value.

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

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

For a tool with no annotations and no output schema, the description covers the purpose, content, and a usage precaution effectively. It explains what the playbook includes and directs the user to read the preflight first. The main missing piece is parameter guidance, but the tool is simple and the schema partially covers that, so the description is largely 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 description says nothing about the two parameters (projectId and platformSlug). The schema covers projectId with a detailed note, but platformSlug is undocumented and the description does not compensate for that gap. Since schema coverage is only 50%, the description should have provided some clarification or context, but it does not.

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

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

The description clearly states the tool provides 'everything needed to submit a stored project to one platform' and enumerates its contents (preflight, sign-in rule, field mappings, steps, gotchas, call afterwards). It distinguishes from siblings by emphasizing manual submission ('yourself, in the maker's browser') and being a guide rather than an action, though the exact action (returning a playbook) is implied rather than directly stated.

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

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

The description gives a clear context for use: when submitting a stored project to one platform manually. It provides a specific preparatory instruction ('Read the preflight before opening a tab'), which is valuable guidance. However, it does not explicitly mention alternatives or when not to use the tool, missing an opportunity to differentiate from siblings like plan_submissions or record_submission.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals the merge semantics ('Facts and pack are merged into what is there'), implying non-destructive updates, and the incremental nature of the operation. This adds valuable context beyond the tool name. However, it doesn't specify whether merging is deep or shallow, or how conflicts are resolved, which would be useful for safe invocation.

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

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

The description is two sentences long, front-loaded with the core verb and object, and every word contributes meaning. It efficiently conveys the main purpose and the merge behavior without fluff. 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?

Given the tool's complexity (6 parameters, nested pack object, no output schema), the description is too sparse. It explains the merge concept but omits practical details such as how projectId works, what facts should contain, and what the response will be. The schema provides some nested field descriptions, but the overall context is insufficient for reliable tool invocation, especially with no annotations.

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 description mentions 'Facts and pack' but doesn't explain what these are or how they relate to other parameters like url, name, pitch, or projectId. The schema coverage is only 17%, and the description fails to compensate by explaining the core top-level fields. It relies on the schema, which itself is sparse for top-level parameters. This is inadequate for an agent to correctly construct a request.

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: 'Fill in or correct a stored project.' It uses a specific verb and resource, and the merge behavior ('Facts and pack are merged into what is there') distinguishes it from the sibling create_project. This is a precise, non-tautological purpose statement.

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 existing projects ('stored project', 'merged into what is there') and highlights an incremental workflow ('add one field at a time as the maker answers'). While it doesn't explicitly contrast with create_project or other siblings, the context is clear enough for an agent to infer when to use it. It lacks explicit exclusions or alternative recommendations, so not 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?

No annotations are provided, so the description carries the transparency burden. It discloses what information is returned (account, plan, free tier left), implying a read-only query. It does not mention error behavior or token validity, but that is acceptable for a simple whoami-style 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?

Two sentences: first states purpose, second gives usage advice. Front-loaded and free of extraneous detail.

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

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

For a simple identity/status tool, the description covers what it returns and when to call it. It lacks output format or error behavior, but these are not critical for a whoami operation with no annotations or output schema.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. The baseline for 0 params is 4, and the description adds no parameter info because none 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 returns the SubmitMap account, plan, and free tier quota associated with the token. This specific verb+resource structure distinguishes it from siblings focused on projects, submissions, and platforms.

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

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

It explicitly says to 'Call it first if you are unsure whether the maker is connected,' providing a concrete scenario for when to use the tool. Though no alternatives are named, this tool is a self-check with clear precedence.

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