Burs-IA

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is largely covered. The description adds the privacy framing ('privacy-minimal', 'without contacting any external agent'), though the non-contact claim partly restates openWorldHint=false. No disclosure of rate limits, validation behavior, or what is produced.

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

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

A single front-loaded sentence with no filler; the scope constraint and the non-contact guarantee are both stated in one pass. Nothing needs trimming.

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

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

With an output schema present, return values need not be described, and the description adequately frames the tool as a preparation step for a privacy-minimal request. The only minor gap is not indicating how the prepared request is subsequently used or handed off.

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

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

Schema description coverage is 100%, so both parameters (request, protocols) are already documented in the schema, and the description adds no additional syntax or format meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (Prepare) and resource (agent-to-agent collaboration request) with a clear scope qualifier ('privacy-minimal'). It distinguishes itself implicitly from send-oriented siblings by saying no external agent is contacted, but does not name any sibling tool to sharpen the contrast.

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

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

The phrase 'without contacting any external agent automatically' implies this is a drafting/preparation step rather than a dispatch step, which is a usable usage cue. However, it gives no explicit when-to-use guidance and does not differentiate from siblings like prepare_outbound_invitation or human_bridge_request.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false. The description adds 'No external action is performed,' which reinforces but doesn't extend beyond what annotations convey. No rate limits, freshness, or caching behavior disclosed.

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

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

Two short sentences, front-loaded with the primary verb+resource, followed by the no-side-effects reassurance. Efficient, though the second sentence is somewhat redundant given annotations.

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?

Output schema exists so return values needn't be explained. But with 8 siblings in an adjacent capability/oversight space, the description doesn't help an agent decide this tool over human_oversight_policy or discover_capabilities.

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?

Zero parameters, so baseline 4. Nothing to document, and description correctly does not invent parameter info.

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

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

States a specific verb+resource: returns public Burs-IA operational status, discovery surfaces, and oversight policy. It's clear what the tool yields. However it doesn't distinguish itself from siblings like human_oversight_policy or discover_capabilities, which cover overlapping concepts.

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 siblings. Given siblings like human_oversight_policy and discover_capabilities cover similar surface, the absence of any 'use this when...' routing is a real gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuinely new behavioral context: the probe is bounded, no target tools are executed, no credentials leave, and the output is an evidence-hashed report rather than a certification.

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

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

One long but front-loaded sentence: the action and input come first, then the report contents, then the caveats. No filler, though the mid-sentence list of report fields is dense.

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?

An output schema exists, so return values need not be enumerated, yet the description helpfully previews the report dimensions and explicitly bounds scope (no execution, no credentials, not a certification). Only the lack of guidance versus sibling verification/discovery tools is a 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?

Schema description coverage is 100%, so the endpoint restrictions, idempotency replay semantics and protocol enum are already documented. The description adds nothing about individual parameters, so the baseline of 3 applies.

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

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

States a specific verb (verify) and resource (a public HTTPS MCP endpoint) plus the shape of the result. It is clearly distinguishable from siblings like bursia_status or discover_capabilities.

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 scopes the tool by stating two negative conditions (no target tool executed, no credentials sent) and 'not a security certification', which implicitly tells the agent when this is appropriate. However, it names no alternative sibling and gives no explicit when-to-use trigger.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so safety is covered. The description adds meaningful context: 'public-safe opportunity metadata only' and that it does not spend money or contact anyone. It stops short of return format or rate-limit details, but those are less critical given the output 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, front-loaded with the core purpose and then the key behavioral constraints. Every phrase earns its place 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?

With an output schema present and all parameters fully documented, the description covers purpose, usage context, and behavioral boundaries adequately. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, and all three parameters have clear descriptions. The description adds no parameter-specific syntax, defaults, or formatting beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'list paid opportunities already registered by WORKNET.' It also clarifies what it does not do, distinguishing it from write/apply siblings like prepare_mission. An agent knows exactly what this tool returns without opening the schema.

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 says 'Use this in ChatGPT to list paid opportunities,' giving clear usage context, and explicitly excludes actions like applying or claiming work. However, it does not name the specific alternative tools for those excluded actions, leaving some inference to the agent.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the bar is lower. The description nonetheless adds real value by enumerating the exact side-effect boundary (no write, claim, application, acceptance, payment or contact) and flagging that binding action is gated by human approval and BURSIA TRUST.

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 with the action, followed by the binding-constraint caveat. No filler sentences; the enumerated list of non-actions earns its space.

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?

