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 clearly communicates a read-only informational purpose with no side effects implied. While it doesn't specify return format or auth requirements, for a zero-parameter server-info tool this is sufficient.

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, no wasted words. The first sentence states the core purpose; the second provides usage triggers. Front-loaded and easily 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?

The tool is extremely simple (no params, no output schema). The description fully covers what it does, when to use it, and enough behavioral context. There are no gaps given the tool's minimal 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?

The tool has zero parameters, so there is nothing to explain. The description correctly focuses on purpose and usage rather than parameter details.

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 information') and clearly identifies the resource: this MCP server, its author, and the projects behind it. It is clearly distinct from sibling tools that operate on domain data (people, deals, notes, etc.).

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 call the tool, listing exact user phrasings ('what is this MCP', 'who built this', 'tell me about this server'). It provides clear context and there are no alternative tools for this meta-purpose, so no exclusions are 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, the description carries the full burden of behavioral disclosure. However, it only restates the tool's name without elaborating on side effects, idempotency, duplicate handling, or required permissions. It adds essentially no behavioral context beyond the obvious action.

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

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

The description is a single sentence that is front-loaded and free of unnecessary words. It efficiently conveys the core purpose without any waste, earning the highest conciseness score.

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

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

Given the simplicity of the tool and full schema coverage, the description is minimally adequate. However, it lacks any context on return values, duplicate behavior, or when to use this versus related tools, leaving gaps for an agent to make fully informed decisions.

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

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

Schema description coverage is 100% with both parameters documented as 'Person ID' and 'Action plan ID'. The description adds no additional parameter meaning beyond the schema, 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 'Add a person to an action plan' uses a specific verb ('Add') and clearly identifies the resource (person) and target (action plan). It distinguishes from sibling tools like addPersonToAutomation by explicitly naming the action plan context.

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

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

The description provides no guidance on when to use this tool versus alternatives like updateActionPlanPerson or listActionPlansPeople. There is no mention of prerequisites, context, or when an add operation is appropriate.

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

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

With no annotations, the description must disclose behavioral details but does not. It gives no information about side effects, idempotency, or requirements (e.g., whether the person/automation must exist). The description is essentially a bare statement of intent.

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, front-loaded sentence with no unnecessary words. It clearly communicates the core purpose and 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 tool is simple but lacks critical context. Without annotations or output schema, the description should clarify expected behavior (e.g., what happens if the person is already in the automation, or whether it creates a new relationship). The minimal text leaves gaps for the 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% (both personId and automationId have descriptions), so the baseline is 3. The description adds no additional semantic context beyond the parameter names and IDs, but it also does not need to since the schema is sufficient.

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 'Add a person to an automation' uses a specific verb and resource, clearly distinguishing it from sibling tools like addPersonToActionPlan and updateAutomationPerson. It directly states the operation without 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?

No guidance is provided on when to use this tool over alternatives, nor any prerequisites or conditions. The description only restates the action, leaving the agent without context on when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It discloses two useful behavioral traits: rate limiting (25 PUTs per 10 seconds) and that results are returned per person. However, it does not address potential partial failures, atomicity, side effects beyond the update, or authentication requirements. For a mutation tool with no annotations, this is a moderate level of 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. The first sentence front-loads the core action, the second provides essential behavioral constraints (rate limit and output). Every word earns its place, and the structure is clean 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?

With no output schema, the description compensates by stating that results are returned for each person, giving the agent an idea of the response shape. It also explains the rate limit, which is crucial for bulk operations. However, it could be more explicit about partial-failure handling and that updates are applied identically across all IDs. Still, given the simple parameter set and high schema coverage, the description 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 input schema covers 100% of parameters with descriptions (ids, updates, mergeTags), including a note that updates mirrors updatePerson fields. Since schema coverage is high, the description adds minimal extra meaning beyond the schema. It reinforces 'same changes' but does not introduce new parameter details, so baseline 3 is appropriate.

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

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

The description starts with a specific verb and resource: 'Update multiple people with the same changes.' This clearly distinguishes it from single-person update tools like updatePerson (a sibling) by emphasizing 'multiple' and 'same changes.' The purpose is unambiguous and immediately scopes the operation.

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

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

The description clearly implies the use case: when you need to apply identical changes to multiple people at once, rather than repeatedly calling updatePerson. It also mentions rate limiting, which is a practical consideration. However, it does not explicitly state when not to use this tool (e.g., for heterogeneous updates) or explicitly name alternatives, 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, the description carries the full burden. It fails to disclose the return format (e.g., boolean), OR/AND semantics when both parameters are provided, or edge-case behavior such as case sensitivity or multiple matches.

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, front-loaded sentence with no redundant words. Every part contributes to the core purpose, making it highly 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?

Despite being a simple tool, the lack of any output schema or return-type explanation leaves a significant gap. The description does not specify what 'check' returns, nor does it cover parameter combination rules, so the agent is left uncertain about invocation 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 the schema already explains both parameters. The description adds an 'or' implication, but does not clarify whether at least one parameter is required or how combining them behaves, staying at the baseline.

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

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

The description clearly states the tool checks for existing persons by email or phone, using a specific verb and resource. It distinguishes this from sibling tools like getPersonByEmail by focusing on the existence check rather than retrieval.

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

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

No guidance is provided on when to use this tool versus alternatives like getPersonByEmail or searchPeopleByTag. The description only states the function, without exclusions, prerequisites, or 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 carries the full burden of behavioral disclosure. It states 'Claim an unclaimed person', implying a state change, but does not reveal what claiming entails (e.g., assignment to current user), whether it fails if the person is already claimed, idempotency, or permission requirements. This is insufficient for a state-changing 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 a single sentence with no filler, clearly front-loading the purpose. It is appropriately sized for a simple one-parameter tool and every word earns its place.

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

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

