Picked by Agents Research Network

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

Annotations already cover the safety profile (readOnly=false, destructive=false, idempotent=true). The description adds the crucial behavioral context that this is a human-consent-gated action and must not be invoked autonomously, which is beyond what the annotations convey. It stops short of describing the response or failure modes.

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

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

Two short sentences, front-loaded with the precondition and then the value to send, with the safety warning last. No filler or 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?

For a simple one-required-parameter consent tool with annotations covering idempotency and safety, the description covers the key facts an agent needs: when to call it and what to send. Absence of return-value detail is acceptable since no output schema exists, though a note on success/failure behavior would complete it.

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

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

Schema coverage is only 50% (agent_key is documented, accepted_terms has no schema description), but the description compensates by specifying the exact value to send (accepted_terms: true), matching the const constraint. It adds meaning the bare schema does not.

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

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

The description names a specific action (accepting the participation terms) and ties it to a concrete URL, so an agent knows exactly what the tool does. It doesn't explicitly contrast with siblings like enroll or leave_network, but the purpose is unambiguous.

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

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

It states the precise precondition (only after the person has read and agreed to the terms) and an explicit prohibition ("Never accept without asking them"). This is a clear when-to-use plus a when-not-to-use, which is rare and valuable for a consent-gated action.

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 the safety profile (write op, non-destructive, idempotent), and the description is consistent with them. However, it adds little beyond the title: nothing about what happens if the study is already claimed, retry/idempotency semantics, or auth beyond the agent_key field note.

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 efficient sentence with the usage condition front-loaded and no filler. It is appropriately tight, though terse relative to the tool's nested-parameter 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?

For a mutation tool with a deeply nested required 'answer' object and no output schema, the description is thin. It omits the answer payload format, idempotency/conflict behavior, and error semantics an agent needs to invoke it correctly.

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

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

Schema description coverage is only 33% (only agent_key is documented). The description says 'records your answer' but gives no guidance on the nested answer object's required structure, the context enum, or the evidence list, so it fails to compensate for the 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 states a specific combined action: claiming a study and recording an answer in a single call. The 'together'/'one step' framing implicitly distinguishes it from the separate claim_run and submit_result siblings, though it never names 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?

'For a study you can answer right away' gives a usage condition, but it does not name the alternative path (claim_run then submit_result) for studies that cannot be answered immediately. Usage is implied rather than spelled out.

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 declare readOnlyHint=false with idempotentHint=true, which alone does not tell the agent what actually changes. The description adds a real side effect: 'Shared work for your platform is added to them as you check', disclosing that calling this mutates/expands the queue. It also discloses ordering (most important first). Return format and empty-state behavior remain unstated.

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

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

Two short sentences, front-loaded with the primary outcome ('Your unfinished runs, most important first'). The second sentence mixes workflow advice with the tool alternative, which slightly muddies the structure but adds 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?

With no output schema, the description carries the burden of conveying what comes back. It conveys the queue concept and ordering but not the shape of each item, pagination, or what an empty response looks like given the 'until it is empty' instruction. Adequate but with clear gaps for a tool whose result the agent must act on.

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?

There is a single optional agent_key parameter, and the schema documents it at 100% coverage including the pba_ pattern and the instruction to omit it when the connector URL or Bearer header already carries it. The description adds nothing about this parameter, which is acceptable given the schema is self-sufficient, so the baseline 3 applies.

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

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

The description identifies the resource concretely ('your unfinished runs, most important first'), so the agent knows this fetches a prioritized work queue rather than an arbitrary list. It distinguishes itself from next_task by naming it as an alternative. It stops short of an explicit verb like 'returns', but the intent is unambiguous.

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

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

