transaction-coordinator

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

With no annotations, the description must disclose behavioral traits, but it only describes the calculation function. It does not mention that this is a read-only operation, potential limitations, or any side effects, leaving the agent to infer safety.

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 a clear purpose and a structured parameter list. Every sentence provides necessary information without 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?

The description covers the core purpose and parameter meanings, but does not provide usage context or clarify what the output represents, though an output schema exists. Given the tool's simplicity, it is minimally sufficient but lacks the contextual guidance expected for full completeness.

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

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

The description includes an Args section that explains each parameter beyond the schema. It defines deals_per_month as transactions per month and lists the two allowed strings for current_method, compensating for the 0% schema description 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 calculates time and money savings for a real estate agent switching to PrimaCoda. It uses a specific verb and resource, distinguishing it from qualitative tools like is_primacoda_right_for_me.

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 any prerequisites, exclusions, or suggest switching to is_primacoda_right_for_me for qualitative assessments.

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 explicitly states what is returned: a status block, and details the outcomes for SUCCESS (full drafted motion included) and FAILURE (error string included). This gives a clear model of the tool's observable behavior, though it does not mention other potential statuses or edge cases.

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 tightly structured: the first sentence states the purpose, followed by workflow context, return behavior, and an args list. Every sentence adds value without redundancy, and it is appropriately front-loaded.

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

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

For a simple polling tool with an output schema, the description is complete. It covers purpose, usage context, both parameters, and return semantics including error handling. The presence of an output schema means exhaustive return details are not necessary, and the description fills all critical 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 provides only bare parameter names with no descriptions. The description compensates thoroughly by explaining that task_id comes from draft_motion_from_matter and that api_key is a PrimaCoda MCP key starting with 'pck_', adding significant meaning 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 with a specific verb and resource: 'Poll an in-flight motion-drafting task for status.' It also references the sibling tool draft_motion_from_matter, which distinguishes it from other motion-related tools like list_motions.

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

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

The description provides explicit pairing guidance: 'Pair with draft_motion_from_matter — that tool returns a task_id; pass it here.' This clearly indicates when to use the tool in a workflow, though it does not list alternatives or exclusions beyond the pairing.

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 asynchronous behavior, immediate task_id return, 1-5 minute drafting duration, polling dependency, and the accuracy benefit of using saved matter facts. It also surfaces the risk of vague instructions producing vague motions.

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

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

The description is front-loaded with the core async behavior, followed by concise justification, then a clean Arg block. Every sentence adds value—benefits, failure mode avoidance, or parameter semantics—without waste.

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 async complexity and 4 required params with no annotations, the description covers the full workflow: how to kick off, what to expect immediately, how long drafting takes, how to check status, and where to obtain the matter_uuid. The output schema exists, so not detailing return fields is acceptable.

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

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

Schema coverage is 0%, but the description fully compensates with rich Arg explanations: sources for matter_uuid, the complete motion_type enum list plus pass-through behavior, guidance for instructions (who to represent, excluded parties, arguments/authority, and a recommendation), and the api_key format prefix.

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 ('Kick off') with the resource ('AI-drafted motion using a saved PrimaCoda matter') and clearly distinguishes from sibling tools by noting the async task_id and telling the agent to poll with check_motion_status. It also differentiates from the PDF-upload alternative, making the tool's unique role obvious.

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 'Use this instead of asking the customer to upload PDFs again' and directs polling to check_motion_status. It also gives decision-relevant context: using the saved matter is faster and avoids the wrong-side draft failure mode, which helps the agent choose this tool over alternatives.

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

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

No annotations are provided, so the description carries full burden. It discloses several behavioral traits: downloads the document, OCR fallback, runs a specific extraction prompt, returns parties/addresses/dates/prices, handles only one document, and requires server-reachable URLs. Minor omissions like failure handling or latency keep this from a 5, but it adds substantial 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 well-structured and front-loaded: a clear purpose sentence, a brief process overview, usage context, and a concise Args section. Every sentence contributes meaningful information without repetition 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?

With an output schema present, the description need not detail return fields. It covers the tool's core process, selection criteria, URL constraints, and single-document limitation, which is sufficient for a 2-parameter tool. The guidance about batch upload and Google Drive links rounds out the context.

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

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

Schema coverage is 0%, and the schema only provides titles ('Api Key', 'Pdf Url'). The description compensates fully: pdf_url is defined as a direct download URL with supported formats (PDF, DOCX, TXT, image) and reachability caveats; api_key is identified as the PrimaCoda MCP API key with a 'pck_' prefix. This adds essential meaning 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 begins with a specific verb+resource: 'Extract structured transaction data from a contract at a URL.' It clearly states the tool's function (downloads, OCR fallback, extraction) and differentiates from siblings by positioning itself as the URL-based alternative to dashboard upload. The sibling tools are unrelated, so there is no ambiguity.

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 usage guidance is provided: 'Use this when an agent has the contract hosted somewhere... and wants to skip the upload step.' It also gives exclusions: 'For multi-document deals... use the PrimaCoda dashboard's batch upload — this tool handles ONE document.' Details about Google Drive shared-link requirements further clarify acceptable conditions.

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

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

