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

No annotations are present, so the description carries the full burden. It discloses the cross-organization admin behavior and access restriction, which are meaningful. However, it does not describe authentication consequences, permission bypass, or error/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?

Two short sentences with no wasted words. The core action, scope, and access restriction are all delivered efficiently and front-loaded.

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

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

For a low-complexity tool with two required string parameters and no output schema, the description gives enough context to select and invoke it. It could be more complete by naming a regular alternative and explicitly stating expected returns, but the essential selection criteria are present.

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

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

Schema description coverage is 0%, so the description must compensate. It gives meaning to the 'id' parameter via 'by id', but leaves the 'token' parameter almost entirely implicit. Admin/support-only usage hints at token relevance, but no format, source, or role requirements are stated.

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 has a specific verb and resource: 'Get any note by id, across organizations.' It clearly distinguishes itself from sibling tools like note_get and note_get_scoped by emphasizing cross-organization scope and admin/support-only access.

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?

'Admin/support use only' provides a clear who-can-use exclusion, and 'across organizations' clarifies when this tool is appropriate. It does not explicitly name an alternative like note_get for normal scoped access, so it stops short of full alternative routing.

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

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

With no annotations, the description carries the behavioral burden. It conveys a read-only operation through 'Fetch' and explicitly states the one-call and 20-item limit. However, it does not disclose behavior for missing/invalid IDs, partial failure, authentication via token, or return ordering/shape. Basic transparency exists but is incomplete.

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

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

A single sentence that front-loads the action, resource, and key constraint. Every word contributes: 'Fetch multiple notes by id', 'single call', and 'up to 20 ids'. No filler, no redundancy.

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

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

The description gives a basic adequate overview for a simple batch get, but it lacks details that an agent would need given there is no output schema and no annotations: return format, order, behavior for missing IDs, and auth expectations. It also fails to distinguish from note_batch_resolve, making full context incomplete.

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 property descriptions have 0% coverage, so the description must add meaning. It does clarify that 'ids' are note identifiers, which maps directly to the IDs array. However, it says nothing about the 'token' parameter, its role, or any format details beyond the schema. The compensation is only partial.

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 ('Fetch'), names the resource ('notes'), specifies the selection criterion ('by id'), and highlights the batch/single-call behavior with a hard cap (20 ids). This clearly distinguishes it from note_get (single note) and other siblings.

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 usage context is implied: fetch multiple notes by ID in one call. However, it does not explicitly name alternatives like note_get for single fetches or note_batch_resolve, nor does it say when not to use this tool. The sibling note_batch_resolve creates ambiguity that the description does not address.

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 the 50-id cap and that all requested notes are returned, but does not explain what happens with invalid or missing ids, whether results preserve request order, what token scope is required, or how errors are surfaced. For a batched fetch tool this is a noticable 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 one sentence, front-loaded with the core action, and adds the important 50-id bound without padding. It is appropriately concise, though it sacrifices behavioral nuance.

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 annotations, no output schema, and 0% schema coverage, the description is too thin to fully support correct invocation. It leaves out error handling, the meaning of token, ordering behavior, and relationship to note_batch_get, making the tool incomplete for an agent encountering it among many note tools.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that ids are note identifiers and that up to 50 can be provided, but it completely omits the meaning of the required token parameter, leaving the agent without enough information to construct a correct call.

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 (fetch), the resource (multiple notes by id), and the batching behavior, making the basic purpose easy to grasp. However, it does not distinguish itself from the sibling note_batch_get, which appears to cover the same operation, so it falls short of a 5.

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

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

The phrase 'in a single batch call' implies this tool should be used when retrieving multiple notes at once, so usage context is partially conveyed. But it provides no explicit guidance on when to prefer this over note_get or note_batch_get, and no exclusions are 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 behavioral disclosure burden, but it only restates the mutation. It does not mention auth requirements, what the token represents, side effects, permissions, or failure 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 efficient sentence with the action and scope front-loaded and no filler. Brevity is good, though it sacrifices useful guidance.

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

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