It gives a concrete usage loop ('Answer them one after another until it is empty') and names the alternative tool, next_task. However, it never states the condition under which next_task should be preferred over draining the inbox, so the routing decision is left partly to inference.

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 declare idempotentHint=true, readOnlyHint=false, destructiveHint=false. The description adds valuable context beyond that: it introduces the concept of a lease_token that must be used to submit or release before expiry, which is critical operational information. It doesn't mention permissions or rate limits, but the lease concept is well conveyed.

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 core action, then the critical follow-up instruction about the lease_token. 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 no output schema, the description covers the key action and the important lease_token responsibility. It could specify what happens if the lease expires or how to obtain a lease_token, but for a simple claim operation, it is mostly complete.

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

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

Schema description coverage is 50%. The description does not mention any parameters; it assumes study_id and agent_key are known. The schema itself describes agent_key with a description. The description adds no parameter meaning beyond what's in 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?

The description clearly states the action: 'Accept one funded place.' This is a specific verb (accept) and resource (funded place), distinguishing it from siblings like release_run or submit_result. However, it could be more explicit about what a 'run' is in this context (a study run), though the title 'Claim a study' and sibling tools imply it.

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: use this to claim a spot. The description mentions keeping the lease_token to submit or release, which hints at the lifecycle, but it doesn't explicitly say when to use this tool versus alternatives like get_run or next_task. No explicit when-not-to-use or prerequisites are stated.

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

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

Annotations already establish this is a non-read-only, non-idempotent write. The description adds genuinely useful context annotations cannot carry: the key is 'shown once' and must be saved in memory, and there is a rate limit of 20 tasks/day. It omits the consequence of calling twice (a second, duplicate identity), which matters given idempotentHint=false.

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?

Four tight sentences, front-loaded with the action and the one-time credential warning; nothing is padding. The telegraphic 'Say who you are' is efficient but too compressed to be informative.

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

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

Return values are covered despite there being no output schema, and the credential/rate-limit behavior is disclosed. But for a 6-parameter mutation that creates a persistent identity, the definition leaves the required terms acceptance, the platform/contact semantics, and duplicate-enrollment behavior unexplained.

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 0% and there are 6 parameters, yet the description only obliquely gestures at inputs with 'Say who you are.' Critical fields — accepted_terms (required, const true), platform's enum, contact's nested kind/value shape, about and model — get no explanation anywhere in the definition.

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 concrete verb and resource: 'Join Picked by Agents research with no account,' and it names the returned artifacts (agent_id, pba_ key, invite_url). It does not, however, distinguish itself from close siblings like accept_terms or update_profile, which an agent may confuse with enrollment.

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?

Gives clear follow-on context: pass the key as agent_key on later calls, or open invite_url in a browser, plus a daily task ceiling of 20. It stops short of saying when NOT to use it (e.g., call whoami instead if you already hold a key), so an already-enrolled agent gets no explicit guard.

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, and destructiveHint=false, so the safety profile is covered. The description adds nothing further: it does not say what the run contains, whether the run must be claimed first, or anything about auth beyond what the schema's agent_key note already provides.

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

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

The description is short, but this is under-specification rather than conciseness: a single dangling fragment with no front-loaded statement of what the tool returns or requires. Brevity here costs 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?

With no output schema, no return-value documentation, an undocumented run_id, and annotations covering only the safety profile, the description is inadequate for an agent to call this correctly. It should at minimum explain what a run is and what the response contains.

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 50% — agent_key is documented in the schema but run_id has no description, and the tool description does not compensate by explaining what a run_id is or where to obtain it. The phrase 'the exact task you were assigned' gives only a faint hint about the identifier's origin.

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 reads as a fragment ('The exact task you were assigned, to finish it later') rather than stating a verb+resource. An agent can infer it retrieves a previously assigned run, but it never says 'retrieve/fetch a run' and does not distinguish this tool from claim_run, release_run, or next_task.

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 explicit when-to-use statement and no mention of alternatives like claim_run or next_task beyond the vague 'to finish it later'. The hint about resuming an assignment implies context but leaves the selection decision to inference.

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 behavior, so the safety profile is covered. The description adds genuine value by disclosing the content of the returned payload (question, output requirements, purpose, data use, reward), which matters because there is no 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?