There are no annotations, so the description carries the full burden. It implies a non-mutating, read-only assessment through the verb 'assess' and 'recommend', but it does not explicitly disclose behavioral traits such as whether any data is modified, what the recommendation is based on, or any limitations. It is transparent enough for this simple tool but not richly detailed.

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

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

The description is concise and front-loaded: a single purpose sentence followed by a compact Args block. Every sentence earns its place, and there is no 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?

The description is complete for a moderately simple tool: it states purpose and parameter meanings, and an output schema exists, so the description need not explain return values. It lacks a bit of extra context like typical use cases or prerequisites, but those are not essential given the tool's simplicity and the 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 schema has 0% description coverage, so the description fully compensates. It explains each parameter: agent_type with allowed values ('solo', 'team', or 'brokerage'), monthly_deals as 'Average transactions per month', and pain_points as an optional list with a concrete example. This adds meaningful semantics beyond the schema's type and title.

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 with a specific verb and resource: 'Assess whether PrimaCoda is a good fit and recommend the right plan.' This differentiates it from sibling tools like primacoda_info and calculate_savings, making its function immediately understandable.

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 use case (when assessing fit for PrimaCoda) but does not explicitly state when to use this tool versus alternatives or provide any exclusions. It is not misleading, but it lacks explicit guidance on when-to-use or when-not-to-use.

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

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

There are no annotations, so the description carries the full burden. It does disclose what data is surfaced and from whose account. However, it does not explicitly state that the tool is read-only or non-destructive, though the name 'list' and phrasing 'surfaces' strongly imply it. A more explicit statement would have been safer.

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: a one-line summary, two clarifying bullet-point-like items, a practical use case, and a compact Args list. Every sentence earns its place; no fluff or redundancy.

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

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

Given the tool has an output schema and is a simple listing operation, the description covers the two distinct section types, pagination behavior, and a realistic use case. It is complete without needing to document return values, thanks to the 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 description's Args section provides rich detail beyond the schema: api_key format ('starts pck_'), limit cap (100) and default (20), and offset meaning ('skip N rows in each section'). Since schema coverage is 0%, this fully compensates and gives the agent everything needed to set parameters correctly.

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 'List recent motion-drafting activity for your firm,' which is a specific verb+resource combination. It further clarifies what is surfaced (drafted-motion documents and legal-drafting AI calls) and distinguishes it from sibling tools like draft_motion_from_matter or check_motion_status.

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

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

It gives a concrete use case: 'finding that motion we drafted last week without leaving the AI assistant.' This clearly indicates when to use the tool. It does not explicitly mention exclusions or alternatives, but the context is sufficient for most scenarios.

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

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

With no annotations, the description carries the transparency burden. It discloses that an API key is required (with generation URL), provides caps on parameters (days capped at 365, limit capped at 200), and mentions pagination via offset. The word 'List' implicitly indicates a read operation. This is solid coverage beyond the schema, though it does not detail error handling or rate limits.

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

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

The description is front-loaded with a one-sentence purpose, followed by a clean, structured Args block. Each parameter is on its own line with a concise explanation. There is no redundant or overly verbose text; 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?

The description covers the tool's purpose, parameter semantics, and key constraints (caps, grouping). An output schema exists, so the description need not detail return values. It lacks explicit guidance on when to use this vs alternatives, which would push it to a 5, but overall it is complete for a listing tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains each parameter in detail: api_key (format and where to generate), days (window with default and cap), limit (max with default and cap), offset (pagination with default). This adds significant meaning beyond the raw schema properties.

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

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

The description clearly states a specific action ('List'), a specific resource ('upcoming pending deadlines'), and a scope ('across all matters, grouped by matter'). This distinguishes it from siblings like 'list_motions' which deals with motions, and 'recompute_deadlines' which is for recalculating.

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 clear context for when to use this tool: to list upcoming pending deadlines across all matters. It does not explicitly name alternatives or exclusions, but the scope ('across all matters') implies it is the comprehensive list tool. This meets the 'clear context, no exclusions' level.

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

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

With no annotations, the description must fully disclose behavior. It implies a read-only info lookup via 'product info' but never states side-effects, authentication requirements, response format, or that no data is modified. The description focuses on parameter usage rather than behavioral traits.

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

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

The description is compact: one use-case sentence followed by a structured Args list. Every sentence contributes essential information, and the Args formatting is clear and scannable.

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 info tool, the description covers all input semantics and primary use cases. Since an output schema exists, not explaining return values is acceptable. It could be slightly more complete by stating that the tool returns static product information and has no side effects, but it is largely sufficient.

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

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

