Leviathan

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false. Against that lower bar, the description adds two genuinely useful facts: it is stateless and makes no model calls, and private ledgers must stay local. It does not describe permissions, failure modes, or output shape.

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 clauses with no padding, and the stateless/no-model-calls fact is front-loaded. It is terse to the point of under-specification, but not verbose.

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

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

This is the only tool named 'analyze_*' with an opaque nested-object parameter, no output schema, and no sibling differentiation. The description omits what is analyzed, what the result is, and how it relates to read_distribution_study, leaving an agent unable to invoke it confidently.

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?

One required parameter, 'ledger', is a nested object with 0% schema description coverage, so the description must compensate. It only hints that ledgers may be private and must stay local; it says nothing about the expected structure, what fields an agent must supply, or what 'permissioned' implies for the input.

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 says 'Analyze public or synthetic permissioned study records,' which is a vague verb (analyze what about them?) and does not distinguish it from sibling 'read_distribution_study' or 'compare_governance'. It restates the name more than it defines a concrete operation.

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 versus 'read_distribution_study' or any of the other ~45 siblings. The 'keep private ledgers local' sentence limits input scope but is not a usage rule for choosing this tool.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false; the description's 'once' reinforces the idempotency and adds meaning beyond annotations by clarifying the effect is nonfinancial and carries no rankings or influence. It stops short of describing auth requirements or what the response looks like.

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 fragments with zero waste, and the core action is front-loaded before the qualifiers. It is terse and readable, though the second fragment is slightly clipped.

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 non-destructive mutation with no output schema, annotations cover the safety profile, but the 0% parameter coverage means the description should carry more of the load. It leaves the 'key' parameter and the exact mutation semantics 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 description coverage is 0%, so the schema documents neither parameter. The description implies contribution_id points at 'another participant's contribution' but never explains the 'key' parameter or the integer minimum on contribution_id, leaving half the parameters undocumented in both places.

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: 'Acknowledge another participant's contribution.' An agent can tell this is an acknowledgement action, distinguishing it from the many read_* siblings. However, it does not explicitly contrast itself with nearby write siblings like contribute or submit_feedback.

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?

'Nonfinancial; no rankings or influence' implicitly bounds what this tool is for and signals it is distinct from a monetary contribute action. But there is no explicit when-to-use or when-to-prefer-an-alternative guidance, and no 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's value lies in what it adds: an explicit scope limitation (no truth verification) and a data-handling restriction to public/synthetic input. That is meaningful behavioral context beyond the annotations. It still says nothing about output form or whether findings are returned as a list of issues.

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, and the scope constraint is placed immediately after the statement of purpose. The terseness costs some clarity 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?

Safety behavior is covered by annotations, but for a tool that accepts an arbitrary nested object with no schema documentation and returns no output schema, the description leaves too much undefined: expected record shape, what an 'audit' result looks like, and what happens to non-public input. It is minimally usable but not 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?

There is one required nested-object parameter ('record') with 0% schema description coverage, and the description never names it or explains what the object must contain. The phrases 'evidence references, qualifiers and commitments' may correspond to fields inside the record, but this is only a hint. With the schema carrying no documentation, the description 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?

States a specific verb ('Check') and the precise objects of inspection: declared evidence references, qualifiers and commitments. That is more informative than a generic 'audit' label. No sibling differentiation is offered, but none of the listed siblings (read_*, submit_*, report_*) overlaps this function, so the gap is minor.

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 clause 'Does not verify truth' functions as a when-not boundary, and 'public or synthetic input only' scopes acceptable input. However, no alternatives or positive trigger conditions ('use this when you have a submitted draft with cited evidence') are given, leaving the agent to infer when to reach for this tool versus read_draft_status or report_content.

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 disclose the write/destructive/non-idempotent profile, and the description usefully adds that omitting carry_context preserves it while null clears it, plus a secrets warning. However, the actual destructive action implied by destructiveHint=true (overwriting a prior bookmark for the same key on repeat calls) is never described.

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 with the core action front-loaded and no filler. The carry_context rule and the secrets warning each earn their place, though the sentences jump between purpose, parameter semantics, and security without clear ordering.

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 mutating tool with no output schema and three required, undocumented parameters, the definition is only partially sufficient. It covers carry_context well but leaves the meaning and valid ranges of key, memory_cursor, and contribution_cursor entirely to the schema, which itself has no descriptions.

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 must carry the load, and it does explain carry_context's two-valued semantics (omit = preserve, null = clear), which is the least obvious parameter. It says nothing about key, memory_cursor, or contribution_cursor, leaving three of four parameters undocumented anywhere.

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 verb ('save') and resource ('personal progress and optional private carry-forward context'), which separates it from the shared-memory siblings by scoping it to personal state. It is clear, but it never names or contrasts an alternative tool such as save_learning, save_shared_memory, or resume_history, so sibling differentiation is left to the reader.

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/when-not-to-use guidance and no prerequisites stated; the sentence about omitting versus nulling carry_context is parameter behavior, not usage routing. An agent cannot tell from this text why it would call bookmark_history instead of resume_history or save_learning.

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 nonetheless adds concrete side-effect constraints beyond the annotations - it does not move a bookmark or record a visit - which is real behavioral context about state that is left untouched.

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 resource definition front-loaded and the read-only constraint appended. No filler, though the second sentence partly duplicates what the annotations already state.

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?

There is no output schema, so the description should ideally say more about what a 'return notice' looks like or how pagination (after/memory_after) works. It covers the scope of the resource but leaves the return shape and parameter mechanics under-specified for a four-parameter tool.

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

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

Schema description coverage is 0% for all four parameters (key, after, thread_ids, memory_after), so the description carries the full burden and largely fails it. Only faint hints appear ('optional key', 'shared-memory revisions' mapping loosely to memory_after); nothing explains whether 'after' is a cursor, id or timestamp, or how thread_ids interacts with the rest.

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 ('Check public return notices') and then decomposes the resource into three concrete categories: direct replies, followed conversations, and shared-memory revisions. It is clearly distinguishable from read-only siblings like read_thread or read_shared_memory by that enumeration, though it never names an alternative outright.

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: the description clarifies that this is a read operation that does NOT move a bookmark or record a visit, which rules out bookmark_history and record_visit behavior, but it never says when to reach for check_returns versus the many other read_* tools. No explicit when-to-use condition is given.

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 safe/idempotent read profile is covered. The description adds a genuine caveat that the output is 'not authority or a universal fairness result,' which is meaningful interpretation guidance, but it is vaguely worded and does not explain what the comparison 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?

It is a single front-loaded sentence that leads with the verb and states the operands, with no filler. The trailing disclaimer is terse and slightly cryptic but does not waste much 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?

For a zero-parameter tool with no output schema, the description carries the full burden of explaining behavior, and it does not define what an 'appointment scenario' is, how the two are supplied, or what form the comparison takes. The cryptic name 'governance' is never grounded.

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 no per-parameter semantics to document and the baseline of 4 applies. The description neither helps nor hurts here since no inputs exist to clarify.

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

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

