Reviewmetric

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

No annotations are supplied, so the description must carry behavioral disclosure. It implies a read-only account lookup by listing returned data, but does not explicitly state that it is non-mutating, whether authentication or a specific account context is required, or how fresh the token and price data are.

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

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

The description is a single compact sentence that immediately enumerates the account data points. There is no filler or repetition.

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

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

With zero parameters and an output schema, the description need not explain return structure. It adequately signals the fields the agent will see, though it could say more about read-only behavior or account context.

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

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

The tool takes zero parameters, so the schema has nothing to explain and the description does not need to compensate. Baseline for zero parameters applies.

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

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

The description names a specific resource, the user's ReviewMetric account, and enumerates the information returned: RM tokens left, Atlas access, review count, and prices. It is clear what the tool exposes, though it lacks an explicit verb and does not distinguish itself from siblings such as list_my_reviews.

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 tool or which sibling to use instead. An agent must infer that it is for viewing account-level information, with no exclusions or alternative paths 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?

With no annotations, the description carries the full burden, and it does disclose one behavioral trait: the feed is refreshed weekly, so results are time-bounded. It says nothing about how many items are returned, whether results are cumulative or rolling, or whether it is a pure read — gaps that a zero-parameter tool can mostly afford but not entirely.

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, front-loaded with the scope. The parenthetical 'updated every week' slightly restates 'This week's' but does add the refresh cadence, so it is not pure 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?