For a tool with no annotations and no output schema, the description is too terse. It does not explain the effect of claiming, provide usage context, or clarify what the caller should expect. The one-line purpose leaves too much implicit for an AI agent to use 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 already describes personId as 'Person ID to claim' with 100% coverage. The description adds no additional meaning about the parameter beyond the schema, so it meets the baseline of 3 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 uses a specific verb 'claim' with a clear resource 'unclaimed person', which distinguishes it from siblings like createPerson, updatePerson, or listUnclaimed. It concisely conveys the action and target, making the tool's purpose immediately evident.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention related tools like listUnclaimed, nor does it explain that claiming typically follows listing unclaimed people, and there are no exclusions or preconditions 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 full burden. It discloses platform-specific naming conventions that prevent errors and clarifies the invitees structure. However, it does not mention side effects, permission requirements, or return behavior, leaving significant gaps.

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 entire description is a single well-structured sentence. It is front-loaded with the core purpose and immediately provides the most important usage caveats. 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?

For a 10-parameter create tool with no output schema, the description covers the most error-prone naming conventions but omits return value, permissions, and error behavior. It is adequate for basic usage but not fully complete for an agent to invoke confidently in all contexts.

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 high (90%), so baseline is 3. The description adds value by warning against incorrect field names (startTime/endTime, appointmentTypeId/appointmentOutcomeId) and reiterating the invitees shape. It does not address the one undocumented parameter (allDay) or provide deeper semantics beyond what the schema already offers.

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 'Create an appointment' with a specific verb and resource. It also provides critical naming conventions (start/end, typeId/outcomeId, invitees format) that distinguish this tool from similar create tools and prevent common mistakes.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention any exclusions or alternative tools to prefer in certain scenarios. The naming hints are about parameter usage, not tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only that it creates an appointment outcome, with no mention of side effects, permissions, return values, or failure modes, leaving significant 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, concise, front-loaded sentence with no unnecessary words. For a tool with one parameter, this is appropriately sized and 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?

Given the tool's low complexity (one parameter, no output schema), the description is minimally viable but lacks context about return values or usage scenarios. The absence of annotations and output schema means the description could have been more informative about expected behavior.

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 specifies the required 'name' parameter with description 'Outcome name', so schema coverage is 100%. The description adds no additional parameter semantics beyond the schema, meeting the baseline for fully documented parameters.

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 'Create' and the resource 'appointment outcome', clearly distinguishing it from sibling tools like listAppointmentOutcomes and updateAppointmentOutcome. It is not a tautology and precisely states the action.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. The creation semantics are implied by the verb 'Create', but no exclusions or alternative tool suggestions are given, so usage context is only implicit.

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, but it only states the action without any side effects, permissions, or default settings. It does not mention what happens upon creation (e.g., whether the type is immediately available, or if additional configuration is required).

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

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

The description is a single sentence, which is concise, but it essentially restates the tool name without adding structure or context. It is not verbose, but also not particularly informative.

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 create operation with one parameter and no output schema, the description is minimally viable but leaves gaps such as name uniqueness or length constraints. It provides the essential action, but no additional context about expected behavior or return values.

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 covers the only parameter 'name' with a description ('Type name'), so schema coverage is 100%. The tool description adds no extra meaning beyond what the schema already provides, so a baseline of 3 is appropriate.

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

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

The description 'Create an appointment type' uses a specific verb ('Create') and resource ('appointment type'), clearly distinguishing it from siblings like updateAppointmentType or listAppointmentTypes. It does not elaborate on what an appointment type is, but the core purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as updateAppointmentType or createAppointment. No prerequisites or conditions (e.g., whether appointment types must be unique) are mentioned, leaving the agent to infer usage.

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 only says 'Log a call' which implies creation, but does not describe side effects, required permissions, or failure behavior. The FUB expectation is an API detail, not a behavioral trait.

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 short sentences, front-loaded with the primary purpose and then a key parameter expectation. Every word earns its place with no 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?

For a 10-parameter mutation tool with no annotations or output schema, the description is minimal. It conveys the core purpose and a critical expectation, but omits other behavioral context like return values, prerequisites, or potential errors. It is adequate but with clear 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?

Schema coverage is 100%, so the baseline is 3. The description adds extra value by highlighting that isIncoming and note are expected by FUB, and that note should be singular. This provides semantic guidance beyond the schema 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 action and object: 'Log a call for a person.' This is specific and distinguishes it from sibling tools like getCall, updateCall, and listCalls. The additional note about FUB expectations further clarifies the intent.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of using updateCall for modifying existing calls, and the FUB expectation note is about parameter format rather than usage 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?

No annotations are present, so the description carries the full burden of behavioral transparency. The phrase 'Create a custom field' only implies a write operation but does not clarify side effects, permissions required, uniqueness constraints, or whether dropdown options are required for certain types.

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 no wasted words, fitting the tool's simplicity. It is front-loaded, but it is a phrase rather than a full sentence, which slightly reduces clarity.

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 lack of annotations and output schema, the description leaves out critical context such as the entity type (person, deal, etc.) the custom field belongs to, uniqueness expectations, and how it relates to sibling tools like createDealCustomField. This is insufficient for an agent to safely select and invoke the tool among many similar create operations.

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 covers all parameters (100% coverage) with descriptions for each, so the description does not need to add parameter semantics. The schema already explains 'name', 'type', and 'options', and the description adds no extra meaning beyond 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 action (create) and the resource (custom field), making the core purpose unambiguous. However, it does not differentiate this tool from the sibling 'createDealCustomField', which might also create a custom field but for deals specifically.

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

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