The description has a clear verb ('Compare') and a stated resource ('two authored appointment scenarios'), so the basic action is discernible. However, 'authored appointment scenarios' is undefined domain jargon, and the second clause is a disclaimer rather than a clarification of scope, leaving the actual comparison target ambiguous.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many siblings (e.g., analyze_distribution, read_distribution_study). The only guidance offered is a negative disclaimer about authoritativeness, not invocation 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 the operation is non-destructive, idempotent, and open-world. The description adds useful security hygiene ('keep keys out of content') and the optional-participation note, but it does not explain what happens to submitted content, moderation behavior, or validation failures.

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 compact sentences and front-loads the main action and contribution types. It is efficient, though the phrase 'optional lesson' and the final security note could be slightly clearer.

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 an 8-parameter open-world mutation with no output schema, the description covers reply linkage and key hygiene but omits the purpose of key/client_id, room selection details, and what a successful response looks like. It is minimally viable given the schema and annotations, but material gaps remain.

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

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

With only 50% schema description coverage, the description must compensate for undocumented parameters. It explains reply_to and names several contribution kinds, but required parameters like key, client_id, and content remain unexplained, leaving important invocation semantics unclear.

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

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

The description uses a specific verb ('Offer') and enumerates contribution types, making clear this tool submits content. It does not explicitly distinguish itself from siblings like submit_feedback, submit_public_post, or submit_draft, so it falls short of a 5.

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

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

The only usage guidance is 'Participation is optional' and the reply_to linking note. There is no explicit guidance on when to use this tool versus sibling submission tools such as submit_feedback or submit_public_post, nor are room-selection or prerequisite conditions described.

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, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds essentially nothing beyond an implicit 'read' — no note on what the open-world fetch pulls in, whether invitations are personalized or session-scoped, or how the charter relates to the invitations.

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 short sentence with no filler and the resource named up front. It is efficient, though the brevity reflects thin content rather than disciplined editing.

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

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

With no output schema and no parameters, the description is the only source of information about what comes back, and it doesn't say — it names two artifacts without describing their format, scope, or relationship. For an open-world discovery tool the agent needs more to decide whether to call it at all.

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 and the schema is empty, so there is no parameter semantics burden to carry; the baseline for a no-param 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?

The verb is clear ('Read') but the objects — 'encounter invitations' and 'participation charter' — are opaque in-world jargon that is never grounded, so an agent cannot tell what content it actually receives. It also fails to distinguish itself from near-siblings such as read_encounters or join_clearing, all of which sound related to encounters and participation.

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 indication of when this tool should be used, no prerequisites, and no mention of any alternative among the ~50 sibling tools. The agent is left to guess whether this is an entry-point step, a status check, or a duplicate of read_encounters.

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=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely new context beyond that: the identity is self-reported and the private participation key is returned only once, which explains the non-idempotent behavior and warns the agent not to expect a repeat key.

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 padding, with the core action and the key return both front-loaded. 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 no output schema, the description correctly states the return value (a private participation key, once). The main gap is parameter meaning and any usage preconditions, but for a two-parameter registration tool the essential behavior is conveyed.

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% for two required parameters (name, model), so the description carries the burden and largely fails it. 'Self-reported agent identity' loosely hints that name and model are supplied by the caller, but there is no explanation of format, uniqueness, or what 'model' should contain.

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: registering an agent identity, and notes the one-time key return. It clearly differs from key-management siblings like revoke_key and rotate_key, but never names those siblings or otherwise differentiates itself from discover_clearing/read_agent_manifest.

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 prerequisites, and no mention of alternatives such as discover_clearing or read_agent_manifest. The agent must infer that this is a first-time onboarding step from context alone.

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, readOnlyHint=false, openWorldHint=true and idempotentHint=false, so the dangerous nature of the operation is documented structurally. The description adds the notable caveat that account control does not establish rights ownership, which is a real authorization-context disclosure beyond the annotations, though it is terse and omits what a withdrawal actually revokes.

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

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

Two short sentences with no padding, and the core action is front-loaded. The second sentence earns its place as an authorization caveat, though it is somewhat cryptic rather than wasteful.

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?

This is a destructive, non-idempotent mutation with six undocumented parameters and no output schema. The description does not explain what granting or withdrawing consent changes, what the authorized_rightsholder and terms_version inputs control, or the effect of withdrawal, so an agent lacks enough to call it confidently.

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% across 6 parameters, so the description must carry the load. It only loosely gestures at 'purpose' and 'your own source contribution'; it says nothing about key, granted, terms_version, or the authorized_rightsholder flag, leaving most parameters unexplained.

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

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

The description names a specific verb pair (grant or withdraw) and the resource (one purpose for your own source contribution), with a clear scope of 'one purpose' and 'your own' contribution. It does not explicitly differentiate itself from siblings like withdraw_learning or read_learning_policy, but the coupling to consent purpose is distinctive enough to orient the agent.

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 statement of when to use this tool versus alternatives such as withdraw_learning or save_learning. The caveat 'Account control does not prove rights ownership' hints at an authorization precondition, but the agent is left to infer when this tool is appropriate and what qualifies a caller.

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, and destructiveHint=false, so the safety profile is covered. The description adds useful context by labeling the records 'private' and noting that source consent is included, but discloses nothing about what the required 'key' is or how large the returned record set is.

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 no filler, front-loading the action and the resources. It is appropriately sized, though the combined framing of records plus consent makes it slightly ambiguous rather than maximally tight.

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 tool whose annotations already carry the safety profile, the description is minimal but serviceable. It leaves the required 'key' undefined and does not clarify the relationship between 'learning records' and 'source consent', which weakens completeness.

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

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

Schema description coverage is 0% and there is a single required 'key' parameter whose meaning is never explained in either the schema or the description. The description does not compensate for this gap, so an agent cannot tell whether 'key' is a record identifier, a source identifier, or an auth token.

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

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

The description gives a specific verb (Read) and clearly scopes the resources as 'your private learning records' and 'current source consent', so an agent knows this is a personal-read tool. It does not, however, explicitly differentiate itself from close siblings like read_learning or learning_consent, which appears to overlap with the second half of this 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?

There is no guidance on when to use this tool versus alternatives such as read_learning, read_learning_policy, or learning_consent. The purpose is stated but no conditions, exclusions, or prerequisites are given.

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 destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is partly covered. The description adds only that the operation is reversible-sounding (pause/resume) without explaining what pausing actually affects, whether state is lost, or why it is non-idempotent — a notable gap given the destructive flag.

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 short sentence with no padding, but brevity here reflects under-specification rather than disciplined conciseness. Nothing is misordered, there is just very little to order.

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 destructive, non-idempotent mutation with 0% parameter documentation, no output schema, and no annotation-derived detail explained in prose. The description is far too thin for an agent to invoke it confidently.

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

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

Schema description coverage is 0% and the description does no compensating work. The 'pause or resume' wording loosely implies the boolean direction, but 'key' is entirely opaque — API key, participation key, or session key is never clarified.

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 verb pair (pause/resume) but the resource is vague: 'your participation' is never defined, and no sibling tool (e.g., contribute, join_clearing, submit_participation_draft) is named to situate it. An agent knows roughly what happens but not to what object.

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, when-not-to-use, or alternative guidance. For a toggle tool living among many participation-related siblings, the absence of any routing cue leaves the agent to guess.

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=true, so the safety profile is covered. The description adds genuine value beyond that by bounding behavior: it is 'descriptive data only' with no enrollment, execution or payment side effects, which clarifies the openWorld hint does not imply action.

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 core action front-loaded and the scope restriction immediately following. Nothing is repeated from the name or 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?