Given the many sibling note creation tools and no annotations or output schema, the description is too thin for confident tool selection and invocation. Token semantics and differentiation from sibling tools are missing.

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

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

Schema description coverage is 0% and the description adds no meaning for body, title, or token. The required token parameter is completely unexplained, leaving an agent without enough information to populate parameters confidently.

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 ('a note') with an organizational scope, so the basic purpose is evident. However, it does not distinguish note_create from siblings like note_create_in_org or note_create_limited.

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 the many sibling creation variants, nor any exclusions or prerequisites. 'In your organization' hints at scope but does not tell an agent when to prefer note_create over alternatives.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It reveals only that the tool creates a note and that org_id targets the destination org; it does not disclose permission requirements, whether org_id is mandatory, side effects, or response/error behavior.

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

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

Two tight sentences with the core operation and scope first, followed by the critical parameter clarification. Every sentence earns its place and no filler is present.

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

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

For a mutation tool with no annotations and no output schema, this is thin. It omits return value, error behavior, required auth, and how this tool relates to note_create or note_create_limited, leaving an agent without enough context to invoke it confidently beyond simple cases.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning only for org_id ('targets the destination org'); token, title, and body are left to inference, and the description does not resolve whether org_id is required even though the schema marks it optional.

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?

States a specific action—create a note—and a precise scope: inside a specific organization, with cross-team collaboration intent. It also clarifies that org_id targets the destination org, distinguishing this from generic note_create siblings even without naming them.

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

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

The description gives a clear context ('inside a specific organization', 'cross-team collaboration') that tells an agent when this tool is appropriate. It does not explicitly name note_create as the alternative or exclude cases where organization targeting is not needed, so it stops one step short of full routing 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 behavioral burden. It usefully discloses the quota limit (max 3) and that tracking is per client identity. However, it does not explain what happens when the quota is exceeded, authorization requirements, or the creation outcome, leaving meaningful behavioral 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 description is compact, front-loaded, and each sentence earns its place: the first defines the action and limits, the second clarifies how the limit is tracked. There is no redundant or filler content.

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

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

Despite a small parameter set, the lack of annotations, zero schema descriptions, no output schema, and close sibling tools make the description insufficient. An agent cannot confidently determine what 'token' means, how to identify the client, or what error/response to expect when the quota is reached.

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

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

Schema description coverage is 0%, so the description needed to compensate for the three parameters. It does not mention token, title, or body by name, and 'client identity' is only an oblique reference to what is likely the token. The description adds little beyond the generic act of creating a note.

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 and resource: 'Create a note'. It also distinguishes this tool from sibling note_create by naming the per-client quota constraint (max 3 notes), making the tool's specialized role clear.

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

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

The quota and client-identity tracking imply this tool is for creating notes under a client-scoped limit, but there is no explicit when-to-use or when-not-to-use guidance, and no alternative sibling is named. The usage context is only implied, not 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a note is deleted but does not mention whether deletion is permanent, whether it requires specific permissions, if it can be undone, or what side effects occur. For a destructive operation, this transparency 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?

The description is a single short sentence with no fluff. It is front-loaded and easy to parse, though it sacrifices informative detail for 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?

With no annotations, no output schema, and two required parameters, the description is too minimal. It omits critical context about authorization, permanence, failure behavior, and the meaning of the token parameter, leaving the agent under-equipped to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description only clarifies the 'id' parameter indirectly by saying deletion is 'by id.' The 'token' parameter is not explained at all, leaving the agent without guidance on what token is expected or how it is 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 a specific verb ('Delete') with a clear resource ('a note') and identifying key ('by id'). It is immediately distinguishable from sibling tools like note_get, note_update, and note_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?