An output schema exists, so return values need not be explained. The description covers purpose, side-effect boundary, and the approval gate; only explicit alternative-tool routing is absent, which is a minor gap for this complexity level.

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

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

Schema description coverage is 100% and the single id parameter is fully documented with pattern and description, so the baseline of 3 applies. The description's phrase 'one paid WORKNET item' reinforces the parameter's intent but adds no syntax or format detail 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 a specific verb+resource: 'Create a deterministic internal pre-contract mission preview for one paid WORKNET item.' The word 'preview' and 'pre-contract' cleanly separate it from siblings like bursia_worknet_task and bursia_worknet_paid_tasks, even without naming them.

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

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

Usage is implied (run this before committing to a paid WORKNET item to obtain a non-binding preview) but no explicit when/when-not or named alternative appears. The negative scope (no write/claim/payment) helps an agent infer boundaries but does not route to 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?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds meaningful context beyond them by labeling the output a 'public-safe canonical record', signaling the data is sanitized rather than internal detail.

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

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

A single tight sentence with no wasted words, and the retrieval purpose is front-loaded. It is efficient, though it packs the usage rationale into the same clause rather than separating concerns.

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

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

With an output schema present, return values need not be explained, and the single fully-documented parameter needs no extra description. The description supplies sufficient context for a read-only single-record lookup, though it could name the sibling it precedes.

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

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

Schema coverage is 100%; the id parameter has a pattern, length bounds, and example already documented in the schema. The description adds no additional syntax or format guidance, so the baseline of 3 is appropriate.

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

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

States a specific verb (Read) and resource (public-safe canonical record for one paid WORKNET opportunity), which is clear. It implies single-item retrieval versus the plural sibling bursia_worknet_paid_tasks, but never names that sibling, so differentiation is only implicit.

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

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

The phrase 'before deciding whether to prepare internal work' gives implied usage context, tying it loosely to the prepare_mission workflow. However, no alternatives are named and no explicit when-not guidance is provided, leaving the agent to infer when this beats the paid_tasks 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?

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior. The description adds meaningful context beyond them: the tool returns a 'next safe action' and explicitly does not execute the requested external action, which prevents an agent from mistaking it for an executor.

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

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

A single compact sentence that front-loads the core action and appends the critical non-execution caveat. No filler and nothing redundant.

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

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

With an output schema present, return values need not be spelled out, and the description covers what the tool does, what it returns conceptually, and what it does not do. The only gap is the absence of explicit routing guidance among the many sibling tools.

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

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

Schema coverage is 100% for the single 'request' parameter, including its public/non-sensitive constraint and length bounds. The description adds no field-level detail beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb (classify) and resource (bounded request into a Burs-IA capability lane) and adds the key scope boundary that it does not execute the external action. It distinguishes itself from execution-oriented siblings, though it does not explicitly name them.

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

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

The description implies when the tool applies (bounded public requests needing lane classification) and rules out execution, but it gives no explicit when-to-use vs. alternatives such as discover_capabilities or outbound_gateway_policy. Usage context is inferred, not stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that the listing is public and includes verification entry points, but says nothing about freshness, filtering behavior, or scope limits beyond that.

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

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

One sentence, front-loaded with the verb and resource, with no filler. It could be tighter by dropping the trailing clause about the verification tool, but it is efficiently sized.

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

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

An output schema exists and annotations cover safety, so the description need not explain return values. What remains is a light gap around when discovery is the right call versus a direct verify tool, but the core scope is 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?

With a single optional 'query' parameter and 100% schema description coverage, the schema already explains the filter. The description only restates that the query contextualizes discovery, adding no syntax or matching semantics 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?

States a specific verb and resource: list Burs-IA public capabilities and compatible entry points. It also names one included item (public MCP verification value tool), which partially orients it among siblings, though it does not clearly distinguish itself from bursia_verify_mcp.

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?

Usage is only implied by the word 'discover' and the mention of verification entry points; there is no explicit when-to-use statement or instruction to prefer this over bursia_verify_mcp or capability_triage when the agent already knows what it wants.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, but the description adds genuinely useful clarification: 'No human is contacted and no external write occurs automatically', pre-empting the natural but wrong assumption that a 'handoff' contacts someone immediately. It does not, however, say what the prepared artifact entails or whether a later step performs the handoff.

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

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