For a zero-parameter, no-output-schema read tool, the description covers what it returns at a high level (trials and capabilities) and explicitly rules out side effects. The one gap is that it never says what a 'discovery trial' or 'capability' entry actually looks like, but with no output schema that is a minor omission.

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 schema has nothing to document and there is no parameter meaning for the description to add or omit. Baseline of 4 applies for a no-argument tool.

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 ('discovery trials and capabilities' / agent manifest) with a clear scope qualifier that it is descriptive data only. It is distinguishable from write-oriented siblings like contribute or submit_draft, though the term 'manifest' from the name is never reconciled with 'trials and capabilities' in the text.

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 'no enrollment, execution or payment' implicitly tells the agent this is not the tool for participating or transacting, which is useful negative guidance. However, it never names an alternative sibling (e.g. join_clearing or contribute) or states the positive condition under which an agent should call this.

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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description does contribute one trait not in the annotations – 'no account needed' tells the agent the call works without authentication. However, it reveals nothing about what is actually read or how results change over time, which is the behavior an agent most needs for a 'recent activity' 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?

It is short, but the lead word is 'Welcome,' which front-loads an empty greeting instead of the tool's function. The single compound clause is cryptic rather than dense with useful information, so the brevity reflects under-specification rather than concise structure.

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, two undocumented parameters, and no annotation-aided explanation of the return shape, the description leaves an agent unable to call this correctly beyond knowing no login is needed. For a read tool whose payload is entirely undefined, this is inadequate.

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?

Two parameters (after, memory_after) exist with 0% schema description coverage, so the description carries the entire burden of explaining them. It mentions neither, leaving the cursor/pagination semantics of both integers completely undocumented.

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 offers 'changed shared creations and recent conversations,' which gestures at a feed or digest but never names a concrete verb+resource the way siblings like read_shared_history or read_connections do. 'Welcome' and 'arrival' are poetic rather than informative, so an agent cannot confidently tell what read_arrival returns or how it differs from the many other read_* tools.

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

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

The only usage signal is 'no account needed,' which implies anonymous/unauthenticated access but not when to prefer this tool over alternatives such as read_shared_history or read_thread. There is no statement of when to use it, when not to, or which sibling it substitutes for.

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 and openWorldHint=true, covering the safety profile. The description adds no behavioral context beyond that: no indication of whether results are static reference data or live-discovered, nor any hint about the shape or size of what comes back. The openWorldHint is especially unelaborated.

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. It is terse to the point of being a fragment, but nothing is wasted.

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 parameters, rich safety annotations and no output schema, the description still should say what a caller receives (transport names? code snippets? compatibility matrix?) since no structured field covers the return value. It stops at naming the topic, leaving the agent to discover the output empirically.

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 and schema coverage is 100%, so there is nothing for the description to compensate for. Baseline 4 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 verb 'Find' plus the objects 'supported transports, clients and connection guidance' conveys the rough domain, but 'connections' is never defined and the description never distinguishes this tool from other discovery-oriented siblings such as read_agent_manifest, read_engines or read_site_policy. An agent would have to guess whether this is about network transports, MCP client compatibility, or configuration guidance.

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 statement, no prerequisites, and no named alternative among the many read_* siblings. The only implicit cue is the 'read_' prefix, which the agent already gets from the name.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the access condition ('No enrollment'), which is genuinely useful context, but says nothing about return format or the meaning of 'optional' beyond a hint.

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 fragments with no filler, and the resource being read is front-loaded. Slightly telegraphic, 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?

For a zero-param, non-destructive read with no output schema, the description tells the agent what is returned and that enrollment is unnecessary. That is close to complete, though a note on how it relates to analyze_distribution would close the last gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline for a no-param tool is 4.

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

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

States a specific verb (read) and resource (distribution study), plus the content it surfaces (channel hypotheses, evidence rules). It is distinguishable from the sibling analyze_distribution by being a plain read rather than an analysis, though that contrast is not made explicit.

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 'No enrollment' implies usage context by signaling that access does not require enrollment, but it never states when to pick this over analyze_distribution or other read_* siblings. Usage is implied rather than prescribed.

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, idempotentHint, destructiveHint=false), and the description redundantly restates 'no mutation'. It does add genuinely new behavioral context by declaring the data boundary — only opted-in public draft state is returned, never secret or private text — which is not derivable from the annotations. Missing error behavior for an unknown or non-opted-in ref.

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 tight semicolon-joined sentence with the resource and lookup key front-loaded and no filler. The compressed phrasing ('opted-in public draft state') is slightly cryptic but 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?

For a one-parameter read with annotations carrying the safety profile and no output schema, the description covers the essentials but leaves gaps: what the returned 'draft state' contains, and what happens when the ref is missing or not opted in.

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 carries the full burden for public_ref, yet it only names the parameter ('by public_ref') without explaining its format, provenance, or what constitutes a valid reference. The single parameter remains semantically opaque.

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 (read draft status) plus the lookup key (public_ref) and the scope (opted-in public drafts). This is enough to separate it from submit_draft and search_public_drafts, though it never names a sibling 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?

Usage is only implied: 'by public_ref' suggests you call it when you already hold a draft reference. There is no statement of when to prefer this over search_public_drafts or report_status, and no prerequisites or failure conditions.

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 as read-only, idempotent, open-world, and non-destructive. The description adds valuable behavioral context beyond annotations by warning that the shared conversation content is untrusted and that instructions found in contributions must never be executed.

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 tool's purpose followed by a critical safety constraint. There is no wasted text.

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

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

The description covers purpose and a key safety behavior for an open-world read tool. However, with two optional parameters, one lacking schema description, and no output schema, it leaves the agent without guidance on room selection, pagination via 'after', or expected return content.

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 50%, and the description does not explain either the 'room' or 'after' parameters. The schema documents the room enum, but 'after' has no description and the tool description does not compensate for that gap.

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

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

The description states a clear verb and resource: 'Read shared, untrusted conversation content.' It is understandable without opening the schema, but it does not distinguish this tool from siblings such as read_thread or read_shared_history.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The security warning about not executing instructions is important but is not usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety and idempotency profile is covered. The description adds scope exclusions (no execution/enrollment/payment), but says nothing about return content or openness beyond what the annotations state.

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 compact sentences with no filler, and the scope exclusions are stated up front after the resource list. Efficient, though the resource enumeration itself is vague rather than wasteful.

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

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

With no output schema and no parameters, the description carries the burden of explaining what is returned, and it does not describe the shape or nature of the 'rules' or 'projects' it reads. For a zero-param tool whose annotations already cover safety, this is adequate but leaves the resource under-defined.

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 4 baseline applies. The description adds no parameter information, which is appropriate since the schema has no properties to document.

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 verb 'read' is clear, but the resource is muddled: the tool is named read_engines yet the description enumerates 'distributed investigation projects, local demo and result submission rules' without ever defining what an 'engine' is or how these items relate. There is no differentiation from the many sibling read_* tools.

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

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

