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

With no annotations, the description carries the disclosure burden. It reveals that the tool creates a persistent agent identity, returns an id, affects the review UI, and enables downstream attribution and approval rules. It does not mention idempotency, duplicate names, or permission requirements, but it covers the main behavioral consequences of the call.

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 focused sentences with no filler. The first sentence front-loads the core purpose and the return-value usage, while the second efficiently covers parameter semantics. It is slightly dense but 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?

Given no output schema, the description supplies the essential return-value behavior (returned id for log_session) and parameter meaning. It is complete enough for a simple 3-parameter create tool, though it does not discuss error cases, uniqueness, or authorization, which are not critical for basic 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 0%, so the description fully compensates. It explains that `name` is how the agent appears in the review UI and that `description` and `system_prompt` are optional reviewer context. All three parameters receive meaningful semantics beyond the raw 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 and resource: 'Register an agent identity with the team,' and explains the downstream purposes (logged session attribution and admin auto-approve targeting). It is clearly distinguished from sibling list/retrieve tools by its create/register action, though it does not explicitly name or contrast those siblings.

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

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

It gives clear context for when to call the tool: 'so logged sessions can be attributed to it' and 'so an admin can target it with an auto-approve rule.' It even instructs passing the returned id to log_session. However, it does not state explicit when-not-to-use conditions or name 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 full behavioral disclosure burden. It does reveal that the tool returns an id (implied by 'pass the returned id') and that name appears in the review UI, but it does not explicitly state that a persistent record is created, nor mention permission requirements, idempotency, or failure behavior.

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

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

The description is three sentences with no filler. It front-loads the core purpose and integration with log_session, then efficiently covers parameter semantics. Each sentence contributes distinct 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 two-parameter create tool with no output schema and no annotations, the description is nearly complete: it explains the return id, the intended workflow, and parameter meanings. It omits error conditions and duplicate behavior, but those are minor for such a simple 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?

With 0% schema description coverage, the description compensates well by clarifying that name is the label shown in the review UI and description is optional context. It adds meaning beyond the bare schema, though it does not specify format or length 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 opens with a specific verb and resource ('Register a task with the team') and immediately explains the tool's raison d'être: scoping logged sessions to a task via the returned id. This clearly distinguishes it from sibling tools like list_tasks and log_session.

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 an explicit condition for use ('useful when several sessions across one piece of work should be filterable together later') and names the integration point with log_session by passing the returned task_id. It does not explicitly state when not to use it, but the context is strong and unambiguous.

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

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

Annotations are absent, so the description carries the burden. It implies a read-only operation by saying 'List' and mentions the purpose of finding an existing id, but it does not disclose details such as response format, ordering, or pagination. Given it's a simple list, this is adequate but not rich.

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 filler, and the core action is stated first. The example adds value without unnecessary length.

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

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

For a no-parameter list tool with no output schema, the description explains the purpose and a concrete use case. It lacks explicit return format details, but the phrase 'find an existing agent's id' implies the response contains ids, which is likely sufficient for an agent to use 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?

The tool has zero parameters, so the baseline is 4. The description doesn't need to elaborate on parameters, and it adds no parameter-specific details, but none are 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 verb 'List' and the resource 'agent identities already registered with this team', and it explicitly distinguishes from create_agent by mentioning the use case of avoiding duplicates. This is specific and not a tautology.

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

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

It explicitly mentions the alternative create_agent and the condition for using this tool (to find an existing id instead of duplicating). This provides clear guidance on when to use it versus a sibling.

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

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

No annotations are present, so the description carries the burden. It conveys a read-only nature through the verb 'List' and scopes the operation to the current team. However, it does not mention output format, pagination, or any limitations—minor for a simple listing but still a gap without annotations.

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

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

A single sentence that front-loads the core action, then adds a practical example and sibling contrast. Every word earns its place; no filler or repetition.

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

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

For a zero-parameter, no-output-schema listing tool, the description covers the purpose, scope, and an important usage pattern. It could explicitly describe the return values, but the example ('find an existing task's id') implies the relevant output is included.

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 the description need not explain any parameter details. Per the rubric, a zero-parameter tool receives a baseline of 4, and the description does not hurt this.

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 the tasks already registered with this team') and explicitly distinguishes itself from create_task, which is a sibling. It leaves no ambiguity about what the tool does.

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

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

It provides an explicit use case ('to find an existing task's id') and names the alternative (create_task) with the reason to prefer this tool ('instead of creating a duplicate'). This is a clear when/when-not guide.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It explicitly mentions that nodes start PENDING and are invisible to retrieve_context until admin approval, which is a deliberate review gate. It also explains how agent_id/task_id can trigger auto-approval. It doesn't mention error handling or idempotency, but the critical behavior is 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 longer than necessary but every sentence provides value. It front-loads the purpose, then explains the approval mechanism, then parameter roles. The structure is logical and the length is justified given the tool's complexity.

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

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

The description is quite complete for a log tool with 6 parameters and an approval flow. It covers the PENDING state, auto-approve rules, and parameter purposes. It doesn't describe the return value, but for a logging action without an output schema, that is acceptable. Minor gaps like error scenarios or idempotency exist but are not critical.

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 explain each parameter. It does so thoroughly: title as a searchable anchor, body as content, tags/links as retrieval aids, and agent_id/task_id for auto-approval and scoping. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: 'Log what happened this session as a memory node for the team to reuse.' It specifies the verb (log), the resource (session memory node), and the intent (reuse). It also distinguishes from siblings by implying that retrieve_context is for retrieval, not storage.

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 when-to-use guidance: 'Call this once at the end of a session that learned something worth keeping.' It also explains the approval gate and references related tools like retrieve_context and create_auto_approve_rule. However, it doesn't explicitly state 'use retrieve_context for retrieval' but the contrast is clear enough.

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 carries the behavioral burden. It explains the traversal-bounding behavior of hops and hub_cutoff, the limitation to reviewed/approved memory, and the exact return shape including approximate token cost. This gives an agent a clear model of what the tool does and what it returns.

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 efficiently front-loaded with the tool's purpose and timing, then progressively explains parameters and output. Every sentence contributes either operational guidance or parameter semantics, with no filler or redundant restatement of the tool name.

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

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

Given no output schema, the description adequately covers what the tool returns ('neighborhood' list and 'approx_tokens'), what inputs matter, and when to invoke it. For a moderate-complexity retrieval tool with three parameters, this is sufficient for an agent to call it correctly without additional context.

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

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

Schema description coverage is 0%, so the description must define all parameters, and it does. It gives anchor a semantic definition with a concrete example, explains hops as traversal spread with its default, and clarifies hub_cutoff's role in preventing hub nodes from pulling in the whole graph. This adds substantial meaning beyond the bare schema.

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

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

The description states a specific verb and resource: 'Retrieve a bounded neighborhood of this team's reviewed, approved memory around a topic.' It clearly distinguishes the tool from sibling tools, none of which perform memory retrieval, and gives a concrete example of the anchor topic.

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 when to call it: 'Call this once at the start of a session, before starting work,' and explains the purpose ('so you inherit what teammates already learned instead of rediscovering it'). It also implies frequency by saying 'once,' which is direct usage guidance.

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