No guidance is provided on when to use this tool versus alternatives like createDealCustomField or updateCustomField. There are no indications of prerequisites, target entity (e.g., person vs. deal), or scenarios where this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'FUB expects peopleIds and price', which hints at backend requirements, but does not disclose side effects, permissions needed, irreversibility of creation, or return value/response format. For a mutation tool, this is a significant gap.

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 short sentences with a clear front-loaded purpose statement. Every word earns its place: it states the action, highlights key API expectations, and lists the required fields. No fluff or redundant 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 creation tool with 16 parameters, no output schema, and no annotations, this description is too sparse. It does not explain return values, error conditions, authentication expectations, or the meaning of the many commission/date fields. The description is minimally viable but leaves substantial gaps for a complex endpoint.

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 adds value by noting that FUB expects peopleIds and price, which are not in the required schema but may be operationally important. However, schema coverage is only 50% and the description only highlights two of the many undocumented parameters (possessionDate, commissions, etc.), so it only partially compensates for the schema's gaps.

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 'Create a deal.' which is a specific verb+resource statement that clearly differentiates this tool from siblings like updateDeal, getDeal, and listDeals. It also adds critical requirement details ('name + stageId required'), reinforcing the creation 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 implies the tool is for creating deals, but it does not explicitly say when to use it versus alternatives like updateDeal for modifications or getDeal for retrieval. It provides no exclusionary guidance ('if you need to modify, use updateDeal'), so the usage context is only implied.

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 burden of behavioral disclosure. It discloses a critical authentication requirement (FUB_SYSTEM + FUB_SYSTEM_KEY env vars) and clarifies that the file is 'externally-hosted' (meaning it references a URI rather than uploading content). This adds meaningful behavioral context beyond the basic action, though it stops short of describing success/error responses or 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 two sentences, front-loaded with the core action and quickly followed by the key restriction. Every word earns its place, achieving clarity without 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 4-parameter tool with a clear purpose and an explicit auth restriction, the description is reasonably complete. It explains the key constraint (env vars) and the external hosting model, and the schema covers parameters. It does not describe return values, but since there is no output schema and the tool is a straightforward create action, the description provides enough context for an agent to select and invoke it.

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

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

Schema description coverage is 100%, with each parameter having a brief description (e.g., 'File URI', 'Deal ID', 'File name'). The description adds little beyond these schema definitions, except for the context that the file is externally hosted, which relates to the uri parameter. Since the schema already documents all parameters, 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 states a specific action: 'Attach an externally-hosted file to a deal.' The verb 'attach' is clear, the resource is 'a deal', and the object is an 'externally-hosted file'. This distinguishes it from sibling tools like createPersonAttachment, getDealAttachment, and updateDealAttachment by scope and action.

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 the tool (when attaching an externally-hosted file to a deal) and provides a clear constraint ('Restricted - Registered Systems Only'). However, it does not explicitly mention when not to use it or name alternative tools like createPersonAttachment for person attachments. The usage context is clear but lacks explicit exclusion or alternative 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 only notes the API's naming expectations for 'label' and 'choices' but does not disclose mutation side effects, required permissions, or response behavior. For a create operation, this is insufficient.

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-loaded with the primary purpose and immediately followed by the key API gotcha. 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?

For a 7-parameter create tool with no annotations and no output schema, the description is too sparse. It lacks information about return values, conditional requirements (e.g., choices needed when type is dropdown), and the purpose of the remaining parameters, leaving the agent under-informed 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?

The description adds meaningful semantics for two key parameters by clarifying the expected API names ('label' not 'name', 'choices' not 'options'). However, with only 43% schema coverage, it does not compensate for the four undocumented boolean/number parameters (readOnly, hideIfEmpty, isRecurring, orderWeight).

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 creates a deal custom field, using a specific verb and resource. It distinguishes from sibling tools like createCustomField and updateDealCustomField by specifying 'deal' and 'create'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention when to use createDealCustomField over createCustomField or listDealCustomFields, nor any prerequisites or 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?

Annotations are not provided, so the description carries the full burden. The verb 'Create' implies a mutation but the description does not disclose permissions, side effects, idempotency, or what happens on success or failure. No additional behavioral context is given.

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

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

The description is a single, concise sentence that directly communicates the purpose. It contains no filler or redundant information, and every word serves a clear 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?

The tool has multiple parameters and no output schema or annotations, yet the description provides only the basic purpose. It does not explain the creation process, parameter meanings beyond the schema, potential validations, or expected results, leaving significant gaps 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 schema description coverage is 100%, with each parameter having a basic description (e.g., 'Email subject' and 'Email body HTML'). The tool description itself adds no parameter-level information, so the schema carries the weight, which justifies the baseline score of 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 action ('Create') and the resource ('an email marketing campaign'), making the tool's purpose unambiguous. It also distinguishes this tool from its siblings 'listEmCampaigns' and 'updateEmCampaign' by specifying the creation aspect.

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?

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites or context, and no exclusions. The description simply states the action without any strategic usage information.

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 only states 'Create' without any information about side effects, permissions, idempotency, or response behavior. This is a significant gap for a mutation 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 a single, front-loaded sentence with zero waste. It is concise, but it could be slightly more structured with additional clauses, so it earns a 4 rather than a 5 due to its extreme brevity.

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 annotations, no output schema, and only a minimal description. It does not explain what constitutes an email marketing event, how it relates to campaigns, or any constraints beyond the schema. The schema partially covers parameters but lacks broader context, making this description inadequate for complete understanding.

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

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

Schema description coverage is 100%, with both 'campaignId' and 'events' having descriptions in the schema. The tool description adds no additional parameter meaning, so the baseline of 3 applies as the schema already provides the necessary 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 a specific verb 'Create' and resource 'email marketing events', which aligns with the tool name and distinguishes it from generic event tools like createEvent. However, it does not explicitly differentiate from sibling tools like createEmCampaign, though the context is sufficient for basic understanding.

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

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

No guidance is given on when to use this tool versus alternatives such as createEvent or listEmEvents. There is no mention of prerequisites, campaign context, or exclusions, leaving the agent to infer usage from the name alone.

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 bears the full burden of disclosing behavioral traits. It only says 'create' which is inherent to the tool name, and offers no information about required fields despite the schema having zero required properties, potential side effects, auth needs, or response format. This is a significant transparency gap for a mutation 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 a single sentence with no unnecessary words, making it immediate and easy to parse. It is appropriately concise for a simple statement of purpose, though it could include more substance while remaining 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 14 parameters, zero required fields, no output schema, and no annotations, this description is insufficient to guide an agent on correct usage. It does not explain the relationship between parameters, the semantics of 'event' in FUB, or any operational constraints. The complexity of the schema demands more contextual information than a single sentence provides.

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 descriptions for all 14 parameters (100% coverage), so the baseline is 3. The tool description adds no parameter-specific meaning beyond the schema, so it neither enhances nor detracts from 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 creates a new event in FUB, with examples like 'lead event, property inquiry'. It uses a specific verb and resource, making the purpose understandable. However, it does not explicitly distinguish from sibling createEmEvent, so it falls short of a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives like createEmEvent or createCall. The description simply states what it does without discussing prerequisites, contexts, or exclusions. This leaves the agent without decision-making support for tool 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 and no behavioral details in the description, the agent is left completely in the dark about potential side effects, permissions, or error conditions. The description adds no transparency beyond the bare action.

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 under-specified, consisting of only three words. While it is concise in length, it lacks necessary substance, making it ineffective rather than 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?