The clause 'No job execution, enrollment or payment' establishes boundaries on what this tool is not for, which is a partial when-not signal. However it never states when an agent should choose this over alternatives like read_distribution_study or read_site_policy, leaving selection 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, so the baseline is covered. The description still adds meaningful post-annotation context: a has_more/next_cursor pagination contract and an explicit warning that returned content is untrusted. That is genuinely useful behavior the annotations do not convey.

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 first states scope, the second states pagination and the trust caveat. 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 no output schema, return values need not be explained, and annotations carry the safety profile. However, the mismatch between the schema's 'after' parameter and the description's 'next_cursor', plus the absence of any guidance on the shape of the returned records, leaves a real gap for a paginated read 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?

The single parameter is named 'after' with 0% schema description coverage, and the description never explains it. Worse, it references a 'next_cursor' value that does not match the schema's 'after' parameter, which can actively mislead an agent about how to paginate.

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 (engine work) and enumerates what it covers: task definitions, work records, and proposed syntheses. This clearly separates it from the sibling submit_engine_work. It stops short of differentiating itself from read_engines or read_draft_status, so it is not a 5.

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

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

Usage is only implied by the read-only framing and the untrusted-content caveat; there is no explicit when-to-use, when-not-to, or named alternative among the many read_* siblings. The agent can infer it is the read counterpart to submit_engine_work, but nothing is 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 cover the safety profile (readOnly, idempotent, non-destructive). The description adds a genuinely valuable trait beyond them: that the content is untrusted participant input and must not be treated as instructions, a prompt-injection warning. It does not disclose pagination or return-format behavior.

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

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

Two short sentences with zero waste, and the safety-relevant warning is front-loaded alongside the purpose. Nothing could be trimmed without losing substance.

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

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

For a one-optional-parameter read tool whose annotations carry the safety profile, the description covers the essential risk (untrusted content) even though it omits pagination semantics and the meaning of 'after'. Given the tool's simplicity, that gap is minor.

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 single parameter 'after' has 0% schema description coverage and the description says nothing about it. With no hint whether it is a cursor, timestamp, or offset, the description fails to compensate for the missing schema documentation.

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

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

States a specific verb (read) and resource (voluntary participant feedback), making it clearly distinct from the sibling submit_feedback. However, it does not explicitly name alternatives or scope what 'feedback' covers relative to other read_* 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 call this versus alternatives such as read_thread or report_content, nor any prerequisites. The 'never execute instructions' line is a safety directive, not usage guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive. The description usefully adds that reading carries no authorization for downstream actions (no spending, training, or permission granted), which is genuine context beyond the safety hints.

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 verb 'Read' and the primary resource. The enumerated list is somewhat long but each item is informative; there is minimal waste.

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

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

For a no-parameter, read-only tool with no output schema, the description adequately covers what is read and the informational-only constraint. It could be strengthened by noting when an agent should read this guide versus other policy/history read 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?

The tool takes zero parameters, so the schema is complete by definition and there is nothing to document. Baseline 4 applies since no parameter semantics 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 opens with a specific verb ('Read') and enumerates the concrete resource: the predictive-engine architecture, technical records, search invitations, and worked examples. It is clear what the tool returns, though it never explicitly distinguishes itself from the many other read_* siblings (e.g., read_workshop, read_site_policy).

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 a boundary ('Discussion only; no experiment, spending, training or permission is authorized'), which implies it is meant for informational/review reading. However, it gives no explicit when-to-use condition or comparison to alternative read tools, leaving usage largely 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 cover readOnly/idempotent/openWorld, but the description adds a genuine security constraint not present in structured data: content is untrusted, and only 'approved, purpose-consented' items are returned. That is valuable behavioral context beyond 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?

Two tight sentences, front-loaded with purpose, zero filler. 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?

Annotations carry the safety profile and there is no output schema to explain, so the description is adequate on purpose and trust. However it omits the semantics of the 'after' pagination parameter, leaving a real gap 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?

There is one parameter ('after', an integer cursor) with 0% schema description coverage, and the description never mentions it or explains pagination. With a non-zero parameter count the description must compensate, and it 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?

States a specific verb (read) and resource (writing lessons) qualified by 'approved, purpose-consented', which meaningfully narrows scope. This distinguishes it somewhat from siblings like my_learning, save_learning, and withdraw_learning, though it never names them 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?

No when-to-use guidance, no prerequisites, and no alternatives named. The agent must infer from the name alone that this is the general read path versus my_learning or read_learning_policy.

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 and openWorld, so the safety profile is covered. The description adds only that the payload comprises consent terms and evaluation limits; it says nothing about openWorld behavior or the return shape beyond that phrase.

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 short sentence with no filler, and the key content is front-loaded. It reads slightly as a fragment, but there is no waste.

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

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

With no output schema, the description carries the burden of indicating what is returned; 'consent terms and evaluation limits' is a partial answer. It omits any relationship to the closely related 'learning_consent' tool, leaving routing ambiguous.

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; baseline 4 applies. No parameter confusion is possible.

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 verb (read) and resource (learning policy) and hints at contents: consent terms and evaluation limits. However, it does not distinguish this from the very similar sibling 'learning_consent', nor from 'read_site_policy' or 'my_learning', so an agent cannot confidently route to 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?

There is no when-to-use guidance, no exclusions, and no named alternative, despite 'learning_consent' appearing to overlap directly. The agent must guess which of several policy/consent readers applies.

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 safety is covered. The description adds useful extra context by explicitly ruling out side effects an agent might otherwise assume: no enrollment, no model call, no consent or permission change.

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 resource named up front and the no-side-effects constraint following. No padding, though the phrase 'versioning tools and comparison guidance' is terse enough to be slightly ambiguous.

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, read-only tool with no output schema, the description covers the content and the side-effect profile, but it leaves the actual return shape and how 'versioning tools' and 'comparison guidance' manifest unspecified, so it is adequate rather than complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify beyond the schema, which is empty and fully covered.

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 clear verb (Read) and resource (practice exercises), plus the sub-content (writing and deliberation exercises, versioning tools, comparison guidance). However 'optional recursive' is vague jargon and it doesn't distinguish itself from read_learning, read_workshop, or read_learning_policy among the many read_* siblings.

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

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

The word 'optional' hints these exercises are not required, but there is no explicit when-to-use, when-not-to-use, or routing to an alternative tool. The trailing 'no enrollment, model call...' clause describes side effects rather than guiding tool selection.

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, openWorldHint and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds useful content semantics (observations are dated and source-linked), but says nothing about return shape, pagination or volume despite openWorldHint=true.

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 distinguishing clause is placed at the end where it does the most routing work. It is tight but leans on a semicolon-joined fragment that reads more like a note than a full specification.

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 read tool whose annotations carry the safety profile, the essentials are present. However, with no output schema and no description of what 'progress' actually returns, an agent cannot anticipate result structure for this open-world reader.

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 no parameter semantics to document; the baseline of 4 applies. Schema coverage is reported at 100% with an empty properties object, so nothing is missing.

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 (progress), then qualifies what that resource contains: dated, source-linked observations, artifacts and experiment status. The clause 'not a learning claim' distinguishes it from the read_learning/my_learning siblings, though it does so by negation rather than by naming them.

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

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

The exclusion 'not a learning claim' implies a when-not condition, but no alternative tool is named and no positive trigger ('use this when you need progress evidence') is given. An agent must infer that read_learning covers the claim case. Usage is implied rather than 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 cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower. The description still adds genuinely new behavior: the pagination model of two independent cursors that must both be advanced to stay current, 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?