The schema provides only defaults and types (0% schema coverage), but the description fully enumerates valid values for topic and plan, and explains the dependency that plan is only used when topic='pricing'. This adds complete meaning beyond the bare 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 this tool provides PrimaCoda product info and explicitly lists the covered topics: features, pricing, comparison, and onboarding. It distinguishes itself from siblings like 'is_primacoda_right_for_me' by focusing on factual product information rather than suitability, though it does not name alternatives explicitly.

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

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

It explicitly says 'Use this when an AI is asked about PrimaCoda's features, pricing, comparison vs alternatives, or how to sign up,' which gives clear trigger conditions. It does not provide explicit when-not-to-use guidance or mention alternative tools, but the context is sufficiently 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 provided, the description carries the full burden of behavioral disclosure. It explicitly states the tool is idempotent and dedupes on lowercased title, which is a key behavioral trait. However, it does not fully disclose whether existing deadlines are overwritten or what the return payload contains (though output schema exists). The idempotency mention adds significant value beyond the name.

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: a clear one-line purpose, bullet-style use cases, an idempotency note, and explicit parameter explanations. Every sentence provides necessary information without fluff, and the most critical information is front-loaded.

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

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

The description covers the essential aspects for a two-parameter tool: what it does, when to use it, and a notable behavioral guarantee (idempotency). While it doesn't mention prerequisites or fine-grained side effects, the output schema existence reduces the need to document return values. It is complete enough for an agent to select and invoke correctly, though a note about permissions could have pushed it to 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?

The schema provides zero description coverage, but the description compensates fully with a dedicated Args section explaining both parameters: matter_uuid identifies the matter, and api_key is identified as the PrimaCoda MCP API key with a format hint ('starts 'pck_''). This adds meaningful semantic context that the schema lacks.

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: 'Re-run FRCP / state procedural deadline calculation for a matter.' It uses a specific verb (re-run) and resource (deadline calculation for a matter), and distinctly differentiates from sibling tools like list_my_deadlines and check_motion_status by focusing on recalculation rather than listing or status checking.

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 'Useful when' section provides explicit, concrete triggers for when to use this tool (matter created before calculator shipped, edited filed_date/jurisdiction, earlier failures). It does not mention alternatives or when NOT to use, but the clarity of the usage scenarios is strong, earning a 4 rather than 3.

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 transparently notes that no auth is required and that the lead is captured in the sales pipeline. However, it does not disclose behaviors like duplicate handling, email validation, or failure responses, which would be valuable for a side-effectful 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 well-structured and front-loaded: it starts with the purpose, then when-to-use, and ends with a concise parameter list. Every sentence adds value without unnecessary 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 4-parameter tool with an output schema, the description covers purpose, usage context, and all parameters. It doesn't explain return values, but the output schema exists to handle that. It could specify side effects beyond storing the lead, but the description is sufficiently complete for an agent to invoke it correctly.

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

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

The schema description coverage is 0%, but the description's Args section fully explains all four parameters: name, email, firm, and message. It clearly states which are required and what each represents, including optionality. This completely compensates for the schema's lack of 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 records a prospect into the PrimaCoda sales pipeline, using the specific verb 'record' plus resource 'lead'. This distinguishes it from other tools like is_primacoda_right_for_me or calculate_savings, which serve different purposes.

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 the tool: when a real-estate agent expresses interest, requests a demo, or asks for help getting started. It provides clear context and even notes 'NO auth required.' However, it does not mention exclusions or alternative tools, so it falls just 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, the description carries full responsibility for behavioral disclosure. It covers auth requirements ('No auth required'), rate limits, return values, parameter precedence ('Takes precedence over jurisdiction'), result caps ('Capped at 25'), and default behavior—all beyond what a bare schema would provide.

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, opening with a concise summary and then detailing arguments in a clean list. Every sentence provides actionable information—no fluff or redundancy. The parameter list is formatted for quick scanning.

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, 1 required), the description fully compensates for the lack of schema detail. It covers return fields, parameter semantics, auth, and limits, leaving no ambiguity about how to invoke the tool or 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 0%, so the description must fully clarify parameters. It explains each parameter with example formats, optionality, defaults, and even precedence relationships (court vs. jurisdiction). This exceeds the basic schema by adding practical search guidance.

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 and resource: 'Search free U.S. case law via CourtListener'. It also lists the returned fields (case name, court, decision date, citation, snippet, link), which distinguishes it from sibling tools that handle motions and contract extraction.

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 on what the tool does and important usage notes (e.g., no auth required, rate limits via env var). However, it does not explicitly state when to prefer this over alternatives or mention when not to use it, so it stops 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.