Given the tool's low complexity, a short description could suffice, but this one omits even basic context about what a 'group' is or what the operation entails. With no output schema and no annotations, the description fails to provide a complete picture 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%, so the input schema already documents both 'name' and 'userIds'. The description adds no parameter information, meeting 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 'Create a group' is essentially a tautology of the tool name 'createGroup'. It states the verb and resource but adds no distinguishing scope or details, failing to differentiate from sibling create tools like createPersonAttachment or createTeam.

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

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

No context is provided about when to use this tool versus alternatives. The description neither states scenarios nor exclusions, leaving the agent without guidance on selecting this tool among many similar create operations.

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 only states that a note is created, without disclosing side effects, permission requirements, reversibility, or what happens to the note after creation.

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

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

The description is a single sentence, front-loaded with the action and object. Every word is necessary, 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?

Despite having 4 parameters and no output schema or annotations, the description does not explain return values, param relationships, or required vs optional fields. It is too minimal to fully guide an agent in a complex creation 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 descriptions cover 100% of parameters (body, userId, personId, createdAt), so the baseline is 3. The description adds no extra meaning about parameter semantics, merely contextualizing the note as being 'on a person'.

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 'Create a note on a person' clearly states the specific action (create) and resource (note) with a target (person), which distinguishes it from sibling tools like updateNote and createPersonAttachment.

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, nor does it mention prerequisites or exclusions. It lacks any contextual instructions for choosing createNote over similar create/list/update 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 available, the description carries the full burden of behavioral disclosure. It only says 'Create a new person/contact', which is the obvious action, and fails to mention permissions, duplicate handling, validation, error responses, or return behavior.

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

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

The description is a single concise sentence with no wasteful words. However, for a tool with 21 parameters, it is somewhat under-sized, so it earns a 4 rather than a 5.

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 is complex with 21 parameters and no output schema or annotations. The one-line description is far from complete, giving no sense of what the tool returns, what fields are essential, or how the many parameters relate.

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

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

The input schema has descriptions for all 21 parameters, so the baseline is 3. The description adds no additional parameter context beyond what the schema already provides.

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

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

The description clearly states the tool's purpose with a specific verb ('Create') and resource ('person/contact in FUB'). It is unambiguous and distinguishes itself from sibling tools like updatePerson or createPersonAttachment.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states what it does without mentioning prerequisites, typical use cases, or 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It does add useful information about access restrictions and environment variables, but it does not describe what the operation does beyond 'attach', whether it creates a new record, or any side effects. There is no contradiction with annotations since none exist.

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, gets straight to the point, and every part earns its place. It states the core purpose first and then provides the critical access constraint.

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 create operation with a fully documented schema, the description covers the essential context: what it does and the access restriction. It doesn't explain return values, but given no output schema, the absence is forgivable. The constraint about env vars is valuable and complete enough for this 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 100%, so the schema already documents all four parameters. The description adds minimal parameter-specific context, aside from implying the 'uri' is an external file reference. This meets the baseline but doesn't enhance schema 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 action (Attach) and the resource (externally-hosted file to a person), and it naturally distinguishes from sibling tools like getPersonAttachment and updatePersonAttachment by focusing on the create operation. The phrase 'externally-hosted file' adds specificity beyond a generic attach.

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 includes a notable usage constraint: 'Restricted - Registered Systems Only' and lists required environment variables. This gives clear context about when this tool can be used, though it doesn't explicitly name alternative tools or state when not to use 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, but it only states 'Create a pipeline.' It omits side effects, required permissions, idempotency, or return behavior, leaving the agent without crucial operational context.

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 one concise, front-loaded sentence with no wasted words. It is appropriately brief, though it borders on under-specification, stopping just short of a tautology.

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 output schema and no annotations, the description fails to explain what 'pipeline' means in context, what the response looks like, or any preconditions. It is too skeletal to be considered 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 input schema has 100% description coverage for the 'name' parameter ('Pipeline name'), so the schema already carries the semantic load. The description adds no additional parameter meaning, meriting the baseline score of 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 action ('Create') and the resource ('pipeline'), distinguishing it from sibling tools like updatePipeline and listPipelines. However, it lacks elaboration on what a pipeline represents in the domain, preventing a perfect score.

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 vs alternatives, such as updatePipeline for modifications or listPipelines for viewing. There are no exclusions, prerequisites, or contextual hints beyond the imperative verb.

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 disclosing behavioral traits. It only states 'Create a pond' and does not mention side effects, permissions, idempotency, return values, or any other meaningful behavior beyond the obvious fact that it creates a resource.

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

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

The description is very short, but it is under-specified and restates the tool name, so it does not earn its place. It is not verbose, but the content is so minimal that it fails to provide useful structure or information beyond the name.

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 mutating tool with no annotations and no output schema, the description should provide more context about what happens when a pond is created or what the resulting state is. 'Create a pond' alone is insufficient for complete understanding of the tool's behavior.

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 the only parameter 'name' with 100% coverage, so the description does not need to add parameter meaning. It earns the baseline score of 3, as it neither adds nor detracts from the schema's clarity.

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 'Create a pond' is essentially a plain-language restatement of the tool name 'createPond', providing no additional detail beyond the action and resource. It is not vague, but it qualifies as a tautology since it simply restates what the name already conveys.

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?

There is no guidance on when to use this tool vs. alternatives like listPonds, getPond, or updatePond. No prerequisites, exclusions, or contextual hints are provided, leaving the agent without direction on selecting this tool.

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

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

No annotations are provided, leaving the description to fully disclose behavioral traits. It only says 'Create a reaction' but does not mention whether duplicate reactions are allowed, whether existing reactions are replaced, what happens on error, or any required permissions. For a mutation tool, this is a significant lack of 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, clear sentence with no redundant words. It is front-loaded with the action and resource, and every word contributes to meaning. This is appropriately concise for a simple 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?