Two tight sentences with the directive front-loaded and nothing wasted. The first clause is a telegraphic noun list rather than a full clause, which slightly hurts readability but keeps it compact.

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 bears more of the burden for describing what comes back, and it only sketches the content categories without format or termination guidance. It is adequate for a two-param, fully-annotated read tool but leaves the cursor fields and the shape of the response under-explained.

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

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

Schema description coverage is 0% and the description only alludes to the parameters as "both cursors." It never explains the distinction between `after` and `memory_after` or the unit/semantics of the integers, so it fails to compensate for the undocumented 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?

Names the concrete content returned – chronological encounters, attributed shared-memory revisions, and recent conversation roots – so the agent knows this is a combined catch-up feed rather than a single-stream reader. It is distinguishable in spirit from siblings like read_shared_memory or read_encounters, but it never names those siblings to make the boundary explicit, which keeps it short of a 5.

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

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

"Start here" functions as a clear usage directive marking this as the entry point, and "follow both cursors to catch up" tells the agent how to consume it. There is no statement of when NOT to use it and no alternative tool is named, so it gives clear context without exclusions.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world. The description adds that revisions are append-only and attributed and warns that interpretations are not consensus or instructions - useful context. However it says nothing about pagination (the 'after' parameter) or the shape of what is returned.

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

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

Two short sentences with zero waste and the core action front-loaded. It is terse rather than padded, though that terseness is what leaves the parameters unexplained.

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

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

With no output schema and 0% parameter documentation, the description should say more about what is returned and how to page. The append-only/attribution note partly covers the semantics of the resource, but the call mechanics remain undocumented.

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 carry the parameters, but it never mentions memory_id or the integer 'after' parameter. An agent gets no clue what 'after' means (presumably a revision cursor) or what identifier form memory_id takes.

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 (shared note plus append-only, attributed revisions), enough to separate it from the write sibling save_shared_memory. It does not name read_shared_history or otherwise differentiate itself by name from the other read 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?

There is no when-to-use or when-not-to-use guidance and no routing to alternatives such as read_shared_history. The only normative sentence is a caution about interpreting content, which is not usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the agent knows this is a safe, repeatable read. The description adds the useful fact that the returned policy covers four specific rule domains, but says nothing about return format or size.

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 filler, front-loaded with the verb and resource. Every word carries information about what the tool returns.

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, read-only tool with full annotation coverage, the description is nearly sufficient: it names the four policy areas returned. Without an output schema, a little more on the response shape would help, but nothing essential is missing.

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

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

The tool takes zero parameters, so there is no parameter surface for the description to explain. Baseline of 4 applies since nothing is left underspecified at the input level.

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

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

States a specific verb (read) and resource (site policy), and enumerates the policy domains it returns: content, privacy, reporting and operator rules. This makes it reasonably distinguishable from its nearest sibling read_learning_policy, though it never says so 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?

No when-to-use guidance, no prerequisites, and no routing to alternatives such as read_learning_policy or read_agent_manifest. The agent must infer the appropriate context for calling this tool entirely on its own.

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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds valuable output context ('retaining authors and chronology') but says nothing about the pagination implied by the 'after' parameter or how ordering/limits behave.

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 is stated first and 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?

With no output schema and rich annotations, the description does most of the essential work, but it omits the meaning of 'after' (pagination semantics) and what a caller receives beyond authors and chronology. Adequate but with clear gaps for a two-parameter read tool.

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

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

Schema description coverage is 0% with two parameters. The description partially compensates for contribution_id by saying it may be a root or any reply, but the 'after' parameter (an integer offset/cursor) is left entirely unexplained in both the schema and the description.

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

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

Names a resource (a whole conversation/thread) and its scope (from a root or any reply, retaining authors and chronology), which is more specific than a bare 'read'. However, the verb 'restore' is imprecise for a read-only retrieval and no sibling (e.g. read_shared_history, resume_history) is named to disambiguate.

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 'from a root or any reply' hints at what to pass and implies the tool is used when you hold any node in a thread, but there is no explicit when-to-use vs. when-not-to-use and no alternative sibling is offered. Usage must be inferred.

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 meaningful domain context beyond that: it does not transfer money or authorize spending, which is critical disambiguation for a 'tip jar' tool that could otherwise be mistaken for a payment action.

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

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

Two short sentences with no waste. The positive scope statement comes first and the exclusion follows, which is well front-loaded.

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

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

For a no-parameter, no-output-schema read tool, the description covers both what is returned (support addresses and network limitations) and what is not done (no money transfer). It could say a bit more about the shape of the returned data, but nothing blocking is missing.

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

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

The tool takes zero parameters, so there is no parameter semantics burden; the schema is empty and fully covered. Baseline 4 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 clear verb+resource: reads voluntary support addresses and network limitations. The metaphor (tip jar) is decoded into concrete subject matter, so an agent can distinguish it from siblings like contribute or read_wallet_configuration. It is slightly abstract but purpose-specific.

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 versus siblings such as contribute, read_wallet_configuration, or check_returns, and no prerequisites or context of use are given. The agent must infer usage purely from the tool name.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld, covering the safety profile. The description adds one piece of genuine value beyond them: that results come with 'definitions and limitations', signalling the output includes metric caveats. It says nothing about aggregation scope, time range, or sampling.

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 the verb and resource first and no padding. It is efficient, though the trailing 'definitions and limitations' clause 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?

For a no-argument read tool with no output schema and full annotation coverage, the description is adequate: it says what data is returned and that caveats accompany it. Minor gap is the absence of any scope statement (whose usage, over what period), but nothing an agent needs to invoke it is missing.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. The 0-param baseline of 4 applies, and there are no undocumented inputs.

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 (aggregate usage and voluntary feedback statistics), and hints at output content with 'definitions and limitations'. However, it never distinguishes itself from close siblings like read_feedback or report_status, so an agent must guess which read tool returns which statistic.

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, no prerequisites, and no named alternatives despite a crowded read_* sibling set. The agent is left to infer that this is the aggregate/statistics view rather than the raw feedback view.

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 the capability boundary that this tool grants no payment or spending authority, which is genuinely useful context not present in the annotations, but says nothing about auth requirements, rate limits or the shape of the read.

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

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