An output schema exists, so return values need no explanation, and with no inputs the invocation surface is trivial. The description is close to sufficient, falling short only on how this differs from search_atlas for an agent deciding between the two.

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 are zero parameters, so there is nothing for the description to disambiguate; the baseline applies. The weekly-refresh note is the only semantic detail relevant to invocation and it is present.

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 resource (ReviewMetric Atlas) and a specific scope (this week's additions), which is more precise than a generic 'get updates'. It does not differentiate from siblings like search_atlas or list_frontiers, so an agent must infer that this is a recency feed rather than a searchable listing.

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

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

The description gives no explicit when-to-use guidance and names no alternatives. An agent could reasonably route a query about recent Atlas content either here or to search_atlas with no stated rule for choosing.

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

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

With no annotations at all, the description carries the burden and does real work: it discloses that the tool is pollable and returns different shapes over the lifecycle (progress vs. terminal report), which is the key behavioral fact. It omits rate/polling limits and doesn't confirm the read-only, side-effect-free nature explicitly.

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 plus an Args block, front-loaded with the core behavior. The Python-docstring style 'Args:' formatting is slightly out of place for a tool description but costs no clarity.

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

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

An output schema exists, so the description wasn't obliged to enumerate return values, yet it usefully summarizes what arrives on completion. The remaining gap is the missing sibling comparison for a status tool that sits next to get_report_json and get_text_fixes.

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

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

Schema coverage is 0% and the single parameter is a bare 'Run Id' string, but the Args section compensates by explaining exactly what the value is and the two ways to obtain it. That is genuine meaning beyond the schema, though it stops short of format details.

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

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

States a specific verb+resource ('Check a ReviewMetric review') and immediately characterizes the two response modes: progress while running, and full report + Atlas placement + text-fix count when done. It never names a sibling, so an agent must infer the boundary with get_report_json and get_text_fixes 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?

Usage is only implied: the run_id provenance ('returned by submit_manuscript (or listed by list_my_reviews)') tells the agent where to get the input, which suggests a post-submission polling flow. There is no explicit statement of when to call this versus get_report_json, nor guidance on how often to poll.

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

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

No annotations are provided, so the description carries the full burden. 'Return' implies a read-only retrieval and the description identifies the report contents, but it does not state permissions, side effects, error behavior for incomplete runs, or other operational context.

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

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

The description is front-loaded, short, and has no filler. The argument note is compact and adds a small constraint without bloating the definition.

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 getter with an output schema, the description is mostly complete: it states the returned report type, contents, and that the review must be completed. The main remaining gap is that it does not explain how to obtain or validate the run_id.

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

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

Schema description coverage is 0%, so the description must compensate. Its 'Args' line adds only the constraint that the run is completed, but it does not explain how to obtain the run_id, its format, or other parameter semantics.

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

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

The description uses a specific verb and resource: 'Return the complete ReviewMetric report as JSON', and it names the report contents. It is clear what the tool does, though it does not explicitly distinguish itself from any sibling tool.

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

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

The phrase 'of a completed review' gives a useful usage condition, implying it should be called after completion. However, there is no explicit guidance on when to use this versus alternatives or when not to use it.

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

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

With no annotations, the description carries the full disclosure burden, and it does add real value: it states the call is a 'Free preview' (cost expectation) and that output shape varies by preparation state (preview list vs. exact find/replace edits). It says nothing about permissions, what happens when run_id is not a completed review, or failure modes, which is a meaningful gap for a zero-annotation tool.

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

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

Two tight sentences: the first front-loads what the fixes are, the second covers the state-dependent behavior, followed by a minimal Args block. The parenthetical category list is dense but informative and nothing is redundant.

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

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

An output schema exists, so return values needn't be explained, and the description covers purpose, scope, lifecycle, and the one parameter. The remaining gap is the lack of dependency guidance on prepare_text_fixes and error/eligibility behavior for non-completed runs.

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

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

Schema coverage is 0%, so the description must compensate, and it does: the Args block constrains run_id to 'The Run ID of a completed review,' which is a real semantic restriction beyond a plain string. It does not give format examples or say where a run_id comes from (e.g., list_my_reviews), so compensation is partial but solid for a single parameter.

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

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

The description names the specific resource (text fixes of a completed review) and enumerates the categories of change it covers (wording, overstated claims, citations, missing references, method details, typos), so an agent knows exactly what it returns. It implicitly separates itself from prepare_text_fixes by describing the pre-prepared vs. prepared states, 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?

It establishes clear call context: this applies to a completed review, and the response depends on whether the fixes have been prepared yet ('Free preview before they are prepared; once prepared, the exact edits...'). What's missing is an explicit pointer to prepare_text_fixes as the step that transitions between those states, leaving the agent to infer it from the sibling 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?

No annotations exist, so the description carries the full load, and it does disclose the actual content returned: capability inventory, token-cost information, and example requests. That is meaningful disclosure beyond the name. It stops short of stating whether the output is static or account-specific and doesn't explicitly confirm it is side-effect-free, though a 'help' tool implies read-only.

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 that names the resource first and then enumerates the payload contents. No filler, no restatement of the tool name, and nothing extraneous for a zero-argument tool.

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

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

An output schema exists, so return values need not be described, and zero parameters remove any argument ambiguity. The description is adequate for a simple discovery tool, with only the omission of a clear invocation trigger keeping it short of 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, which is the baseline-4 case; there is nothing for the description to disambiguate. The description's mention of token costs and example requests correctly implies the caller supplies no arguments and receives a bundled informational payload.

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 ('Show') and a specific resource ('everything ReviewMetric can do in Claude'), plus the two content areas it covers: token costs and example requests. An agent can tell this apart from the operational siblings (search_atlas, submit_manuscript, account_status) without opening the schema, though it does not name those siblings 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: an agent would infer 'call this when onboarding or when unsure what ReviewMetric offers or what consumes tokens.' There is no explicit trigger condition, no 'use this before X' guidance, and no mention of whether it should be called first in a session.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It adds useful content scope by naming what the frontiers include (open problems, dependencies, active research groups), but it does not state that the operation is read-only, whether results are paginated, or whether the list is complete.

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

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

The description is a single front-loaded sentence with no wasted words. It is slightly evocative with metaphors like 'edge of science' and 'pushing it now,' but remains concise and 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?

An output schema exists, so the description need not explain return values. With zero parameters and a clear statement of the content returned, the description is largely complete for this simple listing tool, though it omits any note about result size or pagination.

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

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

The tool has zero parameters, so parameter semantics are not applicable. The baseline score of 4 is appropriate because there are no parameters to document and the schema is trivially empty.

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

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

The description clearly identifies the resource as the frontiers of the ReviewMetric Atlas and specifies the content: open problems, what they build on, and the research groups pursuing them. It does not explicitly state the listing operation or distinguish the tool from siblings like search_atlas, but the resource is clear.

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 search_atlas or atlas_whats_new. The description merely describes the content rather than giving usage context or exclusions.

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

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

With no annotations, the description carries the full burden, and it does disclose sort order, returned fields, and the 1–50 limit range. It says nothing about whether the call is read-only, whether results are scoped to the authenticated account, or what happens when the limit exceeds available reviews.

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 lines with the core behavior front-loaded and the parameter note following. Nothing is repeated or wasted, and the Args block is easy to scan.

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

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

An output schema exists, so return values need not be explained in depth, and the tool is a single-parameter list. The remaining gap is account scoping and truncation behavior, minor but relevant for a per-user listing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it explains that limit controls how many reviews are listed and bounds it to 1–50, which is not in the schema. Only the default of 10 is left to the schema, which is an acceptable division.

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

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

States a specific verb and resource ('List the user's ReviewMetric reviews') plus ordering ('newest first') and return content ('scores and Run IDs'). No sibling competes for the same job, so the lack of explicit differentiation is a minor gap rather than a confusion risk.

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 possessive scoping ('the user's ... reviews'), and the ordering note hints at the common 'show my recent reviews' case. There is no statement of when-not to use it, no prerequisites, and no alternative tool named among the many siblings.

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

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

No annotations are present, so the description carries the full behavioral burden. It implies a read-only analytical lookup and hints at the return content, but says nothing about cost/latency, whether it mutates anything, or failure modes for an invalid/incomplete run_id.

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 prose lead is front-loaded and vivid but still economical; the Args block is a single line and earns its place by anchoring the one required parameter. Only mild redundancy with the output schema.

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 required parameter and an output schema, the description needs only to name the operation, constrain the input, and point to the source of run_id — all of which it does. Nothing required for correct invocation 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?

Schema coverage is 0%, so the description must compensate, and it does: run_id is constrained to a completed review and the agent is pointed at list_my_reviews to obtain it. It stops short of format/validation details.

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

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

States a specific verb+resource: it places one of the user's reviewed manuscripts on the ReviewMetric Atlas and describes the resulting facets (topic, cited landmarks, closest discoveries, frontier). Distinguishes it reasonably from siblings like search_atlas or list_frontiers, though it never explicitly names an alternative.

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?

Implicitly scoped by 'one of the user's reviewed manuscripts' and 'a completed review', and it routes the agent to list_my_reviews for the run_id. It does not say when to use this instead of search_atlas/trace_path, nor what happens if the review is incomplete.

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

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

With no annotations, the description still discloses useful cost behavior: it uses 1 RM token and repeat requests for the same review are free. However, it does not explain permissions, whether preparation creates persistent state, what happens if the review is incomplete, or other side effects, so important behavioral context is missing.

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

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

The description is short and front-loaded with purpose and cost, followed by constraints, the next tool, and the single argument. Every sentence adds operational value, and the Args section is compact for a one-parameter tool.

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

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

For a one-parameter tool with an output schema, the description covers the key prerequisite (completed review), cost, and the follow-up retrieval step. It omits how to obtain the run_id and error behavior for incomplete reviews, but the output schema removes the need to explain return values.

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

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

Schema description coverage is 0%, so the description must compensate; it identifies run_id as the Run ID of a completed review, adding a useful prerequisite. It does not specify the expected format or where an agent should obtain the run_id, so compensation is only partial.

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 action (prepare text fixes) on a specific resource (a completed review) and distinguishes this tool from the sibling get_text_fixes by describing the workflow: prepare first, then retrieve the edits with get_text_fixes. An agent can identify the tool's role without opening the schema.

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

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

It explicitly limits use to cases where the user asked for the fixes and names the required follow-up tool get_text_fixes. This provides clear when-to-use guidance and a concrete next step, leaving little 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?

No annotations are provided, so the description carries the full burden. It does disclose search semantics (matches names, topics, summaries) and the limit bounds, but says nothing about whether content must be unlocked first via unlock_atlas_sources, whether this is a read-only operation, or how results are ordered.

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?

Purpose is front-loaded in the first sentence, and the Args block is a compact, scannable mapping of the three parameters. Slight redundancy in describing both the corpus and the matched fields, but no filler.

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

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

An output schema exists, so return values need no explanation, and all three parameters are covered in prose. The remaining gap is relational context — whether the Atlas must be unlocked or populated (place_on_atlas) before a search is meaningful.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it gives query examples, enumerates the six valid field values (the schema only declares a bare string with no enum), and states the limit range of 1–20 that the schema omits. It could still clarify whether field filtering is exact-match.

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 ("Search the ReviewMetric Atlas") and characterizes the corpus (landmark discoveries since 1900, Nobel Prizes, frontiers) plus what fields are matched. It does not distinguish itself from siblings like list_frontiers or atlas_whats_new, 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?

Usage is only implied: the example queries and the enumerated field values hint at typical search intents, but there is no explicit statement of when to use this instead of list_frontiers, atlas_whats_new, or trace_path. With 13 siblings, the absence of routing guidance is a real gap.

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

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

With no annotations, the description carries the behavioral burden well: it discloses the billing cost (1 RM token), expected runtime (~5 minutes), the internal pipeline (novelty, claim support, methods/reproducibility, citation accuracy including retracted references, figures, clarity), and the editorial output. It omits failure modes, whether it blocks or runs asynchronously, and whether a resubmission of the same file is billed again.

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 first sentence front-loads the action and cost, followed by the panel behavior and then the argument docstring. The Args block largely restates the schema, and the referee enumeration is long, but every part is informative rather than filler.

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

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

An output schema exists, so return values need not be explained, and the description supplies the missing pieces: cost, latency, and what the panel evaluates. The main ambiguity is whether the call blocks for five minutes or returns a handle to poll via check_analysis_status.

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 document the single parameter, and it does: "Absolute path to the .docx file on this computer" conveys both format and the absolute-path requirement. Minor gaps remain, such as relative-path handling or behavior on a missing/invalid file.

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 ("Submit a local .docx manuscript to the ReviewMetric review panel") and immediately clarifies what the action triggers. It is clearly distinguishable from siblings such as check_analysis_status, get_report_json, and list_my_reviews.

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

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

The description gives clear context for invoking it: the input must be a local .docx file, it costs 1 RM token, and it takes about 5 minutes, which lets an agent weigh cost and latency. It stops short of explicit when-not-to-use guidance or naming an alternative path for non-.docx inputs.

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

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

No annotations exist, so the description carries the full behavioral burden, and it leaves key traits unstated: whether the tool is a pure read, what happens when no path exists between the two discoveries, whether direction matters, or how long a returned chain might be. It does convey the conceptual output ('chain of discoveries'), which is the one behavioral signal present.

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

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

Front-loaded with the core concept and two illustrative examples, then a compact Args block. The examples earn their space by disambiguating the abstraction; the Args block repeats parameter names but adds the name-or-id semantics, so it is not pure redundancy.

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

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

An output schema exists, so return values needn't be explained, and both parameters are described. But for a tool with zero annotations, the description says nothing about the no-path case, result ordering, or read-only safety, leaving material gaps an agent would want before calling it.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: the Args block names both parameters and explains the critical detail that each accepts either a discovery name or an Atlas id. It does not clarify symmetry (whether from/to can be swapped) or what 'frontier' means as a valid to_discovery value, which is mentioned but left undefined.

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

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

The description identifies the resource precisely — 'the chain of discoveries linking two stars of the ReviewMetric Atlas' — and the two concrete examples (double helix → AlphaFold, Turing machine → quantum computer) make the operation unambiguous. It stops short of stating a verb like 'returns' or 'computes' and never distinguishes itself from siblings such as search_atlas or list_frontiers.

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 examples suggest you call this when you want a connecting lineage between two known discoveries. There is no statement of when to prefer this over search_atlas or place_on_atlas, and no prerequisites or exclusions 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?

With no annotations, the description carries the full burden and mostly meets it: it discloses the price (1 RM token), that the charge is additive to current access, the 30-day window, and that the confirm-less call returns cost and the user's balance. It does not say what happens on insufficient balance, whether repeat calls extend access, or whether the charge is reversible — relevant for a payment operation.

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

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

The purpose and cost are front-loaded and the confirmation rule is emphasized where an agent will see it. The trailing 'Args: confirm: True only after the user's explicit yes' restates the IMPORTANT block, which is mild redundancy but defensible for a destructive-in-effect cost barrier.

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

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

An output schema exists, so return values need no explanation, and the safety-critical flow is fully described for a 1-parameter tool. What is missing is edge-case behavior — insufficient RM balance, concurrent or repeated unlocks, and whether a preview call has any side effect.

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

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

Schema coverage is 0% and the single parameter is boolean, yet the description fully defines its meaning in both states: false/absent triggers a cost-and-balance preview, true executes only after explicit user consent in the same conversation. That is exactly the semantic the bare schema property 'Confirm' with default false fails to convey.

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 specific verb and resource ('Unlock the Atlas sources') and immediately defines what is being unlocked (paper/research-group sourcing and frontier attribution) plus the duration of 30 days. That scope is clearly distinguishable from account_status or search_atlas, the nearest 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?

Explicitly prescribes a two-step flow: call first without confirm to obtain cost and balance, tell the user, ask; only then call with confirm=true after an explicit yes. It also names the exclusion condition ('ONLY if the user then explicitly answered yes'), leaving nothing to inference.

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