For a mutation tool with no annotations and no output schema, the description is too sparse. It does not explain return value, error behavior, or any side effects. The schema covers parameters, but the overall context is incomplete for an agent to invoke the tool with full understanding.

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% (emoji, refId, refType all have descriptions), so the schema carries the semantic load. The description adds no additional parameter context, but per the rubric a baseline of 3 is appropriate when schema coverage is high.

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

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

The description states a specific verb ('Create') and resource ('reaction on an item'), making the tool's purpose clear. Although 'item' is somewhat generic, the input schema's refType parameter clarifies that reactions are attached to items like notes or emails. No sibling tool has the same create action, so further differentiation is unnecessary.

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, such as getReactions for viewing existing reactions. There is no mention of prerequisites, intended use cases, or exclusion of certain scenarios. Users must infer usage from the name alone.

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

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

The description discloses that the relationship is its own contact record linked to personId, which is a key structural behavior beyond the schema. However, with no annotations, the description leaves gaps: it does not mention response behavior, required conditions beyond personId, or any side effects (e.g., duplicate handling, permissions). For a create tool, this is adequate 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?

Two concise sentences, front-loaded with the action and purpose. The key behavioral note about being its own contact record is included without redundancy. Every word 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 7 parameters, 100% schema coverage, and 1 required field, the description is mostly complete for a create tool. It explains the core concept and linkage, though it omits any mention of return value or error behavior. Since no output schema exists, a note on the returned object would elevate completeness, but the current context is sufficient for selecting and invoking the tool.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds that personId links the relationship to an existing person, but this is already reflected in the schema ('Person ID this relationship is associated with'). No additional parameter meaning is provided, 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 clearly states the action ('Create'), the resource ('relationship contact'), and the scope ('for an existing person') with concrete examples (Spouse, Brother, Partner). It distinguishes from createPerson by emphasizing the linkage to an existing personId and that the relationship is its own contact record.

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: when adding a relationship contact tied to an existing person. It implies that this is the alternative to creating a standalone person, but it does not explicitly name createPerson or state when not to use it, so it falls short of an explicit when/when-not listing.

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 merely repeats the function name without disclosing any behavioral traits such as side effects, permissions, idempotency, or return values.

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 short ('Create a pipeline stage') but under-specified. While concise, it fails to include necessary context and reads as a tautology of the tool name, making it insufficiently informative for an agent.

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 sparse annotations, the description should provide more context about the stage's role in a pipeline, ordering, or required pipeline association. It lacks this completeness, leaving agent to infer critical information from the schema alone.

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 covers 100% of parameters with descriptions ('Stage name', 'Pipeline ID'), so the description need not add more. The tool description itself adds no additional parameter meaning, which aligns with the baseline for full 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 'Create a pipeline stage' clearly states the action (create) and the specific resource (pipeline stage). It differentiates from sibling tools like updateStage and listStages, and clarifies it's not creating a pipeline itself.

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 no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or relationships to other stage-related tools (e.g., getStage, updateStage).

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 bears the full burden of disclosing behavioral traits. It only states 'Create a task,' which implies mutation but offers no details about permissions, idempotency, duplicate handling, return values, or side effects. This is similar to the mid-calibration example where 'update' implied mutation but lacked necessary context.

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 (one short sentence) and front-loaded, but it is under-specified. While every word earns its place, the total content is inadequate for a tool with 5 parameters, making it not 'appropriately sized.' It is concise but not sufficiently informative, similar to the calibration note about under-specification not being true 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?

This is a mutation tool with no annotations, no output schema, and 5 parameters. The description provides only 'Create a task,' which does not explain behavior, return values, or usage context. Even though the schema fully documents parameters, the tool's overall context is incomplete given the absence of safety annotations and the need for behavioral 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% (all 5 properties have descriptions), so the schema carries the parameter documentation. The tool description itself adds no parameter-level meaning. Per the calibration rules, baseline is 3 with high coverage, and there is no reason to deviate.

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 'Create a task' uses a specific verb and resource, clearly distinguishing it from sibling tools like listTasks, updateTask, and getTask. It unambiguously states the tool's core function, so it fully satisfies the purpose clarity criterion.

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 exclusions, prerequisites, or clarify how it differs from similar creation tools like createNote or createAppointment. There is no guidance at all, making this a 'no guidance' 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?

With no annotations, the description carries the full burden of behavioral disclosure. 'Create a team' only indicates a creation operation; it does not mention idempotency, potential errors, return values, or side effects, which is insufficient for a mutation 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, but it merely restates the tool name without earning its place. It provides no additional information beyond the name 'createTeam', making it an under-specification rather than effective 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 lack of annotations and output schema, the description should provide more context about the creation result, duplicates, or related operations. The current description is too minimal for a create tool, even with a simple two-parameter 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 description coverage is 100% with clear descriptions for both 'name' and 'description'. The tool description adds no parameter information, so the baseline score of 3 is appropriate as the schema already handles parameter semantics.

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

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

The description 'Create a team' uses a clear verb+resource structure, stating exactly what the tool does. It is distinct from sibling tools like updateTeam or getTeam due to the create verb, but it doesn't add extra context about what constitutes a team in this system.

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?

There is no guidance on when to use this tool versus alternatives like updateTeam or listTeams. No prerequisites, scenarios, or exclusions are mentioned, leaving the agent to infer usage entirely from 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, the description carries the full burden of behavioral disclosure. It provides none: no mention of permissions, idempotency, return values, or side effects. It merely restates the tool's purpose.

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

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

The description is concise as a single sentence, but it is under-specified, lacking the necessary context for a tool description. It is not appropriately sized; it's closer to a tautology than a helpful description.

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 lack of annotations and output schema, the description should provide more context about behavior and usage. For a simple create operation, it's minimal but complete only in the most literal sense.

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 covers 100% of parameters with clear descriptions. The tool description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description 'Create an email template' uses a specific verb ('create') and a specific resource ('email template'), clearly distinguishing it from sibling tools like createTextMessageTemplate. The purpose is immediately 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?