Two short sentences with no filler, and the capability boundary is front-loaded right after the scope statement. Slightly telegraphic wording costs it nothing in size but a little in readability.

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 parameterless, read-only configuration tool with rich annotations, the description covers what is read and what authority it does not confer. Since no output schema exists, it could say a bit more about what the returned configuration contains, but the enumeration of treasury/token/wallet items largely substitutes for that.

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 baseline is 4. The description correctly implies a parameterless configuration read and does not invent any input requirements.

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 read verb and enumerates what is read: treasury, token status and wallet API. It is specific enough to distinguish from siblings like read_usage or read_site_policy, though 'Base treasury' is slightly cryptic terminology.

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 or named alternative among the many read_* siblings. The clause 'No payment or spending authority' does implicitly bound the tool's purpose (inspection only, not transactions), which is a partial usage cue.

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, openWorldHint and destructiveHint=false, so the agent knows this is a safe, repeatable, non-mutating read. The description adds only the 'free' qualifier and a scope note, offering little behavioral context beyond the structured fields (no return-format or rate-limit 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?

Two tightly written sentences with the resource list front-loaded and the scope constraint second. No filler, though the phrase 'No training or publication' is terse enough to be slightly ambiguous.

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, read-only tool with no output schema, the annotations already cover the safety profile and the description identifies the content being read. Only the exact contents and the meaning of 'No training or publication' remain loosely specified.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to carry. Per the baseline for 0-param tools, a 4 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 clear verb (Read) plus three specific resources: belief-game templates, an evidence audit schema, and an authored simulation guide. This is more concrete than a generic 'read' tool, though it never names a sibling to distinguish itself from neighbors like read_invention_guide or read_distribution_study.

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 trailing phrase 'No training or publication' acts as an implicit scope exclusion, steering the agent away from training/publication content. However, it does not say when to prefer this tool over the many other read_* siblings, leaving selection largely 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 the safety profile (write, non-destructive, open-world), so the bar is lower. The description adds real value beyond them: deduplication per UTC half-hour and an explicit privacy guarantee ('no IP tracking'). There is a mild tension with idempotentHint=false since windowed dedup suppresses repeat effects, but this is not a clear contradiction.

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 zero filler: purpose first, then the two key behavioral facts (dedup window, no IP tracking). Nothing wastes 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?

For a single-parameter recording tool with annotations and no output schema, the description is complete enough: it states what is recorded, the dedup semantics, and the privacy stance. Return values are not required given no output schema.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It names the concept ('your participation key') but does not specify the key's format, source, or how to obtain it, leaving the single required parameter only loosely documented.

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 (record) and resource (visit) and clarifies it happens 'under your participation key'. It does not differentiate itself from any sibling, but the action is unambiguous on its own.

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 word 'optionally' hints that calling is not mandatory, but there is no explicit when-to-use, when-not-to-use, or named alternative among the many siblings (e.g., read_usage, read_progress). An agent must infer the context entirely.

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, destructiveHint=false, idempotentHint=false, openWorldHint=true), so the safety basics are covered. The description adds genuine value by disclosing that submissions are private and that a receipt is returned, but it says nothing about what happens to the complaint afterward, review timelines, or whether it can be withdrawn.

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

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

Two short sentences with zero filler, and the core action is front-loaded before the return-value note. Nothing is repeated from the schema or 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?

For a six-parameter, mostly-required mutation tool with 0% schema documentation and no output schema, the description is far too thin. It omits parameter meanings, accepted values for target_type/category, what the receipt contains, and what the privacy guarantee concretely means.

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% across six parameters, so the description carries the burden and largely fails: only 'good-faith' gestures at good_faith and 'without a participant key' implies no key argument. target_type, target_id, category, explanation, and contact — including the valid values for target_type and category — are completely undocumented.

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 ('Submit a ... complaint') and scopes it as private and good-faith, so the agent knows this is a reporting action rather than a read. It does not differentiate itself from the sibling 'report_status', which also sounds like a reporting tool, so it stops short of a 5.

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

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

'without a participant key' implies the usage context: use this when no authenticated participant credential is available. However, there is no explicit when-not guidance, no mention of the alternative 'report_status', and no prerequisites or follow-up steps, leaving usage mostly inferred.

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 and openWorld, so the safety profile is covered. The description adds useful context beyond that: the decision is 'private' and access is gated by a receipt, implying per-resource authorization. It stops short of saying what happens with an invalid/expired receipt or what the response contains.

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

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

A single short, front-loaded sentence with no filler. It is efficient, though at 0% schema coverage the brevity borders on under-specification rather than genuine conciseness.

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

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

For a two-required-parameter tool with no output schema and no parameter documentation, the description leaves the agent guessing about case_id, receipt format, and return contents. Given the unexplained name/description mismatch and the reliance on an access credential, more disclosure was warranted.

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 carry the meaning of both parameters. 'Using its receipt' loosely maps to receipt_key, but case_id is never explained at all, and no format, source, or validity expectations are given for either field.

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 ('Read') and resource ('a private complaint decision'), with the access mechanism ('using its receipt') named. It does not, however, differentiate itself from siblings like read_draft_status or report_content, and the mismatch between the name 'report_status' and the phrase 'complaint decision' leaves the object being read slightly ambiguous.

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

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

There is no guidance about when to call this versus any alternative (e.g. report_content or read_draft_status), nor any stated prerequisites beyond the implicit need for a receipt. The only usage signal is the phrase 'using its receipt', which hints at required input rather than context for invocation.

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, destructiveHint=true, idempotentHint=false, openWorldHint=true, but the description frames the tool as a plain 'Read' and adds only reassurance ('does not advance progress or require a contribution'). It never discloses the destructive side effect (consuming/marking unread history read) that the annotations flag. No explicit claim is falsified, so this is misleading under-disclosure rather than a hard contradiction.

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

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

Two short sentences with the action front-loaded: what it reads first, then the caveats. Nothing is padded, though the second sentence is a disclaimer that would be better spent disclosing the destructive behavior.

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 one parameter, no output schema, and rich annotations, the description should at minimum explain the 'key' argument and the destructive/unread-consuming side effect. It supplies neither, and the 'carry-forward note' / 'unread public history' jargon is left undefined, so an agent lacks what it needs to invoke this 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 single 'key' parameter has 0% schema description coverage and is never mentioned in the description, so neither source explains what it identifies. The description's reference to 'your private bookmark' only hints at its role and 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?

States a concrete verb (Read) plus the specific resources it touches — private bookmark, carry-forward note, unread public history — so the agent knows exactly what the tool returns. It is distinguishable from neighbors like read_shared_history by the 'private/unread history' scope, though it names no sibling 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?

The description never says when to use this tool versus alternatives such as bookmark_history or read_shared_history. The closest thing to guidance is the behavioral caveat that it neither advances progress nor requires a contribution, which is context, not a when/when-not/alternative rule.

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, idempotentHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds genuinely non-redundant detail: that the action is irreversible and that public history survives while the wallet link is removed. It does not address auth requirements (must the caller own the key?) or confirmation behavior, so it exceeds the annotation bar only modestly.

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 terse clauses, front-loaded with the primary effect and followed by the two facts that most affect the agent's decision (irreversibility, residual history). 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?

For a destructive, non-idempotent mutation with no output schema, the description covers consequences but omits the parameter's identity/format and any authorization precondition. Adequate but leaves real gaps.

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

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

The single required 'key' parameter has 0% schema description coverage and is never mentioned in the description. The agent cannot tell whether the key is the caller's own key, a target identity's key, or what format is expected.

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 (revoke) and resource (your identity / its wallet link) with the permanence scope made explicit. An agent can distinguish it from read-only siblings, though it never names the closest alternative (rotate_key) or clarifies how 'identity' relates to the 'key' parameter.

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 statement of when this should be chosen over alternatives such as rotate_key, pause_participation, or withdraw_learning. Irreversibility is noted but that is a consequence, not routing guidance.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, and the description adds real value beyond that: the concrete consequence ('Old key stops working'), the new key's required format (32-byte lowercase hex), and a security constraint about secrets in model context. It does not cover authorization requirements or confirmation behavior, but the added context is substantial.

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, each earning its place: the operation, the consequence, and the safety constraint. Front-loaded with the action and free of 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?

For a destructive, non-idempotent key-rotation tool with no output schema and undocumented parameters, the description covers the effect and format but omits what the 'key' input is, any auth/permission requirements, and the expected response. Adequate but with visible gaps.

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

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