The description gives no guidance on when to use this tool versus alternatives, such as when to delete versus update, or whether deletion is scoped to certain note types. The user must infer usage solely 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 provided, the description carries the full burden of behavioral disclosure. It only mentions the admin-only restriction for the wildcard org_id; it does not reveal whether the operation is read-only, returns a downloadable file, triggers a side effect, or produces a large payload, and it offers no information about rate limits or failure modes.

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 short sentences with no fluff: the core purpose is front-loaded, and the admin-only caveat is a natural follow-up. 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, this description is incomplete. The required token parameter is undocumented, the export output format is entirely unspecified, and the behavior when org_id is omitted is not addressed. The only complete context is the wildcard global-export path.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It explains org_id's special '*' value and the admin constraint, but it never mentions token—the only required parameter—or even what a normal org_id should look like. This leaves a significant gap for the required parameter.

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

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

The description uses a specific verb ('export') and a clear resource ('all notes for an organization'), and it adds the wildcard behavior for global exports. However, it does not explicitly contrast itself with sibling tools like note_list or note_get, so the agent must infer the distinction from the word 'export' alone.

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

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

It provides a clear context for org-scoped exports and flags global export as admin-only, which gives some usage boundary. But it does not state when to use this tool over alternatives like note_list or note_search, nor does it explain what happens when org_id is omitted.

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 only says 'Get one note by id' and does not mention whether the operation is read-only, what permissions or token scopes are required, whether errors are thrown for missing notes, or what the response contains.

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 short and front-loaded with the core action, which is good. However, it is under-specified even as a minimal viable definition; a single terse sentence does not provide enough surrounding structure or context to be genuinely helpful.

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, no output schema, and two required parameters that are completely undocumented, the description is not complete enough. It fails to explain token usage, return values, error behavior, or how this tool differs from its many similarly named siblings.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It does not mention 'token' at all and only indirectly implies 'id' through 'by id.' The agent receives no added meaning about token purpose, id format, or relationships between the 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 clearly states the verb ('Get'), the resource ('one note'), and the selection criterion ('by id'). This distinguishes it from tools like note_list and note_batch_get, though it does not explicitly name those alternatives.

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

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

The description gives no guidance on when to use this tool versus closely related siblings such as note_get_by_query, note_get_scoped, note_batch_get, or note_search. The intended use is only implicitly 'when you need a single note by its id,' but no exclusions or alternatives are 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?

No annotations are provided, so the description carries the full burden. It discloses that the operation fetches, implying read-only behavior, but does not explain what 'filtered store query' means, whether token scoping applies, what happens on missing IDs, or any side effects. This is too thin.

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 short and front-loaded, but 'resolved through a filtered store query' is vague and potentially confusing. Brevity is good, but here it sacrifices necessary 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?

For a tool with no annotations, no output schema, two undocumented required parameters, and many similar siblings, this description is incomplete. It lacks parameter explanations, behavior on not-found, and guidance on how this differs from note_get.

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

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

Schema description coverage is 0% and the description adds no meaning to the 'id' or 'token' parameters beyond their string types. The token is presumably an auth token, but that is never stated.

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 ('Fetch a single note by id') and the resource ('note'). It is distinct from list/search tools, but does not differentiate it from the sibling note_get, which likely does the same thing directly.

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 note_get, note_search, note_get_scoped, or note_get_by_token_scope. The phrase 'resolved through a filtered store query' hints at a different mechanism, but no conditions or alternatives are stated.

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

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

With no annotations, the description carries the burden of explaining behavior. It does disclose the key behavioral trait: notes are fetched read-only based on the token's scope claim rather than an explicit org parameter. It does not mention token validity, error behavior, pagination, or response shape, but this is minimally adequate for a read-only get 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 brief and front-loaded, stating the primary purpose in the first sentence. The second sentence reinforces the token-based scoping behavior and is not filler, but it is somewhat redundant with the first sentence, preventing a perfect 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?