The description provides no guidance on when to use this tool versus alternatives (e.g., createTextMessageTemplate or mergeTemplate). No context, prerequisites, or exclusions are 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 available, the description carries the full burden. It discloses that the tool only records, does not deliver, and requires specific environment variables ('FUB_SYSTEM + FUB_SYSTEM_KEY'). This gives important behavioral context about side effects and restrictions, though it does not detail return values or error conditions.

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

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

The description is two sentences: the first states the core function, the second adds critical non-delivery and auth restrictions. Every sentence earns its place, and the main action is front-loaded. 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 tool has moderate complexity with 7 parameters, all documented in the schema. The description provides essential operational context (logging vs sending, restricted access) that is not in the schema. Given no output schema, the description is reasonably complete, though it could mention the response type or success/failure behavior.

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 provides descriptions for all 7 parameters, achieving 100% coverage, so the baseline is 3. The tool description does not add parameter-specific guidance beyond the schema, but the overall purpose helps infer how parameters like 'toNumber' and 'fromNumber' are used.

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 'LOG' and names the resource 'a text message that was already sent by your registered third-party SMS system.' It clearly distinguishes from sending SMS by explicitly stating 'does NOT actually deliver an SMS' and from template tools like createTextMessageTemplate by focusing on recording an actual message.

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 clearly defines when to use this tool: to log an already-sent SMS from a third-party system. It explicitly states what it does not do ('does NOT actually deliver an SMS'), implying not to use it for sending. It does not name specific alternative tools, but the context is sufficient to guide selection among siblings like createCall or createNote.

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. It only states the action ('Create') without disclosing any behavioral details such as required permissions, idempotency, duplicate handling, or what happens on success. This is minimal and leaves the agent without important context for a mutation operation.

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

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

The description is a single, clear sentence with no wasted words. It is appropriately concise for a simple create operation, though it could add value with minimal extra context without becoming verbose.

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 create tool with no annotations, no output schema, and no usage differentiation, the description is inadequate. It fails to clarify how this template creation is distinct from other template tools, and does not mention required fields or any post-creation effect. The gaps in usage guidance and transparency hurt completeness.

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

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

Schema description coverage is 100% for both parameters ('name' and 'body'), so the schema already provides the necessary meaning. The description adds no extra parameter semantics, but the baseline of 3 is appropriate since 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 states exactly what the tool does: 'Create a text message template.' The verb 'create' is specific, and the resource 'text message template' clearly distinguishes it from generic template tools like createTemplate and from other template CRUD operations.

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

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

No guidance is provided on when to use this tool versus alternatives. Given siblings like createTemplate, createTextMessage, and mergeTextMessageTemplate, the description does not clarify which scenario calls for this tool or mention any exclusions or prerequisites.

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 only says 'Create a webhook' without mentioning side effects, return values, required permissions, or error behavior, which is insufficient for a mutation 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 short but under-specified. The single sentence merely restates the tool name and does not earn its place by adding useful information, making it more of a placeholder than a concise description.

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, and the description is minimal. It lacks critical context about webhook event types, URL expectations, and how it relates to sibling webhook tools, making it inadequate for a 2-parameter 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 input schema fully describes both parameters (url as 'Callback URL' and event as 'Webhook event type'), so schema coverage is 100%. The description adds no additional parameter context, meeting the baseline but not exceeding 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 'Create a webhook' is essentially a tautology of the tool name 'createWebhook'. It states the action and resource but adds no specificity about the webhook's purpose or distinguishing characteristics.

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 like listWebhooks, getWebhook, updateWebhook, or getWebhookEvents. There is no mention of prerequisites, use cases, or 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?

There are no annotations, so the description must convey behavioral traits. The verb 'Get' clearly indicates a read-only operation, but it does not disclose potential error outcomes, response structure, or any special behaviors. Given the simplicity, this is a minor gap but the description is very minimal.

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, concise sentence with no redundant words. It directly states the action and object.

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 provides the essential purpose. However, it could be more complete by mentioning that it returns the full appointment object or noting the absence of side effects. Overall, it's adequate but not exhaustive.

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 only parameter `id` with 'Appointment ID' at 100% coverage. The description 'by ID' adds no semantic enrichment beyond the schema. Baseline 3 is appropriate.

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

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

The description uses the specific verb 'Get' with a clear resource 'appointment' and identifies the primary parameter 'by ID'. This clearly distinguishes it from sibling tools like listAppointments, createAppointment, or updateAppointment.

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 instead of alternatives such as listAppointments or getAppointmentType. It lacks any mention of prerequisites, alternative approaches, or 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?

With no annotations provided, the description must carry the behavioral disclosure burden. The verb 'Get' implies a read-only operation and no side effects, which is adequate. However, it does not specify what happens if the ID is not found (e.g., returns null or throws an error) or whether the full outcome object is returned.

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, front-loaded sentence with no filler or redundancy. It efficiently conveys the essence of the tool without unnecessary details, making it easy for an agent to parse.

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 single-ID lookup tool with no output schema, the description sufficiently conveys the operation and resource. It would benefit from explicitly stating what is returned (e.g., 'Returns the appointment outcome matching the given ID'), but the resource name and 'by ID' imply the return value well enough for a low-complexity 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 input schema already provides full coverage for the single parameter 'id' with description 'Outcome ID'. The description merely restates 'by ID' without adding new semantic detail, such as format expectations or alternatives. 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 states the operation ('Get'), the specific resource ('appointment outcome'), and the access pattern ('by ID'). This distinguishes it from sibling tools like listAppointmentOutcomes, which would retrieve multiple outcomes without a specific ID.

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

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

No guidance is provided about when to use this tool versus alternatives. For example, it does not mention that listAppointmentOutcomes should be used for listing all outcomes, or that this tool is for single-record retrieval when the ID is already known. The 'by ID' clause is implicit context but not explicit 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?

No annotations are provided, so the description must carry the full burden. It correctly indicates a get (read) operation with no side effects, but it does not disclose return format, error behavior, or permissions. The minimal behavior is transparent, but additional context is lacking.

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, concise sentence of six words. Every word contributes to the meaning, with no unnecessary information. Excellent structure and length.

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 required parameter and no output schema, the description is adequate. It clarifies the resource and the method of lookup. It could mention that the full appointment type object is returned, but this is easily inferred from the tool name and 'get' semantics. Given the simplicity, this is reasonably complete.

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

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