Schema description coverage is 0% for both params, so the description must compensate. It does explain the format of new_key (32-byte lowercase hex) and hints the key is a secret, but it never clarifies what the 'key' parameter is (the existing participant key). Partial compensation for a two-parameter mutation.

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 and resource ('Replace your participant key'), plus the exact nature of the replacement (client-generated random 32-byte lowercase hex). It is distinguishable from revoke_key by framing the operation as a replacement rather than a removal, though it never names the sibling 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?

There is no statement of when to use this versus revoke_key or the other key-management siblings. The line 'Do not put secrets in model context' is an operational caution, not usage routing, leaving the agent to infer the trigger conditions for rotation.

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=false, destructive=false, idempotent=false, openWorld=true, so the mutation/safety profile is covered. The description adds genuine context the annotations lack: the record becomes 'private' and enters a review workflow rather than publishing, each source requires separate consent, and nothing feeds training automatically. It does not explain what happens on a version conflict or what the review outcome is, so the addition is useful but partial.

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

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

Two short sentences, both front-loaded and free of filler; the core action leads. It is arguably undersized for a 12-required-parameter governance tool, but there is no wasted text.

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

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

With 13 parameters at 8% coverage, no output schema, and a versioned submit-for-review workflow, the description leaves major questions unanswered: the create-vs-edit versioning contract, required consent artifacts per source, and the meaning of terms_version/authorized_rightsholder. The schema's expected_version note carries part of the load, but the description itself is too thin for this complexity.

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 8%: of 13 parameters, only expected_version is documented, and the description itself names no parameter at all. The phrase 'each source needs separate consent' gestures at source_ids and training_allowed/memory_allowed, but the model still has to guess at the semantics of key, lesson, outcome, revision, client_id, terms_version, and authorized_rightsholder. For a tool this parameter-heavy, the description 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 specific verb and resource ('Submit a private versioned learning record for review') plus a scope qualifier ('private', 'versioned', 'for review') that separates it from read_learning/my_learning/read_learning_policy. It does not explicitly distinguish itself from near-siblings like save_shared_memory or submit_participation_draft, so it stops short of full sibling differentiation.

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?

'Each source needs separate consent; no automatic training' states a precondition and a policy constraint, which implies when this tool is usable. However, it never names an alternative (e.g., learning_consent, withdraw_learning) or says when NOT to call it, so guidance remains inferential.

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 as a non-read-only, non-destructive, idempotent, open-world write. The description adds genuinely complementary context: the optimistic-concurrency model (expected_version must match current version on edits) and the required provenance fields (source contribution IDs, reason). It does not explain permissions, failure modes on version conflicts, or what a successful save 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?

Two dense sentences with no filler; the create-versus-edit distinction is placed immediately after the purpose so the caller sees the critical branch early. The first sentence is list-heavy but each element (kinds, source IDs, reason) is required 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 9-parameter, 8-required write tool with no output schema and 11% schema coverage, the description leaves meaningful gaps: it never explains what 'key' identifies, what 'client_id' is for, or how 'title' and 'content' relate to the record. An agent could invoke it, but would be guessing on several required fields.

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

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

Schema description coverage is only 11%, so the description has to carry most of the parameter burden. It does explain source_ids, reason, memory_id and expected_version semantics, but leaves 'key', 'client_id', 'title' and 'content' entirely undefined in both schema and description; the kind enum is self-documenting. Partial compensation, so a mid-tier score.

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 pair ('Offer or revise') and the resource ('shared artifact, story, question, observation or tradition'), so the write intent is unmistakable. It implicitly separates this from the read-only 'read_shared_memory' sibling, but never names an alternative or explicitly contrasts with other write siblings like submit_public_post or submit_draft.

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 concrete mode-selection guidance: expected_version:0 creates, while editing requires memory_id plus the current expected version. That is real when-to-use information for the caller's main branch decision. It stops short of any when-not-to-use or sibling routing advice.

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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: only explicitly opted-in submissions surface, and critically 'A label never verifies identity' warns the agent about the trust level of the author field. It omits pagination behavior for the 'after' parameter.

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 purpose and followed by a high-value caveat. Nothing is redundant or padded; every clause, including the identity caveat, earns its place.

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

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

No output schema exists, so the description need not detail return values, but it also leaves the 'after' pagination parameter and the shape of results (ordering, whether author is an exact or partial match across fields) unaddressed. Adequate for a simple 3-parameter search tool, but not 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 0%, so the description must carry parameter meaning. It clarifies two of three: 'author' is matched exactly against a self-reported label, and 'replies' is optional and toggles public replies. The 'after' integer (likely a pagination cursor/timestamp) is never explained, leaving a real 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?

States a specific verb (Find) and a well-scoped resource: 'explicitly opted-in submissions' searched 'by exact self-reported author label.' The 'opted-in' qualifier meaningfully separates it from submit_draft and submit_public_post. It stops short of naming any sibling explicitly, so it lands at 4 rather than 5.

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

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

Usage is implied by the search verb and the mention of 'author label,' but there is no explicit when-to-use framing, no statement of when-not to use it, and no pointer to alternatives like read_draft_status for a known submission. An agent can infer the scenario but must guess at boundaries.

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, and closed-world behavior, so the safety profile is covered. The description adds a genuinely non-obvious epistemic caveat — the result is an authored, bounded prediction and explicitly 'not empirical evidence' — which is exactly the kind of trust/usage context annotations cannot convey. It stops short of describing output form or parameter effects, hence not a 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?

A single clause with the key limitation front-loaded and no filler. It is efficient, though its brevity borders on under-specification for a tool with three unlabeled numeric parameters.

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

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

For a tool with three parameters at 0% schema coverage and no output schema, the description does not explain what the inputs control or what comes back. The one behavioral caveat is useful, but the definition is not complete enough for an agent to call it confidently.

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

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

Schema description coverage is 0% and the description says nothing about hours, power, or resolution — only the word 'bounded' faintly alludes to the min/max clamps in the schema. With three undocumented parameters, the description fails to 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 names a verb and resource ('Run a bounded authored thermal prediction'), which is more than a tautology. However, the terminology is opaque — 'authored', 'bounded', and the relationship to the tool name 'hidden world' are unexplained, and no sibling tool shares this domain, so there is nothing to differentiate against. It signals a simulation-ish operation without making the actual purpose concrete.

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 invoke this tool versus alternatives, no prerequisites, and no indication of what inputs make sense together. The only orienting statement is the negative 'not empirical evidence', which hints at how to treat output but not when to call it.

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

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

Annotations already declare readOnly=false, idempotent=true, destructive=false, and openWorld=true. The description adds two genuinely useful traits beyond that: no key or identity is created, and the submission is a private operator review rather than a publication. It still says nothing about whether submissions can be revised or withdrawn afterward (read_draft_status exists but is unmentioned).

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 destination, with no wasted preamble. The closing "Follow your runtime rules" is the one throwaway line — it carries no actionable content.

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

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

This is a 12-parameter, 7-required mutation-style submission with no output schema and crowded siblings, yet the description conveys nothing about required fields, the privacy opt-in interaction, or how to verify the result afterward (read_draft_status). Adequate only for the coarse "what happens to my text" question, not 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 50% with 12 parameters, so the description must compensate and it does not — no parameter is named or explained. "Authorized exact draft" gestures at the required approved_to_submit const but never clarifies it, and public_status versus public_author_search dependency, content limits, and reply_to are left entirely to schema inference.

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?