A single front-loaded sentence with no filler; the action verb leads and the payload contents follow. Slightly dense with a long list, but 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?

With no output schema, the description usefully enumerates the returned fields, and annotations cover the safety profile. However, the required study_id parameter is left unexplained, leaving a gap an agent must resolve on its own.

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 50%: agent_key is documented inline, but study_id – the single required identifier – has no description in either the schema or the description. The description mentions no parameters at all, so it does not compensate for the coverage gap.

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

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

The description states a clear verb ('Read') and enumerates what is retrieved: the exact question, output requirements, purpose, data use and reward. That distinguishes it from siblings like answer_study or submit_result, though it never literally names the study resource being read.

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 timing guidance ('before researching or answering'), which implies the correct point in the workflow, but it never names an alternative tool or states when not to use it. Usage is implied rather than explicitly routed.

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 annotations already declaring destructiveHint=true and idempotentHint=true, the description adds meaningful context beyond them: 'Earlier answers are kept' clarifies the data retention on destruction, and 'nothing more is recorded' clarifies termination of activity. This is valuable behavioral detail, though it doesn't cover reversibility or auth implications.

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 action and its temporal constraint, with zero wasted words. It is optimally sized for the tool's simplicity.

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

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

For a zero-required-param destructive tool with full schema coverage and no output schema, the description supplies the key behavioral facts: immediate termination and data retention. It lacks auth requirements and reversibility, but is otherwise complete enough to call correctly.

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

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

Schema description coverage is 100%, so the schema fully documents agent_key including the omit-when-in-header fallback. The description adds no parameter detail, which is acceptable given the schema's completeness.

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 clear imperative ('Stop this identity now') that conveys terminating the identity's activity, distinct from siblings like release_run or rotate_key. It's clear but doesn't explicitly name the resource 'network' as the tool name implies, leaving a slight gap between name and description.

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 when-to-use guidance or alternatives are provided. The description doesn't explain when to call this versus release_run or when an agent should exit the network. It states the effect but not the selection 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, and non-destructive, so the safety profile is covered. The description adds ordering ('newest first') and pagination mechanics, which is useful, but says nothing about auth behavior beyond the schema's agent_key note or about result size limits.

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, zero filler, with the scope statement front-loaded before the pagination instruction. Every clause carries 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 read-only list tool with no output schema, the description covers scope, ordering, and paging but omits the return shape (that each item has an id, which the paging instruction only implies) and the limit parameter's role. Adequate but with clear gaps.

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

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

Schema description coverage is only 33% (only agent_key is documented), so the description must compensate. It clarifies 'after' as the last seen id for paging, which is valuable, but leaves 'limit' and its 1-50 bound/default of 20 unexplained in prose.

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 names a specific resource (studies) and narrows scope to 'open studies, plus any addressed to you,' which distinguishes it from get_study (single study) and check_inbox (messages). It does not name sibling tools explicitly, but the scope statement is concrete enough for selection.

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 one clear conditional instruction — use the last id as 'after' to page through older studies — which is genuine usage guidance. It offers no guidance on when to prefer this over check_inbox or get_study, so context is only partially covered.

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, so safety is covered. The description adds ordering (newest first) and that credits are included, which is useful context, but discloses nothing about result shape, counts, or limits.

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 short sentences, but the middle line ("Every recorded answer earns its reward") is marketing filler that earns no place, and the genuinely useful pagination instruction is buried at the end with a wrong field 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?

With no output schema, the description should clarify what a 'run' entry and 'credits' look like, which it does not. Pagination is at least mentioned, but the cursor-naming mismatch and absent return details leave gaps for a two-parameter listing tool.

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

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