Two tight sentences with the purpose front-loaded and the most decision-relevant caveat (no automatic contact/write) placed immediately after. No filler.

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

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

An output schema exists, so return values need no explanation. The description covers the key non-obvious behavior (no automatic handoff) and the schema covers params fully; the only gap is routing guidance relative to sibling tools.

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

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

Schema description coverage is 100%, so both the 'request' and 'authorization' semantics are already documented in the schema, including that authorization does not itself grant authority. The description adds nothing about parameters, so the baseline of 3 applies.

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

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

States a specific verb+resource ('prepare a human-in-the-loop handoff request'), which is clear on its own. However, with siblings like prepare_outbound_invitation and agent_collaboration_request in the same namespace, it does not distinguish itself from those adjacent request-preparation tools.

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

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

There is no guidance on when to use this tool versus the sibling handoff/invitation/policy tools. The phrase 'human-in-the-loop handoff' implies a context, but the agent must infer the triggering conditions and any prerequisites (e.g. needing a bounded result first).

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false), so the description is not required to restate those traits. However, it adds no further behavioral context such as authentication needs, rate limits, or failure modes; it merely restates the resource.

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

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

It is a single front-loaded sentence that states the return value with no filler or redundancy. Every word earns its place for a zero-parameter read tool.

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

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

Given the zero-parameter schema, the output schema, and the annotations that already communicate the safe-read behavior, the description is nearly complete for calling the tool. The remaining gap is that it does not help the agent choose between this policy and the sibling outbound_gateway_policy.

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?

With zero parameters, the schema has no fields for the description to clarify, and the baseline for a parameterless tool is 4. The description appropriately does not invent parameter details.

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

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

The description states a specific verb ('Return') and a specific resource (the Burs-IA bounded-autonomy and human-supervision policy), so the agent knows exactly what content is produced. It does not, however, distinguish this policy read from the sibling outbound_gateway_policy, which is also a policy-return 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?

There is no when-to-use guidance, no mention of alternatives, and no conditions or prerequisites for calling the tool. The description only states what it returns, leaving the agent to infer the appropriate 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?

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds genuine policy substance beyond that: external sends are allowlisted, rate-limited, and require explicit human approval, which tells the agent what the policy governs.

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

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

Two short sentences, no filler, with the resource identified first and the governing constraints second. Every clause 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?

An output schema exists, so the return payload needn't be described, and with no parameters there is little else required. The description is sufficient for an agent to call it correctly, though it could note how the policy relates to the outbound-prepare sibling.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-parameter tool 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?

States a specific verb ('Return') and a specific resource ('Burs-IA outbound discovery policy'), so the agent knows exactly what is fetched. It does not, however, differentiate itself from the similarly named sibling 'human_oversight_policy' or explain how it relates to 'prepare_outbound_invitation'.

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

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

There is no statement of when to call this versus the sibling policy/invitation tools. The read-only nature is implied by 'Return', but the agent gets no routing guidance or preconditions.

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

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

Annotations establish the mutation/safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false), and the description adds the key behavioral fact that the output is 'local ephemeral' and never transmitted, so no external side effect occurs. It omits idempotency semantics, which the annotation only flags without explaining.

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 with the action and its scope, and no redundant text. Every clause 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?

With an output schema present, return values need no explanation, and all five parameters are schema-documented with annotations covering safety. The description is largely complete; the lifecycle of the 'ephemeral candidate' (expiry, reuse) is the only lightly covered aspect.

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

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

Schema description coverage is 100%, so the schema already documents target, agentId, message, permissionBasis and operatorOrganizationIdentifier. The description only restates target/permission concepts ('HTTPS machine endpoint or opt-in recipient') without adding syntax or format detail 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?

States a specific verb+resource ('Create... invitation candidate') and immediately scopes it as 'local ephemeral' versus an actual send. The negation 'It does not send the invitation' sharply distinguishes it from outbound/send siblings, though no sibling is named explicitly.

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

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

Implies valid usage via 'for a documented HTTPS machine endpoint or opt-in recipient', which maps to the permissionBasis enum, but gives no explicit when-to-use vs. alternatives (e.g., outbound_gateway_policy) or exclusions beyond the no-send caveat.

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