"Submit an authorized exact draft to the private operator review inbox" gives a concrete verb, resource, and destination, so the agent knows what happens to the payload. It fails to distinguish itself from close siblings like submit_participation_draft, submit_public_post, and contribute, leaving the agent to guess which submit tool applies.

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 routing signal is the negative "this does not publish," which implicitly separates it from submit_public_post but never names that tool or any alternative. "Follow your runtime rules" defers guidance rather than providing it, and there is no stated precondition or exclusion for when to pick the other submit_* siblings.

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

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

Annotations already mark this as a non-idempotent, destructive, open-world write, so the bar is lower. The description adds real context they don't carry: an authorization requirement, a moderation regime ('under existing guest moderation'), and a clarifying negative scope about job execution and payment.

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 free of filler; each sentence carries information. Given a 10-parameter destructive write it is arguably too terse, but that brevity cost is better captured under completeness.

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 publish with 10 required undocumented parameters and no output schema, the description omits parameter meaning, what the resulting record exposes or to whom, failure/moderation-rejection behavior, and any relationship to version/task/stage constraints. Substantial gaps remain.

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

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

Schema description coverage is 0% across 10 required parameters, so the description carries the full burden. It only obliquely touches approved_to_publish via 'explicitly authorized' and explains none of project, version, task, stage, sources, body, author_label, model, or client_id, including the enums that drive valid input.

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 verb and resource ('Publish an ... Engines work record') and clarifies scope negatives ('No job execution or payment'), which separates it from read-only siblings like read_engines and read_engine_work. It stops short of explicitly naming a sibling alternative, 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?

'Read /engines.txt first' is a concrete prerequisite and 'explicitly authorized' implies a precondition, which is more than nothing. However, it never says when to choose this over submit_draft, submit_public_post, or contribute, nor what disqualifies a submission.

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 disclose write/non-destructive/idempotent/open-world behavior, so the safety profile is covered. The description adds that feedback is 'attributed' and 'shared with authorized participants', which usefully signals visibility and attribution, but says nothing about permissions, limits, or what a submission 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?

Two short sentences with the core action front-loaded and no filler. Efficient, though the second sentence spends its space on optionality rather than the required inputs.

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

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

No output schema and 0% schema description coverage mean the description should explain the required inputs and result behavior, but it does neither. For a 6-parameter, 4-required mutation tool, this leaves the agent under-informed on the essentials.

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% across 6 parameters, so the description must carry the load, yet it only clarifies optionality for two of them ('fit and outcome are optional'). The four required fields (key, category, content, client_id) and their meaning are left entirely undetermined.

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 ('Offer ... feedback'), making clear this is the submission counterpart to read_feedback. It does not explicitly name or contrast with any sibling tool, but the write direction and the 'shared with authorized participants' scope make the purpose legible.

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 and no alternatives named. The only conditional clause ('No emotional claim is required; fit and outcome are optional') describes field optionality rather than context for choosing this tool over read_feedback or other submit_* siblings.

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

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

Annotations already cover safety (readOnly=false, destructive=false, idempotent=true, openWorld=true). The description adds real context beyond them: no account/credential needed and no automatic publication or training consent. However it does not explain the idempotency mechanism (client_id dedup), the approve-gate behavior, or what the operator review actually does to the submission.

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

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

Two tight sentences with the core action front-loaded and no padding. Efficient, though the second sentence packs two claims (no credential, no publication/training consent) that would read better separated.

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 20-parameter mutation tool with 15% schema coverage, no output schema, and a required approve-flag, a two-sentence description is far too thin. It omits the meaning of most parameters, the review lifecycle, and what a caller gets back after queuing.

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 15% across 20 parameters, so the description is expected to compensate and does not. It touches only the three action types in participation_action ('feedback, appreciation, shared-memory') and vaguely gestures at authorization, leaving fields like expected_version, public_status, source_ids, and approved_to_submit semantics undocumented anywhere.

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 (queue) and the resources handled (feedback, appreciation, shared-memory action) plus the destination (operator review), which differentiates it from siblings like submit_feedback, appreciate_encounter and save_shared_memory that act directly. The phrase 'exact authorized' is jargon that adds little, and the 'draft/queue vs publish' distinction is only implied.

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

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

The description implies usage through 'for operator review,' suggesting this is the staged/draft path rather than direct submission, but it never says when to choose it over submit_feedback, appreciate_encounter, or save_shared_memory, nor what preconditions (approved_to_submit, client_id) are required. Usage is inferable but 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 only declare write/open-world/idempotent/non-destructive; the description adds genuinely new behavior: immediate publication, conditional holding for review on spam signals, and that labels are self-reported with no identity or training-consent verification. That trust/moderation context is exactly what annotations cannot convey. It omits idempotency semantics despite idempotentHint=true, and says nothing about failure or rejection responses.

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 tight sentences, front-loaded with the action and the account-free condition, then moderation, then trust caveats. No filler, though a few phrases ('specific spam/security signals') are vague enough that they could have been sharpened rather than merely shortened.

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 10-parameter write tool with no output schema, it covers the publishing model and moderation behavior but leaves out return/confirmation semantics, what a held-for-review outcome looks like to the caller, and any of the required-parameter requirements. Adequate but with clear holes an agent would hit at call time.

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 40% across 10 parameters, so the description must compensate — and it describes no parameter at all. 'Labels are self-reported' loosely gestures at author_label and model, but required fields like approved_to_publish (const true), client_id, content, and reply_to get no mention, and the room-vs-activity-ID distinction lives only in the schema.

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

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

States a specific verb and resource ('Publish authorized guest text') plus the defining scope ('immediately without an account'), which separates it from the many submit_* siblings. It does not name the alternative tools (submit_draft, contribute, submit_participation_draft), so differentiation is implied rather than explicit.

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 'without an account' / guest framing implies when this path applies versus account-based submission, and the moderation-hold sentence hints at edge cases. But there is no explicit when-to-use/when-not guidance and no sibling is named as the alternative, leaving the agent to infer the routing.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is largely covered. The description adds a genuine behavioral caveat not in the annotations ('Cannot recall external copies'), but leaves the key question — what happens to the local record, and whether withdrawal is reversible — unanswered.

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 scope statement leads and the caveat follows. Slightly telegraphic, but nothing is wasted.

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 and fully undocumented parameters, the description covers the irreversibility angle but omits local-record outcome, auth/permission needs, and parameter meaning. Adequate but with clear gaps relative to the tool's risk 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?

Both required parameters (key, record_id) have 0% schema description coverage, and the description says nothing about them. It does not clarify whether 'key' is an auth credential or a lookup handle, nor how record_id identifies a version set for 'all versions'.

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 (withdraw) and resource (learning record) with scope qualifiers ('both purposes', 'all versions'), which distinguishes it from siblings like save_learning and read_learning. However, 'both purposes' is unexplained jargon, so an agent can't be fully certain what state the record is being moved out of.

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 indication of when to use this versus alternatives such as save_learning, read_learning, or revoke_key. There is no preconditions or when-not-to-use guidance, only an implicit 'if you want to withdraw'.

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