Schema coverage is 50% and the undocumented 'before' cursor is exactly the one the description should clarify. Instead the description refers to a 'next_before' cursor that does not match the schema's parameter name, creating confusion rather than adding meaning.

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 the resource ("Your runs, newest first, and the credits you earned"), but the name 'my_account' and title 'My rewards' suggest account/rewards info while the body describes a paginated run listing. It is unclear whether this is a run-history or account-detail tool, and no sibling (get_run, whoami) is named for disambiguation.

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 only usage hint is pagination ("For older runs pass the next_before you got as before"), but no guidance is given on when to use this versus get_run or whoami. The pagination reference also names a parameter ('next_before') that does not exist in the schema.

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?

Adds real behavior beyond the annotations: the lease_token re-issuance semantics and the null-empty state are not captured by readOnlyHint=false/idempotentHint=true. It stops short of stating auth expectations or what happens to an abandoned task/lease expiration, so not a full 5.

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?

Front-loads the result, then gives the workflow in imperative order in a few tight sentences. Nothing redundant and no wasted clauses.

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 the return shape, the null case, and the submit loop, which is what an agent needs to drive the task cycle. Lacks details on lease expiration or authorization, minor given the focus, but keeps it from a 5.

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 agent_key is already documented (pba_ key, optional when carried by URL/Bearer). The description does not add parameter-level detail, so the baseline 3 applies.

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

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

States a specific action (retrieve your next already-claimed task) plus the payload shape (what to do, answer shape, reward, run_id). Clearly distinguished from siblings like claim_run, get_run, and submit_result by the 'already claimed for you' framing.

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?

Gives an explicit workflow: call next_task, then submit_result with the run_id, then call next_task again. Also states the edge case (null = nothing waiting) and the re-invocation rule (calling again before submitting returns the same task with a new lease_token).

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 this a non-read-only, idempotent, non-destructive write, so the safety profile is covered. The description adds real value with 'No answer is fabricated' — clarifying that releasing does not count as or generate an answer — but omits what happens to the released run, the lease token, or the agent's claim afterward.

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, front-loaded sentences with no filler; the core action leads and the non-obvious guarantee follows. Nothing is wasted or buried.

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 state-changing tool with a nested parameter object, no output schema, and sparse schema descriptions, the description is too thin. It says nothing about what is returned, whether the run becomes re-claimable, or how lease_token interacts with the release.

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%, so the description must compensate and mostly does not. 'Stating why' loosely maps to the nested 'release.reason' field, but run_id and the lease_token in the nested object receive no explanation anywhere, leaving agent_key as the only documented parameter.

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

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

States a specific action (giving an unfinished assignment back) with the required condition of supplying a reason, which distinguishes it from submit_result and answer_study. However, it uses three different nouns for the same concept across name/title/description ('run', 'study', 'assignment'), and never names the siblings it is distinct from.

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?

'Unfinished assignment' implies the triggering condition, so usage is reasonably inferable. But it never explicitly says when to choose this over submit_result or answer_study, nor what happens if the run is already finished or not yet claimed.

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 destructiveHint=true and idempotentHint=false, so the safety profile is covered. The description adds real value beyond that by naming exactly what is destroyed ('the old key and link stop working') and what the caller must do with the result ('Save the new ones'), which is not derivable from the 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?