For a two-parameter retrieval tool, the description provides enough information to understand the core call: pass a token and optionally override the scope. However, without an output schema or annotations, missing details such as return shape, error behavior, and how this differs from note_get_scoped leave moderate 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 50%: the optional scope parameter is documented, while the required token parameter has no schema description. The description adds meaning to token by explaining that it carries the intended scope, but it does not elaborate on the optional scope override semantics or token format, so it only partially compensates for the schema gap.

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 clear action ('Get notes') and resource ('organization indicated by the token's scope claim'), so an agent understands what the tool returns and how the target organization is determined. However, it does not differentiate it from closely named siblings like note_get_scoped or note_get_by_query, so it stops short of full clarity.

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 intended use case: retrieve notes when the token's scope claim selects the organization. It does not explicitly say when to use this tool over note_get_scoped, note_get, or note_get_by_query, and it provides no exclusions or alternatives.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does reveal a meaningful behavior: the tool honors an X-Org-Id routing header set by the API gateway. However, it does not mention return format, pagination, or whether the org header changes which notes are visible.

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 no filler. The primary purpose is front-loaded, and the routing behavior is added concisely without redundancy or repetition of schema 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 one-parameter list tool, the description provides the core operation and a useful routing detail. However, with no annotations, no output schema, and many sibling tools, it would benefit from clarifying the token's role and how 'scoped' differs from note_list or note_get_by_token_scope.

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

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

Schema description coverage is 0%, and the description never explains the required 'token' parameter. 'List the caller's notes' indirectly implies that token identifies the caller, but the agent is left to infer this rather than being told.

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 ('List') and the resource ('the caller's notes'), giving an unambiguous purpose and a specific scope. It stops short of explicitly distinguishing itself from similar siblings like note_list or note_get_by_token_scope, so it misses 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 phrase 'List the caller's notes' implies the main use case: returning notes owned by the current caller. However, it does not state when to prefer this tool over note_list, note_get_by_token_scope, or note_search, nor does it give any exclusions or alternative routing 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 must carry the behavioral disclosure burden, but it only states the scope ('in your organization') and the read-style verb 'List'. It does not mention whether this is read-only, what is returned, pagination/ordering, authorization requirements, or the meaning/role of the token.

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, front-loaded sentence with no filler. It is concise, though not fully adequate for the missing parameter and usage semantics.

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

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

Without annotations, output schema, or parameter descriptions, the description alone is too thin for safe invocation. It covers the basic purpose but lacks token semantics, return shape, pagination, and when-to-use context, making it incomplete against the rich sibling toolset.

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

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

Schema description coverage is 0%, and the only required parameter, token, is a bare string. The description never mentions token, so the agent cannot know whether it is an auth token, a pagination token, or an organization token. The description must compensate for the missing parameter documentation and does not.

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

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

The description uses a specific verb ('List') and resource ('notes in your organization'), making the tool's core purpose clear. It differentiates from note_get/note_create but does not explicitly separate list from the similarly broad note_search or note_get_by_query.

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 about when to use note_list instead of note_search, note_get_by_query, or note_export. There are no exclusions, prerequisites, or alternative conditions, so the agent must infer usage from the tool name and siblings.

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

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

With no annotations, the description carries the transparency burden. It does disclose the core behavior (substring search) and an important scoping restriction (org_id for admin use), but it omits details such as pagination, result format, auth semantics, and error behavior, so transparency is only partial.

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

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

Two short sentences with the primary action front-loaded. Every clause adds information, and there is no filler or repetition of the tool 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?

Given no annotations, no output schema, and zero schema coverage, the description is too thin. An agent cannot tell when to choose this over note_get_by_query, what the response contains, or whether the result set is limited, which are significant gaps for a search tool.

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

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

Schema description coverage is 0%, so the description must compensate. It gives meaning to q as the substring and explains org_id as an optional admin scope restrictor, but token is left entirely to inference from its name rather than described.

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 and resource ('Search notes') and adds a distinguishing matching criterion ('by substring'). This separates it from list/get tools at a basic level, though it does not explicitly call out sibling alternatives like note_get_by_query.

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 about when to use note_search versus note_list, note_get_by_query, or note_get_scoped. The only contextual hint is that org_id is admin-only, which tells the agent nothing about when substring search is preferred over other query mechanisms.

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 carry the behavioral burden. It discloses that the grant is opaque and redeemable via a specific sibling, which is useful context. However, it does not mention side effects, authentication, persistence, expiry, or what the caller receives, leaving gaps for a state-changing 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 front-loaded sentence with no filler. It is concise and focused, though the brevity sacrifices paramameter guidance.

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

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

Given no annotations, no output schema, and undocumented parameters, the description is not sufficient for an agent to invoke the tool correctly. It lacks parameter semantics, return behavior, and side-effect information.

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

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

Schema description coverage is 0%, and the description provides no explanation of the 'token' or 'id' parameters. The agent is left to guess which parameter identifies the note and which serves as an authorization or grant token.

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 ('Prepare') and resource ('opaque share grant') and clearly scopes it to 'one of your own notes.' It also names the redemption tool, which differentiates it from sibling note_share_redeem and other note tools.

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 this tool is for creating a share grant, while note_share_redeem is for redeeming one. It also gives a usage restriction ('one of your own notes'). However, it does not explicitly state when to avoid this tool or compare it to other sharing-related siblings.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It mentions that the grant is opaque and tied to note_share_prepare, but it does not say whether redemption consumes the grant, mutates access, requires specific auth, or what the response contains.

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?

One tightly written sentence with no filler. The verb and object come first, and every word contributes meaning, including the critical linkage to note_share_prepare.

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 annotations and no output schema, the description leaves important operational context unexplained: what a successful redemption returns, whether the grant is single-use, and what error cases may arise. The link to note_share_prepare helps but does not cover these 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 description coverage is 0%, so the description must compensate. It only echoes the concept of a 'share grant' without clarifying the distinct roles of 'token' and 'grant', their format, or how the two relate.

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 'redeem' with a clear resource, 'an opaque share grant produced by note_share_prepare.' This identifies both the action and the exact provenance of the input, distinguishing it from every sibling tool by naming its paired producer.

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

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

The phrase 'produced by note_share_prepare' gives clear contextual guidance: use this tool when you have a grant from that preparation step. It does not explicitly enumerate exclusions or alternative tools, so it stops short of full 5-level 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 states the core mutation but does not mention required authentication, overwrite behavior, error cases for missing or invalid ids, or whether the update is reversible. This leaves important behavioral context unstated.

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 wasted words. It conveys the operation, target, and identifier efficiently.

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 three-parameter mutation with no annotations and no output schema, this description is too thin. It does not explain return values, error outcomes, authentication prerequisites, or when to prefer this tool over a sibling such as note_create or note_get.

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

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

Schema description coverage is 0%, so the description must add parameter meaning. It clarifies that 'id' selects the note and 'body' supplies the new content, but it says nothing about the required 'token' parameter, leaving one of three parameters unexplained.

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 and resource: 'Update a note's body by id.' It clearly identifies the operation, the target entity, and the selection method, and it distinguishes the tool from siblings like note_create, note_get, and note_delete.

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

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

The phrase 'Update a note's body by id' gives clear context: use this tool when an existing note's body needs to be changed. It does not explicitly name alternatives or exclusions, but the operation and target are clear enough to route an agent correctly.

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 behavioral-transparency burden. It correctly implies a read-only introspection and specifies what is returned, but it does not disclose behavior for invalid or expired tokens, nor does it explicitly state that no side effects occur.

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. The core scope ('session (user + org)') is front-loaded, and every word contributes meaning.

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

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

For a one-parameter tool with no output schema, the description covers both input semantics and return content. The only notable omission is error/edge-case behavior for invalid tokens, which is a minor gap for such a simple read-only 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 description coverage is 0%, so the description must compensate. It clarifies that the 'token' parameter is the caller's authentication token and the basis for the session lookup. However, it does not specify token format or how the token is expected to be supplied, leaving some ambiguity.

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 ('Return') and resource ('session (user + org)') tied to token authentication, making the tool's purpose unambiguous. It is clearly distinct from the sibling note_* tools, which all handle note 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?

The description gives clear context: use this when you need to know which user and org a token authenticates as. It does not explicitly discuss alternatives or exclusions, but no sibling tool overlaps with this identity-resolution task, so the missing exclusion is low-risk.

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