Schema coverage is 100% with the parameter described as 'Type ID'. The description mentions 'by ID', which aligns with the schema but does not add additional meaning beyond what the schema already provides. This meets 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 clearly states the verb ('get'), resource ('appointment type'), and scope ('by ID'). It effectively distinguishes itself from sibling tools like listAppointmentTypes, createAppointmentType, and updateAppointmentType, which have different actions.

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 when you have a specific ID, but it does not explicitly mention when to use it versus alternatives, nor does it provide exclusions or references to other tools. The context is clear from the phrase 'by ID', but the guidance is only implicit.

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 must convey safety and behavioral traits. It only says 'Get an automation by ID' without disclosing what is returned, error handling (e.g., 404 if not found), permissions, or rate limits. This leaves the agent without sufficient transparency for a tool with no annotation support.

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, direct sentence with no fluff. It efficiently states the purpose without redundancy, making it appropriately concise for a simple getter.

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

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

Given the simple nature of the tool and lack of output schema/annotations, the description is incomplete. It does not mention return format, error behaviors, or authentication needs, which are critical for an agent to use it correctly in real 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?

The input schema fully describes the single 'id' parameter (100% coverage) as 'Automation ID', so the description adds no additional parameter semantics. Baseline of 3 is appropriate since the schema carries the semantic load.

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 'Get an automation by ID' uses a specific verb and resource, clearly indicating it fetches a single automation. It distinguishes itself from sibling tools like listAutomations and getAutomationPerson by focusing on the automation entity itself.

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

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

No guidance is provided on when to use this tool versus listAutomations or other automation-related tools. The description does not mention prerequisites, exclusions, or alternative 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It only states the basic action and does not reveal any behavioral traits such as error handling (e.g., what happens if the ID does not exist), whether authentication is required, or whether it is a safe read operation. This minimal description lacks context beyond the literal 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, efficient sentence with no redundant information. It is appropriately sized for a simple get-by-ID tool and front-loads the core action. Every word 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's simplicity—one required parameter, no output schema, no nested objects—the description is largely complete for an agent to select and invoke it correctly. It does not explain what an 'automation-person entry' is, but the sibling tool names (e.g., addPersonToAutomation, listAutomationsPeople) provide context. A brief note about return behavior or non-existence handling could enhance completeness, but it is not strictly necessary for such a straightforward operation.

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 provides a description for the 'id' parameter ('AutomationPerson ID') with 100% coverage. The tool description adds no additional meaning beyond confirming the lookup is by ID. Since schema coverage is high, the baseline score of 3 is appropriate.

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

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

The description explicitly states 'Get an automation-person entry by ID', which uses a specific verb ('Get'), identifies the resource ('automation-person entry'), and specifies the access method ('by ID'). This clearly distinguishes it from siblings like listAutomationsPeople (listing) and addPersonToAutomation/updateAutomationPerson (mutations).

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 does not explicitly state when to use this tool vs alternatives. The parameter requirement ('by ID') implies it is for fetching a single specific record, contrasting with listing tools, but this is implied rather than stated. No exclusions or explicit guidance are provided.

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 merely says 'Get a call by ID' without disclosing response format, error behavior (e.g., 404 not found), or whether it returns the full call object. Minimal 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?

Single concise sentence that front-loads the purpose. Zero wasted words, appropriate for the tool's simplicity.

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

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

Given the simple nature (one parameter, no output schema), the description is minimally adequate but lacks detail on return value or error cases. It meets the viability threshold but does not enrich beyond the bare operation.

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 the parameter 'id' described as 'Call ID'. The description repeats 'by ID' without adding extra meaning beyond the schema, so the baseline of 3 applies.

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

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

Description 'Get a call by ID' uses a specific verb and resource, clearly distinguishing this from siblings like listCalls, createCall, and updateCall. It precisely states the operation and the scope (by ID).

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

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

No explicit guidance on when to use this tool versus alternatives. The context implies usage when a specific call ID is known, but no alternatives are named or exclusionary conditions 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?

Without annotations, the description carries the full burden of behavioral disclosure. It only restates the action and gives the endpoint, but does not explain the return format, error behavior (e.g., unauthenticated requests), or that it is a read-only operation. The 'get' verb and 'GET' method hint at safety, but deeper details are missing.

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, front-loaded sentence that conveys both the action and endpoint. It is maximally concise without any wasted words, making it easy to parse and understand quickly.

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 zero-parameter tool with no output schema, the description is relatively complete. It tells the agent exactly what to expect: it gets the current authenticated user. However, it could be improved by noting the return type (e.g., 'returns the user object') or any authentication prerequisites, but these are largely implied by the tool's name and endpoint.

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 there is nothing to add. The schema coverage is 100% by virtue of having no params. The description does not need to explain any parameters, and the baseline for zero-param tools is 4, which is appropriate here.

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 function: 'Get the current authenticated user' with the explicit endpoint '(GET /me)'. The verb 'Get' is specific, and 'current authenticated user' distinguishes it from sibling tools like getUser (which implies fetching a user by ID) and listUsers (which lists multiple users).

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention that this is the appropriate tool when you need the current authenticated user's information without providing an ID, nor does it exclude alternatives like getIdentity or getUser. The context is implied by the name but not articulated.

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, but it only states the action without any detail on return format, error behavior, permissions, or side effects. For a mutation or complex tool this would be a serious gap; for a simple getter it is still minimal disclosure, hence a low score.

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 concise sentence that front-loads the verb and resource. No wasted words, and it is appropriately sized for a simple parameterless-except-id getter. It fits the tool's simplicity perfectly.

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 single required parameter with full schema coverage and no nested objects or output schema, the description is adequate but has gaps. It never states what is returned (e.g., the custom field object) or how errors are handled (e.g., 404 if not found). With no annotations to fill in safety/behavior, the tool is not fully specified, but the simplicity keeps it at a minimum viable level.

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% since the only parameter 'id' has a description 'Custom field ID'. The description's 'by ID' confirms the schema but adds no new meaning. Baseline for high coverage is 3, and no extra semantic value is provided, so the score stays at baseline.

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 'Get a custom field by ID' uses a specific verb with a clear resource and the method of lookup. It unambiguously distinguishes this getter from related list/create/update custom field tools, even though it doesn't explicitly differentiate from getDealCustomField which operates on a different resource.

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 like listCustomFields or getDealCustomField. There is no mention of prerequisite steps, typical use cases, or situations to prefer another tool. It is a bare statement with zero usage 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 full burden of behavioral disclosure. It does not mention whether the operation is read-only, what happens on missing IDs, or what fields are returned. It essentially restates the tool name with 'by ID', adding no behavioral insight 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 a single, front-loaded sentence with no redundant words. It is concise but not overly terse to the point of being cryptic, fitting the simple nature of the 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?

