Noemic

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

With no annotations, the description carries the full burden. It reveals the default endsAt behavior but does not disclose whether additions are incremental or replace existing slots, authentication requirements (sessionToken is in schema), rate limits, idempotency, 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 long, direct, and front-loaded. No extraneous information. Every sentence adds value.

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

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

For a mutation tool with no output schema and no annotations, the description is incomplete. It does not describe the return value, success/failure indicators, or behavior on overlapping slots. Given the complexity of managing availability slots, more context is needed.

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

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

The description adds meaningful value beyond the input schema by explaining that 'endsAt defaults to one hour after startsAt'. This clarifies behavior for optional parameter endsAt. Schema descriptions cover both parameters but the default behavior is only in the description.

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

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

The description states a clear verb+resource ('Add open session slots to the user's profile') and mentions the default behavior for endsAt. While it distinguishes from siblings that set general availability or read availability, it does not explicitly contrast with similar write tools like 'become_available' or 'set_available_now'.

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 'become_available' or 'set_available_now'. There are no usage context notes, prerequisites, or when-not-to-use instructions.

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

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

With no annotations, the description carries full burden. It discloses that the operation is append-only and date-stamped, and requires consent. It does not mention potential side effects, authentication requirements beyond the session token (already in schema), or rate limits. More detail on consequences of multiple appends would improve 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 consists of two concise sentences: the first states the core function, the second lists relevant examples. No superfluous words; every sentence adds value. It is well-structured and easy 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?

The tool is simple with only two parameters and no output schema. The description adequately covers what the tool does and what kind of input is expected. However, it lacks information on the return value or error states (e.g., what happens if the session token is invalid). Given the low complexity, this is a minor gap.

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 significant meaning to the 'text' parameter by specifying it should be content that helps future matching, with examples. The 'sessionToken' parameter is already well-described in the schema. This compensates for the schema's lack of description for 'text', raising the score above 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 specifies the action: 'append text to the user's agent-readable corpus'. It provides concrete examples of what kind of text to include (new experiences, session details, boundaries), making the purpose distinct. However, it does not explicitly differentiate from sibling tools like 'port_context', which also adds 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 implies usage with 'with their consent' and suggests content that helps future matching. It indicates the tool is append-only and date-stamped. However, it does not specify when not to use it or mention alternative tools for related tasks (e.g., port_context). The guidance is adequate but not explicit.

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

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

No annotations provided. Description mentions ranking and assignment but does not disclose read-only nature or side effects of assignment. Lacks behavioral detail for a safe read tool.

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

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

Two sentences with no wasted words. Front-loaded with main purpose, then usage hints. Efficient.

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

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

For a simple search tool with one optional parameter, the description covers what it does, how to use it, and what to expect. No output schema, but examples suffice.

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 has one string parameter with 0% description coverage. Description compensates by giving search examples and indicating plain language usage, adding value beyond schema.

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

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

Clearly states it is a library of public artifacts ranked by real adoption, searchable and assignable. Distinguishes from sibling tools like create_artifact or my_artifacts.

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

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

Provides examples of plain language search, but does not explicitly contrast with other search tools or specify when to use this versus alternatives like my_artifacts.

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

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

No annotations are provided, so the description carries full burden. It discloses key behaviors: artifacts can be personal or library items, only one per call, and the client's agent administers it with results returning. It does not address permissions, error states, or rate limits, which are gaps 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?

Two sentences, each earning its place: the first defines purpose and parameters, the second provides timing and outcome. No fluff, front-loaded with key 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?

With 4 parameters, no output schema, and no annotations, the description covers the core action, source of artifacts, timing, and result flow. Missing details include required parameters beyond implicit, error handling, and how to retrieve the result. It is functional 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?

Schema coverage is low (25%), but the description adds meaning by explaining 'artifactId' as from personal or library sources, and 'note' as optional. 'sessionToken' is well-documented in schema. 'connectionId' lacks explanation. Overall, the description moderately supplements the schema.

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

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

The description clearly states the action ('assign an artifact') and the resources ('yours or from the library' to a client). It distinguishes the tool's role as pro-side and mentions one-at-a-time assignment, though it does not explicitly contrast with sibling tools that may also involve artifacts.

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 timing guidance ('as a session lands, one artifact at a time') and outlines the post-assignment flow. However, it lacks explicit when-not-to-use instructions or alternatives, leaving the agent to infer context from the sibling list.

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 key behaviors: preview vs. publish mode, no credentials/review, self-set rate, and availability inclusion. It does not mention potential side effects or limitations.

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

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

The description is concise and well-structured, starting with the core purpose, then usage guidance, and parameter hints. It covers essential information without unnecessary detail.

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

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

Given the complexity (9 parameters, no output schema), the description adequately covers the tool's behavior and workflow. It mentions the preview output and quality notes, compensating for missing output schema.

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

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

Schema coverage is high (89%), but the description adds value by explaining the intended use of parameters like story, availability, and publish. It provides practical context beyond the schema definitions.

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: 'Create the user's profile so others can book them.' It uses a specific verb-resource combination and distinguishes from siblings like add_availability or set_available_now.

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 context on when to use the tool, including drafting from conversation, confirming with user, and the preview-then-publish workflow. It lacks explicit when-not-to-use guidance but is clear overall.

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

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

No annotations exist, so description carries full burden. It discloses that the tool returns a secure URL, and instructs to keep requestId and pollSecret private. However, it doesn't state if calling repeatedly creates multiple sessions or if the URL expires.

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

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

The description is four short, front-loaded sentences. Every sentence adds necessary information: condition, behavior, output display, and security warning. 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?

Given zero parameters and no output schema, the description provides all needed guidance: when to call, what the tool returns, and how to handle the response. It fully covers the interaction pattern for a sign-in initiation 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?

No parameters in schema (100% coverage), so baseline is 4. The description adds value by explaining the output (signInUrl) and non-obvious handling (keep secrets private), which compensates for lack of params.

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 the tool initiates sign-in, returns a URL for login/account creation, and distinguishes the action from other authentication steps (e.g., finish_sign_in). Clear verb 'begin sign-in' and defined outcome.

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

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

Provides specific condition: 'Call only when the user is ready for an identity-bearing action.' Also includes critical negation: 'Never ask for credentials in chat.' This tells the agent when and when not to use the 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?

With no annotations, the description must disclose behavioral traits. It states that the booking starts immediately and the result contains a roomUrl, but it fails to mention error conditions (e.g., what if the person is not availableNow), side effects, required permissions, or the nature of the pricing calculation.

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: two sentences. The first sentence covers the core functionality and output, the second covers pricing and default duration. No unnecessary words, and key information is front-loaded.

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

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

Given 3 parameters and no output schema, the description is incomplete. It fails to explain error handling, validation, or what happens if required parameters are invalid (e.g., expired sessionToken, nonexistent profileId). It also does not describe the response format beyond roomUrl.

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 low (33%), with only sessionToken having a description. The tool's description does not explain the parameters at all, beyond implying a 'minutes' parameter via default duration. It does not clarify the role of profileId or any constraints beyond the schema.

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

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

The description clearly states the tool's purpose: instant session with someone whose availableNow is true. It distinguishes from book_session by mentioning same pricing, implying a different use case. However, it could be more explicit about the precondition that the person must be currently available.

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 some usage context: it mentions the default duration (30 minutes) and compares pricing to book_session. However, it does not explicitly state when to use this tool vs. alternatives like book_session for future bookings, nor does it specify prerequisites or 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?

The description explains pricing logic (first free, then credit, then charge) and notes the result indicates payment. However, it does not disclose side effects (e.g., slot becomes unavailable), authorization requirements, or error handling. With no annotations, this 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 concise (3 sentences) and front-loaded with the main action. It avoids redundancy. However, the pricing explanation could be more compact. No wasted words overall.

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 and 3 required parameters, the description is incomplete. It explains pricing but not the return structure, error cases, what happens if the slot is already booked, or confirmatory details. A booking tool needs to specify the outcome and prerequisites for successful use.

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 low (33%), only sessionToken has a description. The tool description provides no additional explanation for slotId or profileId, leaving their meanings and sources unclear. The pricing context does not compensate for missing 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 clearly states 'Book an open slot with a person.' This distinguishes it from siblings like 'book_now' by specifying the resource (open slot) and the person. The verb 'book' is precise and the target 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?

The description implies usage context (when a user wants to book a slot) but provides no explicit guidance on when to use this tool versus alternatives like 'book_now'. It does not mention prerequisites (e.g., slot must be available) or 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, the description carries full burden and discloses key behavioral traits: refund, credit return, slot reopening. It does not mention side effects like notifications or authorization requirements, but is reasonably transparent for a straightforward mutation.

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 purpose and adds essential behavioral details with zero 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?

The description covers the tool's effect on the booking, but with no output schema, it omits return value or response format. Given low complexity (2 parameters), it is minimally complete for an agent to understand primary 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?

Schema description coverage is 50% with only sessionToken described. The description adds no meaning to bookingId beyond being a string, and does not explain how to obtain it (e.g., from my_bookings). The parameter semantics are under-specified.

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 'Cancel' and the resource 'a confirmed booking', and provides specific details about the effects (refund, credit return, slot reopen). It distinguishes from sibling tools as no other tool is named 'cancel_booking' or has similar 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?

The description implies usage for cancelling a confirmed booking but does not explicitly state when not to use or provide alternatives. Since there is no sibling tool with a similar purpose, it is minimally adequate.

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 full burden. It discloses key behaviors: returns unread messages from all connections and marks them as delivered. This is sufficient for a simple read operation.

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

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

Three sentences with no waste. First sentence gives timing, second describes output, third gives response advice. Front-loaded with 'heartbeat' metaphor.

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

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

Given no output schema, the description lacks explicit return structure details, but the simple nature of the tool (messaging) and the provided context (unread messages from all connections) make it adequate. Could mention error handling, but overall 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 only parameter, sessionToken, has 100% schema coverage. The description adds value by explaining its role ('proves which user is acting') and giving usage advice ('reuse for whole conversation; never raw email'), exceeding the schema's basic description.

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

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

The description clearly states the tool's purpose: checking unread messages for a user, using the verb 'call' and specifying the resource 'messages'. It distinguishes from siblings like 'send_message' by focusing on reading unread messages.

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 says 'call whenever your user shows up', providing clear usage context. It does not explicitly state when not to use it, but the context is sufficient for most agents.

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 indicates a destructive action ('close') but lacks details on side effects (e.g., whether a closed brief can be reopened) or authentication requirements 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, concise sentence with no superfluous words. It is front-loaded with the core action and reason contexts, making it efficient for quick scanning.

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

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

Given the tool has two parameters with only 50% schema coverage and no output schema, the description is too sparse. It does not mention prerequisites (e.g., brief must be open), return values, or error conditions, 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?

Schema coverage is 50% (sessionToken has a description). The tool description does not add meaning for 'briefId' beyond the schema, and the sessionToken description in the schema is adequate. Overall, the description contributes little to 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 action ('close') and the resource ('open brief'), with common reasons in parentheses. It effectively communicates the tool's purpose, though it does not explicitly distinguish it from siblings like 'file_brief'.

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 contextual examples of when to close a brief ('found someone, or the need passed'), but does not specify when not to use it or provide alternatives. The usage context is implied rather than explicit.

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

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

With no annotations, the description provides one behavioral clue: 'No topic returns the index.' However, it does not disclose side effects, mutability, or behavior when a topic is provided. Partial 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?

Two sentences with front-loaded information. The list of topics is clear and the behavioral note is compact. No redundancy, although the phrase 'Ground your...' is somewhat vague.

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?

No output schema, so the description should explain return values. It only says 'No topic returns the index' without describing the index format or content when a topic is provided. This leaves the agent guessing about the tool's output.

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

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

The schema has no parameter descriptions (0% coverage). The description compensates by listing valid topic values (active_listening, etc.), adding meaning beyond the schema. It does not specify case or format, but provides useful guidance.

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

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

The description implies the tool provides curriculum information for coaching, listing specific topics and noting that omitting a topic returns an index. However, it lacks an explicit verb like 'retrieve' or 'get', making the purpose vague.

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 phrase 'Ground your cues, debriefs, and artifact designs in this' hints at context but does not specify conditions 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?

No annotations provided; description partially discloses behavior: result lands in connection where person sees it. However, no mention of side effects, idempotency, or required permissions beyond the session token in 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?

Two sentences with clear front-loading of action and context. No redundant information, though could be more precise about 'script'.

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 3 required parameters, no output schema, and no annotations, the description is insufficient. It omits result format, error conditions, and return value, relying too heavily on the schema.

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

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

Schema coverage is only 33% (only sessionToken described). Description adds minimal guidance—'what the script asked for'—but doesn't clarify 'result' or 'assignmentId' utility beyond schema.

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

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

The description clearly states the action ('post back what the script asked for') and resource ('assigned exercise' result). It distinguishes from siblings like 'complete_session' by focusing on assignments, though 'script' is ambiguous.

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?

Implies usage 'after administering an assigned exercise', but lacks explicit when-to-use or alternatives among sibling tools. No guidance on prerequisites or exclusion cases.

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 provided, so description carries full behavioral disclosure burden. It discloses that calling earns a session credit and grows quality record, which are side effects. However, it does not mention idempotency, error states, or what happens if called multiple times, leaving some 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?

Only two sentences, front-loaded with the action timing and effect. No wasted words, but the phrase 'the loop that keeps Noemic alive' is slightly jargon-heavy and could be more universally clear.

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 50% parameter coverage, the description explains core purpose and side effects but lacks detail on the bookingId parameter and expected return value. It is minimally viable but leaves practical gaps for an AI 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 50% (only sessionToken described in schema). Description adds no meaning for bookingId, which remains undocumented. It does not explain what bookingId represents or how to obtain it, leaving a significant gap for parameter usage.

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?

Title says 'Mark a session completed' and description reinforces that it is called after a session actually happened, specifying the resource (session) and action (complete). However, it does not explicitly distinguish from sibling tools like session_debrief or cancel_booking, which are also session-related.

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?

Description says 'Call after a session actually happened,' which implies when to use, but provides no guidance on when not to use or how it compares to alternatives like cancel_booking or session_debrief. No explicit exclusions or alternative tool mentions.

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

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

Description explains that script is followed by client's agent and public artifacts join shared library, but omits details on destruction, reversibility, auth requirements, or side effects of isPublic flag. No annotations provided to compensate.

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, each delivering key info: tool purpose, script role, and public library. Efficient but first sentence contains jargon ('Pro-side', 'ONCE') that may require prior context.

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?

Covers creation and script usage, but lacks details on post-creation workflow, error handling, or prerequisites. Given no output schema and 5 parameters, description could better integrate with sibling tools like assign_artifact.

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 high (80%), but description adds meaning beyond schema by explaining the role of 'script' as facilitator instructions and clarifying that isPublic defaults to true implies sharing. This conceptual context is valuable.

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

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

Description clearly states the tool creates an interactive exercise (artifact) with specific examples, and distinguishes from siblings by emphasizing it's a one-time design. However, 'Pro-side' jargon and lack of explicit differentiation from siblings like assign_artifact slightly reduce 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?

Implies use for designing once and not for assignment (sibling assign_artifact exists), but no explicit when-to-use or when-not-to-use instructions. References coaching_playbook for patterns, but does not clearly guide selection among 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 provided, the description carries full burden. It fully discloses the behavioral traits: staking money, refund on success, forfeit on failure, a $500 cap per user, and that the result reports remaining headroom. It also advises on follow-up and title checks, providing rich 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 four sentences long and front-loaded with the core purpose. It is efficient but could be slightly more concise by merging some sentences. Still, every sentence earns its place.

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

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

Given the absence of an output schema and 6 parameters, the description provides sufficient context: explains the stake mechanism, the cap, and offers usage guidance. It lacks details on the result structure but covers the core behavioral aspects adequately.

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 67% (4 of 6 parameters have descriptions). The description adds context about the stake and cap but does not explain each parameter individually beyond what the schema provides. The value added is moderate, meeting the baseline for this coverage level.

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 'stakes' and identifies the resource 'commitment' clearly. It explains the mechanism (succeed/refund, fail/forfeit) and provides guidance on title formulation. It distinguishes itself from other commitment-related tools like resolve_commitment by focusing on creation with monetary stakes.

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 practical usage advice: 'Make the title concrete and checkable' and 'Follow up with the user before the deadline.' It also mentions the server-enforced cap and the reporting of headroom. However, it does not explicitly state when not to use this tool or contrast it with alternatives like resolve_commitment.

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 covers key behaviors: the brief is anonymous, persists, returns immediate matches, and continues to match new people. It does not mention editing or limits, but provides adequate 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 somewhat poetic and could be more direct, but it conveys necessary information without excessive wordiness. A tighter focus on the core action would improve it.

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 explains the overall purpose, behavior, and post-use action (check my_briefs). It lacks details on output format or error cases, but is sufficient for the tool's simplicity.

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 covers 'sessionToken' (50% coverage). The description adds rich semantics for 'need': 'a few real sentences — situation, what kind of person would help, cadence they want', which compensates for the schema's lack of description.

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

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

The description clearly states the tool's action: 'File what the user needs' and explains it creates a filed document describing a need, returning matches. It distinguishes from siblings like 'my_briefs' (for later retrieval) and 'open_briefs'.

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 advises checking 'my_briefs' on later visits, indicating this tool is for initial filing. It contrasts with search ('not a search') but does not explicitly exclude 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 discloses key behavioral traits: the tool is a polling step that returns a sessionToken upon completion, and warns about exposing secrets. It lacks details on whether the operation is destructive or what state changes occur, but it adds meaningful context beyond the schema.

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

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

Three concise sentences front-loaded with the trigger condition. Every sentence adds value: usage timing, outcome explanation, and security warning. No redundant or extraneous 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?

Given the tool's simplicity (2 params, no output schema), the description is comprehensive. It covers when to use, what parameters are needed, what states exist, and what the tool returns. No obvious gaps remain.

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 requestId and pollSecret are private, come from begin_sign_in, and must not be exposed. This adds crucial meaning beyond the raw schema types and constraints.

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 defines the tool's purpose: exchanging private requestId and pollSecret from begin_sign_in to obtain a sessionToken after user approval. It distinguishes from sibling tools like begin_sign_in and logout by specifying its role in completing the sign-in flow.

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

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

The description provides clear usage context: 'After the user chooses I've signed in' and explains the two possible outcomes (pending vs complete). It does not explicitly list when not to use or alternative tools, but the context is sufficient for an AI agent to decide when to invoke 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?

With no annotations, the description carries full burden. It discloses that slots are open, future, and ordered soonest first, but omits details like whether it returns time ranges, duration, or pagination. No contradictions with annotations (none provided).

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 (two clauses) and front-loaded with key information: what is returned, its status, and ordering. Every word adds value.

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

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

For a simple tool with one parameter and no output schema, the description covers the core behavior: retrieving open future slots for a person, sorted soonest. It lacks details on output fields (e.g., slot duration, time format) but is sufficient for basic usage.

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

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

The only parameter profileId is not described in the schema (0% coverage). The tool description clarifies it refers to 'a person', adding meaning beyond the schema, but provides no format or example. Baseline 3 is appropriate given low coverage.

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

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

The description clearly states the tool retrieves open (unbooked, future) slots for a person, sorted soonest first. This is specific and distinguishes from siblings like add_availability or become_available.

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

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

The description implies the tool is for viewing availability, but does not explicitly state when to use it vs alternatives like book_session or check_messages. No 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?

No annotations provided; description is brief and does not disclose behavior beyond returning a full profile (e.g., error handling, response format, rate limits, required auth).

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 sentence, front-loaded with key info, no extraneous text.

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?

Adequate for a simple get-by-id tool, but missing output schema and description of return structure beyond 'story + corpus' limits 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?

Adds minimal meaning by stating 'by profile id' but does not explain format or source of the id. Schema coverage is 0%, so description partially compensates but lacks depth.

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?

Clearly states verb 'get' and resource 'one person' by profile id, distinguishes from list_people and my_profile by specifying full profile includes story and corpus.

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?

Implies usage for fetching a single person by id, but lacks explicit when to use vs siblings like list_people or my_profile, and no when-not-to-use guidance.

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

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

No annotations are provided, so the description carries full burden. It states the tool returns a state and presentation format but does not disclose whether the tool has side effects, requires authentication, or other behavioral traits. Some transparency but 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?

Three concise sentences, front-loaded with critical usage instruction, followed by return description and presentation guidance. 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?

Given the tool is simple with no parameters and no output schema, the description adequately explains what it returns and how to present it. However, it lacks detail on the 'four paths' or marketplace state, which could be clarified.

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?

Tool has zero parameters and schema coverage is 100%, so baseline is 4. Description adds no parameter-specific guidance, but none is needed.

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

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

The description clearly states the tool's purpose: orienting a first-time user by returning the honest state of the marketplace and the four paths. It distinguishes itself from siblings as an onboarding tool.

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

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

Explicitly instructs to call this FIRST when a user has just connected or is unsure, providing clear contextual guidance for when to use the 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?

With no annotations, the description carries full responsibility. It mentions the tool returns people and that 'the full read always fits', implying no pagination. It also says to present a small panel, hinting at output behavior. However, it does not explicitly state if the operation is read-only, does not disclose authorization needs, side effects, or rate limits. Moderate 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 paragraph with verbose storytelling ('THE PRIMARY DISCOVERY MOVE', 'you are the matcher'). While front-loaded with key information, it contains fluff that could be trimmed. Not extremely 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?

For a list tool with 4 parameters and no output schema or annotations, the description covers purpose and usage guidelines but lacks details on return format, error handling, or exact output limits. It mentions 'small panel' but not count. Incomplete in some aspects.

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%, baseline 3. The description adds conceptual grouping: 'price of entry, presence, an opening soon' maps to parameters like maxHourlyRateDollars, availableNow, hasOpeningWithinDays. It also clarifies that categories are not filters. This provides extra meaning beyond the schema.

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

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

The description states it lists people for discovery, using 'List everyone' in the title and describing it as 'THE PRIMARY DISCOVERY MOVE'. It clearly identifies the resource (people) and verb (list), and distinguishes itself from match_me. However, the metaphorical language ('you are the matcher', 'READ every story and corpus') slightly muddles the directness.

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

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

Explicit guidance is provided: 'prefer this over match_me', indicating when to use this tool over a sibling. It also describes the workflow: optionally narrow by formal facts, then read results. This makes the usage context very 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?

Discloses the destructive effect (token no longer works) and the need to login again. With no annotations, the description fully covers 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?

Two sentences, no wasted words, front-loaded with the key action. Highly efficient.

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

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

For a simple one-parameter tool, the description explains the effect and a typical use case (shared device). No gaps remain.

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 covers 100% of parameters with a detailed description. The tool description does not add significant extra meaning beyond the schema, meeting 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?

Clearly states the tool invalidates a session token, making it stop working, and requires re-login. Verb ('invalidate') and resource ('sessionToken') are specific, and it distinguishes from sibling login/register.

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

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

Provides a usage example ('on a shared device'), giving context for when to use. While no explicit exclusions or alternatives are mentioned, the purpose is clear enough among siblings.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool ranks tokens (not meaning), and specifies that results contain 'availableNow', 'freeFirstSession', and 'next opening'. It does not detail the exact format of results but is largely transparent.

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

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

The description is concise, with no fluff. It uses clear, directive language and front-loads the purpose ('SHORTCUT, not the primary move'). Every sentence adds value.

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

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

For a simple tool with two parameters, no output schema, and no annotations, the description adequately covers when to use, what results contain, and how to handle results. It provides sufficient context for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 50% (only 'need' has a description). The description adds context that 'need' is a 'plain-language description' but does not elaborate on the 'limit' parameter beyond its schema definition. The description partially compensates for the missing parameter description but not completely.

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 it is a 'server-side keyword pre-ranker' and a 'shortcut' for when 'list_people is too long'. It distinguishes itself from the sibling tool 'list_people' by specifying its role as a faster alternative for shortlists.

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

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

Explicitly advises to prefer 'list_people + your own reading' and to use this tool only when list_people is too long. Also provides guidance on presenting results, such as leading with 'availableNow' people when the user needs immediate support.

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 disclose behavioral traits. It does not state whether the tool is read-only or has side effects. The mention of 'adoption counts' hints at return data but lacks details on mutation, permissions, or lifecycle.

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 at one sentence. It conveys the core purpose without waste. However, it could be slightly expanded for clarity without losing 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 no annotations or output schema, the description is incomplete. It does not explain return format, pagination, error handling, or whether the result is filtered by the authenticated user. For a simple list tool, more context is needed.

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

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

Schema coverage is 100%, so the schema fully documents the single parameter (sessionToken). The description adds no further semantic meaning beyond the schema, so 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 it returns artifacts designed by the pro, with adoption counts. It implies a list of the pro's own creations, distinguishing from general artifact_library. However, it does not explicitly differentiate from sibling tools like assign_artifact or create_artifact.

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 siblings like artifact_library or create_artifact. No prerequisites or exclusions are mentioned, leaving the agent to infer 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 must fully disclose behavior. It mentions 'Client-side' and 'pending exercises' but does not explicitly state that the tool is read-only, or describe side effects. The instruction to 'run each script' suggests a subsequent action, not the tool's direct output, leaving ambiguity about return format.

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 and front-loads key information. The phrase 'Client-side' is slightly vague but overall it is concise and avoids waste.

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

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

Given the absence of an output schema, the description should explain what the tool returns. It mentions 'pending exercises' but does not detail the structure or fields. The guidance to 'run each script' is helpful for usage but insufficient for full completeness.

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

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

The only parameter, sessionToken, is fully described in the input schema. The description adds no additional meaning for the parameter, so it meets 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 clearly states that the tool lists pending exercises assigned by the user's people, using specific verbs like 'pending exercises' and 'run each script'. It distinguishes itself from the sibling tool 'complete_assignment' by prescribing that as a subsequent 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 gives clear context for when to use the tool: to see pending assignments for the user. It also guides the agent to run each script conversationally and then use 'complete_assignment'. However, it does not explicitly exclude scenarios or mention alternatives.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It mentions roles and sorting but omits details like authentication requirements (though sessionToken suggests them), pagination, response format, or rate limits. The description provides basic but incomplete 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 concise sentence that efficiently conveys the core purpose and sorting. Every word serves a purpose with no redundancy or unnecessary detail.

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

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

Given the tool's simplicity (one required param, no output schema) and the descriptive schema, the description adequately covers the main concerns: roles and sorting. It could mention the return format (e.g., list of bookings with details) but this is not critical for basic usage.

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

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

The input schema has 100% coverage with a well-described sessionToken parameter. The description does not add any parameter-specific details beyond what the schema already provides. Thus, it meets the baseline but adds no extra semantic value.

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

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

The description clearly states the tool retrieves bookings for both client and pro roles, sorted by earliest first. This specifies the verb (list), resource (bookings), and scope (own bookings across roles), distinguishing it from sibling booking action tools like book_now or cancel_booking.

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

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

The description implies the tool is for viewing one's own bookings, but it does not explicitly state when to use it versus alternatives. Among siblings, no other listing tool exists, so context is clear, but no exclusions or prerequisites 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?

No annotations are provided, so the description must carry the burden. It implies a read operation ('all briefs with matching re-run') but does not explicitly state safety (e.g., read-only). It also does not mention side effects or authentication needs beyond the session 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?

Two concise sentences: the first states functionality, the second provides usage context. No redundant information or excess 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?

Given the tool's simplicity (one parameter, no output schema), the description adequately conveys what it does and when to invoke it. It mentions the return includes briefs and intros, but lacks explicit return structure.

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 parameter coverage is 100% (one required parameter). The schema itself provides a detailed description of `sessionToken`. The tool description adds no additional parameter meaning, baseline 3 is appropriate.

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

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

The description clearly states it returns 'all briefs with matching re-run against today's marketplace plus any intros received,' which is a specific verb and resource. It hints at differentiation from siblings like 'open_briefs' by mentioning matching re-run and intros, but doesn't explicitly distinguish.

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 advises calling 'when your user returns' because new people may have joined. This provides context but lacks explicit when-not-to-use or alternatives among sibling tools.

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

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

No annotations are provided, so the description carries full burden. It discloses the content (AI debriefs from sessions where user was pro), ordering (newest first), and privacy. It does not explicitly state read-only or mention limitations like pagination or completion status, but it is sufficiently transparent for a list 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?

Three sentences, each functional: first defines content/ordering, second gives usage instruction, third adds motivational context. No redundant words; every sentence earns its place.

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

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

No output schema exists, so the description should indicate return format. It mentions 'AI debriefs' and 'recurring growth themes' but does not specify fields like date, session title, or theme details. Adequate for a list tool but could be more complete to guide agent extraction.

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

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

The only parameter is sessionToken, with a detailed schema description explaining its origin, reuse, and security. Since schema coverage is 100%, baseline 3 is appropriate. The tool description adds no additional parameter information but provides context on the output.

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

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

The description clearly states that the tool retrieves all AI debriefs from sessions where the user acted as the pro, sorted newest first, and is private. It specifies the verb implicitly (list/get) and distinguishes from sibling tools like 'session_debrief' (single debrief) and 'write_debrief' (creation).

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 says 'Read it before their next session and coach them on the recurring growth themes,' providing a clear use case and preparatory action. It implies when to use (before coaching) but does not explicitly exclude 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?

Discloses sorting (active first) and included fields (status, deadlines). With no annotations, it sufficiently describes behavior for a read-only listing, though does not mention authentication details or safety.

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

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

Two concise sentences front-loading purpose and a specific use case, 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 simple list tool with one parameter and no output schema, the description is adequate but lacks details on return format or filtering. Could benefit from listing example fields.

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?

100% schema coverage with detailed description for sessionToken. Description adds no further parameter meaning beyond schema.

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

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

Describes listing all commitments with status and deadlines, clearly distinguishing from siblings like create_commitment or resolve_commitment.

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?

Hints at use case for nudging deadlines but does not explicitly state when to use this tool over alternatives or when not to use it. No exclusion criteria.

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

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

No annotations are provided, so the description carries full burden. It discloses the tool returns 'who, context brief, last message, active witnessed commitments'—clear behavioral traits about the data returned. However, it does not mention side effects, pagination, or sorting, but for a read-only list 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 fluff. The first sentence front-loads the core purpose and content. Every word adds value.

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

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

Given the tool's simplicity (1 param, no output schema), the description adequately explains what is returned. Could mention ordering or pagination, but not essential. No annotations to fill gaps.

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

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

The only parameter, sessionToken, is well-described in the schema (purpose, reuse, not email). The description adds no additional meaning beyond the schema. With 100% schema coverage, baseline score 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 title 'The user's standing relationships' and description 'Every connection: who, context brief, last message, active witnessed commitments. The relationships you are responsible for keeping alive.' clearly state the tool lists all connections with specific details. It distinguishes from siblings like list_people (which likely lists people generally) and get_person (single person details).

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 to view one's connections, but no explicit guidance on when to use it versus alternatives like get_person or list_people. No exclusion criteria or context for using this tool over others is 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 must carry the burden. It discloses that credits auto-redeem on the next paid booking, but does not state whether the operation is read-only, what triggers modifications, or any required permissions.

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 that define and add behavior. Every word is necessary and there is 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?

Despite no output schema and no annotations, the description is minimal. It fails to explain what the returned data looks like (e.g., count, list, units), the effect of calling it, or any error conditions. The auto-redeem behavior is mentioned but leaves many operational aspects unclear.

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

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

Schema coverage is 100% and the schema already provides a detailed description of the sessionToken parameter. The tool description adds no additional parameter information, so it meets the baseline but does not exceed.

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

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

The description clearly states the tool returns unredeemed session credits earned by running sessions. It uses specific terms and distinguishes from sibling tools that deal with bookings or assignments.

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 prerequisites or when not to use it, leaving the agent to infer from the tool's name and 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 provided, so the description carries full burden. It does not state that the operation is read-only, nor does it mention any side effects, authentication requirements (though implied by sessionToken), pagination, or response structure. This is insufficient for a tool with zero annotation coverage.

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

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

Two sentences, front-loaded purpose, no fluff. The second sentence provides a follow-up 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?

The tool has one parameter and no output schema. The description is minimal: it states what the tool returns but not the format or structure of the response. It also lacks details like whether the list is limited or paginated. For a simple tool, it is 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 coverage is 100%, so the schema already describes the sessionToken parameter. The description adds context that intros are 'pending' and 'addressed to the user', but does not add syntax or format details 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 clearly states that the tool lists pending intros addressed to the user. It implies a 'list' action and distinguishes from siblings like 'respond_intro' and 'send_intro'. However, it could be more explicit with a verb like 'List pending intros'.

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 suggests using 'respond_intro' after viewing pending intros, providing a hint about workflow. But it does not specify when not to use this tool or mention alternatives like 'send_intro'. No explicit exclusions.

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

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

No annotations are provided, so the description carries the burden. It hints at being a read operation ('status probe', 'cheaper'), but does not explicitly state no side effects. Adequate but not fully explicit.

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

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

Two sentences: first describes function, second gives usage context. No wasted words, front-loaded with key information.

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

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

The description lists the types of information returned (profile, bookability, credits, sessions, commitments) and provides usage context. Lacks details on output format or error conditions, but acceptable for a simple status probe.

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 covers 100% of parameters with full description. The tool description adds no new meaning beyond the schema. 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 clearly states it's a status probe for the user's profile, bookability, credits, sessions, and commitments. It distinguishes from siblings like 'my_credits' or 'my_bookings' by aggregating multiple statuses.

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

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

Explicitly advises calling this before assuming anything about the user's state, and notes it's cheaper than asking. While it doesn't list alternative tools, the guidance is clear and actionable.

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. It discloses anonymity ('never the person') and implies it's a read-only view of demand. However, it does not explicitly state side effects, rate limits, or other behaviors beyond the basic operation. The description adds value but could be more comprehensive.

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

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

The description is three sentences, front-loaded with the core purpose. Every sentence adds unique value: purpose, audience, and action. 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?

Given no parameters or output schema, the description provides sufficient context: what it does, for whom, and how to interact (send_intro). It could mention what data is returned (e.g., list of briefs with IDs), but the mention of 'briefId' in send_intro implies the output includes IDs.

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 no parameters, so baseline is 4. The description does not need to add parameter meaning, and it correctly omits any mention of non-existent 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 tool opens briefs anonymously, focusing on the need not the person. It specifies the audience (supply side: pros or hesitant would-be pros) and distinguishes from siblings like 'my_briefs' (personal briefs) and 'close_brief'.

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

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

The description explicitly states when to use: to show a pro what demand exists or to show a hesitant pro that people are waiting. It also hints at a follow-up action (send_intro). However, it does not explicitly state when not to use or list alternatives, but the context is clear given the sibling list.

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 for behavioral disclosure. It mentions client-side execution and user consent, which imply non-destructive local write, but does not detail side effects (e.g., overwrite behavior, idempotency) or error scenarios. 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?

The description is concise (three sentences) and front-loaded with key information. Every sentence adds value, though the first sentence is slightly run-on. No waste, but could be slightly more 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 simplicity (3 params, no output schema, no annotations), the description provides good context: client-side nature, consent requirement, replacement of intake interview, and updatable nature. It does not explain return behavior or error handling, but these are less critical for a write 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 67% (2 of 3 params explained in schema). The description adds value for the 'context' parameter by explaining its content ('what is going on, history...'), but does not clarify the 'connectionId' parameter, which lacks schema description. The 'sessionToken' parameter is already well-documented in the schema.

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

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

The description clearly states the action ('write the full situation into the connection') and the resource (connection), and explains the purpose ('so their person starts knowing everything'). It distinguishes itself from siblings by focusing on context transfer, though not explicitly compared.

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 specifies that it is 'Client-side only' and requires 'user's consent,' providing clear usage context. It also notes that it 'Replaces the intake interview' and can be 'Update[d] as things evolve,' but does not explicitly mention when not to use it or list 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 provided, so the description carries full burden. It discloses that the tool involves self-reporting and honest recording, and specifies stake consequences. However, it does not mention authentication requirements, irreversibility, or any side effects beyond stake handling.

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, entirely front-loaded: purpose first, then usage guidance. No fluff or repetition. 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?

Four parameters, no output schema, no annotations. The description covers the core behavior but lacks details on parameter requirements, return values, or edge cases (e.g., what if commitment already resolved?). Adequate but not thorough.

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

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

Schema description coverage is only 25% (only sessionToken described). The tool description does not explain the other three parameters (commitmentId, succeeded, note), leaving the agent uninformed. The description adds no value beyond the schema's minimal documentation.

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 ('resolve') and resource ('active commitment'), and explains the two possible outcomes (refund vs forfeit). This fully differentiates from sibling tools like 'create_commitment'.

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 says 'Self-report — ask the user directly and record their answer honestly.', instructing the agent on how to use the tool. It does not mention when not to use or alternatives, but the guidance is clear and actionable.

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 a key behavioral trait: accepting creates a long-standing connection where messages, sessions, etc., live. It also suggests a follow-up action. With no annotations provided, this is valuable context, though the decline case is not covered.

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, concise and front-loaded with the key effect. It could be more structured to cover the decline case, but no unnecessary information is present.

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

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

The description only addresses the acceptance behavior, ignoring what happens on decline. With no output schema, expected return values or side effects are not explained, leaving the tool's full behavior under-specified.

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

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

Schema description coverage is only 33% (only 'sessionToken' has a description). The tool description does not add meaning for 'accept' or 'introId' beyond what the schema provides, so it fails to compensate for the missing parameter documentation.

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 title 'Accept or decline an intro' and description state that accepting creates a connection. This clearly distinguishes it from sibling tools like 'send_intro'. However, the description does not explicitly address the decline action, leaving 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?

The description implies when to use (when accepting an intro) and advises 'immediately port_context' if the user is client side. However, it lacks explicit guidance on when to choose this tool over alternatives or 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?

Describes that the cue appears in the pro's room panel and the client never sees it. Also imposes a practical limit of one short cue. However, it omits any mention of auth requirements or rate limits, which would improve 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?

Highly concise with three sentences, each carrying essential information. No fluff, front-loaded with key purpose and constraints.

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?

Fairly complete given no output schema or annotations. Covers usage, behavior, and parameter semantics. Could mention potential response or error states, but overall adequate.

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?

Adds significant meaning beyond the schema: imposes a 25-word maximum on text (schema allows 400), and provides discipline on content (question, dropped thread, etc.). The schema has only 33% coverage, so description compensates fully.

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 defines the tool's purpose: whispering a cue to a pro during a live session, and it distinguishes from siblings like send_message by specifying the pro-only, client-invisible 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?

Explicitly states when to use (pro-only, live session), what to send (one short cue max 25 words, specific), and what not to do (generic advice). Provides clear guidance on appropriate 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?

No annotations provided, so description carries burden. It discloses privacy (no emails exposed) and outcome (acceptance creates connection) but lacks side effects, authentication details beyond schema, or error cases.

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

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

Three sentences, concise and front-loaded with key information. Could be slightly more efficient but not 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?

Adequate for the tool's complexity but lacks details on return values, success/failure indicators, and error handling given no output schema.

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

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

Schema coverage is 50%; the description clarifies briefId and profileId (missing in schema) by explaining their roles, adding value beyond the schema.

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

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

The description clearly states the verb 'send' and resource 'intro', and distinguishes two modes (profileId vs briefId). It differentiates from siblings like respond_intro by describing the two directions.

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 explains when to use each direction (profileId for person, briefId for need) but does not explicitly state when not to use or name alternative tools.

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

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

No annotations were provided, so the description must cover behavior. It mentions async relay and bidirectionality but lacks details on authentication, rate limits, delivery guarantees, or destructive actions. 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?

The description is very short (two sentences) and front-loaded with the core concept. However, it could be slightly more structured to separate purpose from usage hints.

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, 3 parameters, and no annotations, the description lacks prerequisites (e.g., how to get connectionId), return value, and error handling. Incomplete for reliable agent usage.

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

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

Schema coverage is only 33% (sessionToken described). The description does not explain text's constraints or how to obtain connectionId, failing to compensate for low schema coverage.

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

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

The description clearly states it's an async relay between two people for messages, emphasizing brief daily check-ins. This distinguishes it from siblings like check_messages (reading) and send_intro (introductions).

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 implies usage for short, frequent messages with 'daily two-line check-in' but does not explicitly specify when to use this tool vs alternatives like send_cue or 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?

No annotations provided, so description carries full burden. It implies a read operation (fetching debrief) without stating side effects or safety. Lacks explicit mention that it does not modify data, but is not misleading.

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 that front-load the main purpose and usage. No redundant or extraneous information.

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

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

For a simple retrieval tool with 2 params and no output schema, description covers when, who, and what is returned. Could mention error cases (e.g., session not ended, wrong pro) but overall adequate.

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 covers only sessionToken (50%). Description adds context: sessionToken is an auth token, bookingId identifies the session. However, bookingId lacks direct schema description, and description doesn't fully compensate for that 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?

Description clearly states the tool retrieves an AI debrief for a completed session, specifying content (what worked, changes, drill) and that it is pro-only. Distinguishes from siblings like write_debrief or close_brief.

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

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

Explicitly says 'After a session ends' and 'Pro-only: the email must be the session's pro'. Provides context for when to use, but does not mention alternatives or when not to use (e.g., if session is still ongoing).

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?

Describes consent-gating, participant-only access, and live polling behavior with sinceMs. With no annotations, this is helpful but does not cover rate limits, auth details, or response structure. Some behavioral context is provided but not comprehensive.

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

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

The description is four sentences, front-loaded with key context (consent-gated, participants only, live polling). No redundancy or fluff; every sentence earns its place.

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

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

Given the 3 parameters, no output schema, and no nested objects, the description adequately covers purpose, access restrictions, and usage pattern. However, it omits details about the return format or error conditions, which could be important 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 already describes 'sinceMs' and 'sessionToken' with adequate descriptions. The description adds value by explaining the polling use of 'sinceMs' in context, but does not elaborate on 'bookingId'. Schema coverage is 67%, so description partially compensates.

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 it reads a session transcript, with specifics about consent-gating and participant restriction. However, it does not explicitly differentiate from the sibling tool 'session_debrief', which may cause 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?

Explicitly advises use for supervision and suggests pairing with 'send_cue'. It implies usage during live sessions with polling using sinceMs. Lacks explicit 'when not to use' or alternative tools, but gives strong 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 fully discloses behavioral traits: the two-part presence system, the 15-minute activity heartbeat, that calling this tool counts as activity, and the ranking/booking implications. It is comprehensive and transparent.

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

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

The description is three sentences, each earning its place. It front-loads the key concept (two-part presence) and efficiently covers usage, behavior, and consequences with 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?

Given no output schema and no annotations, the description covers all necessary context: what the tool does, when to use it, behavioral details (15-minute heartbeat), and impact on availability and booking. It is complete and self-sufficient.

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

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

Schema coverage is 100%, providing baseline 3. The description adds meaning beyond the schema by connecting the 'open' boolean to the instant-session status and the activity heartbeat, and indirectly explaining the effect of sessionToken (proves user identity). This extra context justifies a 4.

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 sets the pro's instant-session status (open/closed) and distinguishes it from siblings by explaining it's one of two parts of presence. It uses specific verbs like 'set' and 'open/closed' and references related tools like 'book_now'.

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

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

The description provides explicit guidance on when to use: 'open it when the pro is genuinely at their desk' and to re-call within 15 minutes to stay live. It also explains the benefit (higher ranking for urgent needs, bookable via book_now). While it doesn't explicitly state when not to use, the context is clear.

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

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

With no annotations provided, the description carries full burden. It mentions the panel displays one person at a time and the agent should render choices, but it does not disclose server-side behavior, error handling, or side effects. The description hints at UI behavior but lacks clarity on what the tool actually returns or modifies.

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

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

The description is moderately concise but includes procedural instructions (e.g., 'After silently reading...', 'Then render...') that mix tool behavior with agent actions. It could be tighter while preserving 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?

The tool has no output schema and a nested input parameter. The description does not explain what the tool returns (e.g., whether it returns data for display or directly renders UI). It also lacks detail on error scenarios or constraints, leaving gaps for an agent to reason about.

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 minimal parameter meaning. It mentions 'selected profile IDs' and 'formal filters' but does not explain the individual filter fields (availableNow, freeFirstSession, etc.) beyond what the schema provides. The agent would benefit from more detailed parameter intent.

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 'show' and the resource 'people', and explicitly distinguishes itself as 'THE ONLY user-visible shortlist', differentiating it from siblings like list_people and match_me. It specifies the tool is for presenting selected profiles one at a time, making the purpose unambiguous.

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

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

The description provides explicit usage guidance: 'After silently reading list_people or match_me, pass 1-3 selected profile IDs plus the formal filters you actually applied.' It also instructs on what to render afterward, leaving no ambiguity about when and how to use the 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?

The description correctly states that the tool updates profile fields, which is the core behavior. However, with no annotations, it lacks details on side effects (e.g., does it return the updated profile?), authentication requirements (only hinted via sessionToken in schema), or whether it performs partial or full updates. For a simple write tool, the disclosure is adequate but 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, efficient sentence that lists the key fields without any filler or redundant phrases. It is perfectly sized for its purpose, earning its place with every word.

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 profile update tool with 7 parameters (1 required), no output schema, and no annotations, the description lacks important context: it does not clarify whether updates are partial or full, what happens to unspecified fields, whether validation exists beyond schema constraints, or what the response looks like. The description is insufficient for a tool that modifies user data.

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 low (29%), but the description enumerates the meaningful parameters: displayName, headline, story, rate (hourlyRateDollars), and listing/visibility flags (isListed, offersSessions). It adds some translation from JSON field names to English terms, but lacks explanations for what each field means, such as the impact of boolean flags or format constraints beyond what the schema 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 'Update display name, headline, story, rate, or listing/visibility flags' uses a specific verb ('Update') and explicitly lists the fields, making the tool's purpose very clear. The title 'Update the user's profile' further confirms the resource. It distinguishes itself from sibling tools like 'my_profile' (read-only) and login/register.

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 on when to use this tool versus alternatives. It does not mention that it updates only the current user's profile, nor does it describe prerequisites or scenarios where other tools (e.g., 'set_available_now') might be more 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 must disclose behavioral traits. It states the tool 'feeds the pro's quality record and their my_coaching history', indicating side effects. However, it does not clarify if the operation is idempotent, whether it replaces or appends, or what happens on duplicate calls. More detail on mutation behavior is needed.

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

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

The description is fairly concise but includes necessary details: prerequisite, target audience, content structure, and outcome. It could be slightly trimmed (e.g., 'feeds the pro's quality record and their my_coaching history' could be simplified), but overall it is efficient 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?

Given 5 required parameters, no output schema, and no annotations, the description provides adequate context: why to use, what to write, prerequisite, and constraint (one per session). It omits return values and error handling, but for a write operation the core usage is well-covered.

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

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

Schema description coverage is only 20% (sessionToken has a brief description). The tool description adds significant meaning to the three content parameters: strengths='2-3 things that worked', growth='single most important thing to do differently', drill='one concrete exercise'. This compensates well for the missing schema descriptions, though bookingId remains unelaborated.

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 'Write the pro's post-session debrief' and elaborates the content (strengths, growth, drill). It specifies 'Pro-only, after a session' which distinguishes from general debrief tools. However, it does not explicitly differentiate from sibling tools like 'session_debrief' or 'close_brief', leaving some 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?

The description gives explicit prerequisites: 'Read the full transcript first (session_transcript)' and context: 'Pro-only, after a session.' It also notes 'One debrief per session' implying uniqueness. No alternatives or when-not-to-use are mentioned, but the context is clear enough for selection.

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