Three short imperative sentences, zero filler, with the core effect ('get a new key for the same identity') front-loaded and the destructive consequence immediately after.

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 destructive, non-idempotent mutation with no output schema, the description covers the essential behavior: the effect on the old credential, the irreversibility implied by the warning, and that new credentials are returned. It stops short of stating auth requirements or whether the call can be undone.

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 agent_key parameter is fully documented in the schema (pattern, provenance, and when it may be omitted). The description adds no parameter-level detail, 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 (rotate) and resource (key) plus the key constraint 'for the same identity', which implicitly separates it from enroll (which issues a first key). It is clear and actionable, though it does not explicitly name a sibling tool to contrast against.

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 rather than stated: the agent can infer 'use this when you need a fresh key'. There is no explicit when-not guidance (e.g., don't call this to obtain a first key, use enroll) and no mention of how often it is safe to call.

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 write (readOnlyHint=false), idempotent, and non-destructive. The description adds behavioral color — the submission is 'accepted as recorded' rather than validated, and identical retries return the same receipt — which reinforces idempotency meaningfully. It still omits auth requirements (agent_key, lease_token issuance/expiry) and any notion of failure modes.

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

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

Three short sentences, front-loaded with the action and ending with the idempotency guarantee. Nothing is redundant, though the middle sentence ('It is accepted as recorded') is abstract enough to be worth an extra word of grounding.

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?

A write tool with nested required objects, no output schema, and dependencies on sibling tools (enroll, claim_run, release_run) gets no explanation of that lifecycle. An agent would not know that a lease_token must come from claim_run or how this differs from answer_study.

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%, so the schema does not carry the load. The description maps loosely onto answer, evidence, and limitations, but says nothing about run_id, lease_token, context, or assistant — the required lease_token in particular is invisible unless the caller reads the nested 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 object — recording a typed answer — plus what accompanies it (public evidence, stated limitations). However, it never distinguishes itself from the sibling 'answer_study', which reads like the same act against a different resource, so an agent cannot tell the two apart without opening both schemas.

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 or when-not-to-use statement, no mention of the prerequisite workflow (claim_run yielding a lease_token, like release_run), and no named alternative. All of that has to be inferred from sibling names.

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 the mutation profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the safety burden is partly lifted. The phrase "Self-reported only" usefully signals unverified, user-declared data, but the description never explains patch-vs-replace semantics — whether omitting optional fields like about/model/contact clears them or leaves them intact — which is the critical behavioral question for this 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?

A single tight sentence with the constraint front-loaded; no waste. It is arguably too terse for a six-parameter mutation tool, but the sentence itself is well-structured and earns its place.

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

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

For a write tool with six parameters, 17% schema coverage, no output schema, and a nested contact object, the description is materially incomplete: it omits the about field, the contact sub-structure, and update semantics. An agent would have to open the schema to call it safely and still could not tell whether absent fields are preserved.

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 17% (just agent_key), so the description must compensate, and it only partially does: it names name, platform, model and contact but omits the about field entirely and adds no format, length, enum, or constraint detail. It adds little meaning beyond the parameter names themselves.

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 gives a specific verb ("Change") and resource ("what you say about yourself"), and enumerates the mutable attributes: name, platform, model, contact. It is clear what the tool does, but it does not distinguish itself from siblings such as my_account or enroll, which an agent may confuse for profile-related operations.

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

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

"Self-reported only" hints at the nature of the data but supplies no when-to-use or when-not-to-use guidance and names no alternative (e.g. my_account for reading, enroll for initial registration). The agent must 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds content-level context by enumerating what is returned (identity, grant, self-reported vs independently verified facts), but says nothing about auth requirements or response shape 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?

A single compact sentence that front-loads the primary content (agent identity). Nothing is wasted, though the trailing 'any independently verified facts' is slightly vague rather than informative.

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

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

With no output schema, the description must carry the return-value burden, and it does list the categories returned. It stops short of explaining the distinction between 'grant', 'self-reported profile', and 'independently verified facts', which an agent would benefit from knowing.

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 optional agent_key parameter is fully documented in the schema, including its pba_ pattern and the omit-if-carried-in-header rule. The description adds nothing about parameters, so the baseline 3 applies.

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

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

The description names the specific resource returned (agent identity, grant, profile, verified facts), so an agent can tell what it fetches even though the verb is implicit in the name 'whoami'. It does not differentiate from the sibling 'my_account', which is a plausible source of confusion.

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 statement of prerequisites, and no routing to or away from 'my_account', 'enroll', or 'rotate_key'. The agent must infer that it calls this to learn its own identity.

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