Given the tool's simplicity, the description is minimally adequate, but it lacks detail about the return format, error behavior, and any required permissions. No output schema exists, so the description could have added more context, but it does not. For a simple get-by-ID, this is a borderline 3.

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 `id` parameter as 'Deal ID' (100% coverage). The description's 'by ID' merely reiterates the schema, adding no new semantic meaning. 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 'Get a deal by ID' clearly specifies a single-entity retrieval operation with verb 'get', resource 'deal', and scope 'by ID'. This distinguishes it from siblings like listDeals (bulk retrieval) and createDeal/updateDeal. The intent is unambiguous.

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

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

No usage context is provided. The description does not state when to use this tool instead of listDeals or other getters, nor any prerequisites such as requiring a valid deal ID. This leaves the agent without guidance on tool 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It only states the action 'Get' with no additional context about return format, error behavior, permissions, or whether the actual file content or just metadata is returned. This is minimal for a read operation without annotation support.

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, front-loaded sentence with zero waste. Every word contributes to conveying the tool's purpose, making it exceptionally 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 1-parameter getter, the description is adequate but lacks detail about the return value, such as whether it returns file content or metadata. Since there is no output schema to fill this gap, the description would benefit from mentioning what the response contains, though the tool's simplicity keeps the gap small.

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

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

Schema description coverage is 100% with 'Attachment ID' clearly describing the 'id' parameter. The description's 'by ID' reinforces the schema but adds no new semantic meaning beyond what the schema already provides, matching the baseline 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 'Get a deal attachment by ID' clearly identifies the action (get), resource (deal attachment), and qualifier (by ID). It is distinct from sibling tools like createDealAttachment and getPersonAttachment, which differ by action or resource type.

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 when you have a deal attachment ID and need the attachment, but it does not explicitly state when to use it over alternatives or any exclusions. No alternative tools are mentioned, though the sibling context makes the use case reasonably clear.

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

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

No annotations are provided, so the description must convey behavioral traits. The verb 'Get' implies a read-only operation, which is a basic behavioral signal. However, it does not disclose error behavior, permission requirements, or return format, leaving some ambiguity for an agent.

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 concise sentence that immediately communicates the tool's purpose. It is appropriately sized, front-loaded, and contains no unnecessary words.

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

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

The tool is a simple getter with one parameter and no output schema, so the description is mostly adequate. However, it does not clarify the distinction between deal custom fields and other custom field types (e.g., person custom fields), nor does it describe the return object. This missing context could confuse an agent in this sibling-rich environment.

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 covers 100% of the parameter, describing 'id' as 'Field ID'. The description adds no additional meaning beyond the schema, so with high schema coverage 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 states the action and resource: 'Get a deal custom field by ID'. It provides a specific verb and target. However, it does not differentiate from sibling tools like getCustomField or listDealCustomFields, so it lacks explicit sibling distinction.

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 no guidance on when to use this tool versus alternatives. It does not mention scenarios where listDealCustomFields or getCustomField would be more appropriate, nor any prerequisites. The only implied usage is that an ID 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals only that it retrieves an event, but says nothing about return format, error behavior (e.g., 404 if not found), or permission 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 a single, front-loaded sentence with zero wasted words. It immediately states the verb and resource, making it highly skimmable.

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 simplicity (one parameter) and complete schema coverage, the description is minimally sufficient. However, without an output schema or annotations, it lacks details about the return value shape and edge cases, leaving some ambiguity 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 coverage is 100%: the id parameter is described as 'Event ID' in the schema. The description adds no additional semantic detail, but the schema fully documents the only parameter, so baseline 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 'Get a single event by ID' clearly states the action (get), the resource (event), and the scope (single by ID). It distinguishes from sibling tools like listEvents (which lists events) and createEvent (which 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?

The description implies usage when you have a specific event ID and need that one event. However, it provides no explicit guidance on when not to use it or alternatives (e.g., use listEvents to search/filter).

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 behavioral disclosure. It does not explicitly state that this is a read-only operation, nor does it mention error handling, permission requirements, or what happens if the group does not exist. The verb 'get' implies safety but does not adequately disclose 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 a single concise sentence, front-loaded with the action and resource. There is zero filler or redundant information, making it highly concise and easy to process.

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 get-by-ID tool, the description is minimally viable but has clear gaps. There is no output schema or annotations, and the description does not specify what the return value contains (e.g., the full group object) or behavior on not-found errors. However, given the simplicity of the tool, this may be adequate in 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?

The input schema fully describes the single 'id' parameter (type: number, description: 'Group ID'), giving 100% schema description coverage. The description adds no additional parameter meaning beyond what the schema already provides, 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 'Get a group by ID' clearly states the action (get), resource (group), and search criterion (by ID). It distinguishes itself from sibling tools like listGroups and updateGroup by explicitly indicating a single-group retrieval by ID.

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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of exclusions. The description relies solely on the verb 'get' to imply usage, but does not reference sibling tools like listGroups or listRoundRobinGroups, which are the obvious comparisons.

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 convey behavior. It indicates a read operation via 'Get' and specifies the API key context, but it does not explicitly state side-effect safety, response structure, or error behavior. It adds some context but lacks rich behavioral 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 a single focused sentence with no redundant words. It is appropriately concise for a simple, parameterless 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?

Given the tool's simplicity (no parameters, no output schema), the description sufficiently communicates its purpose and scope. It could mention specific fields returned, but 'identity/account information' adequately covers the value returned.

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 does not need to clarify parameters; the schema already shows an empty object. No parameter information is missing.

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