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

No annotations are provided, so the description must carry the behavioral burden. It usefully discloses that activation happens in one browser process, replaces only the isolated context, and requires the current account's tasks to be finished first. It does not clarify permission requirements, whether the replacement is reversible, or what happens to unrecorded state beyond the stated guardrails.

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 compact and front-loaded, with the core action stated first and the safety constraints immediately after. Every sentence contributes useful information without repetition or 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. However, with no annotations and 0% schema description coverage, the description should more fully clarify account_id semantics and the side effects of replacing the isolated context. The stated guardrails are valuable but do not fully close the gaps for this mutation-like account-switching 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 only parameter is account_id, and schema description coverage is 0%. The description does not explain what account_id represents, how it relates to the 'next sequential' account, or any expected format. With low schema coverage, the description should compensate but does not.

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

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

The description states a specific verb and resource: activating the next sequential account within one browser process. It also clarifies scope by saying only the isolated context is replaced, which helps distinguish it from parallel/batch account tools. However, 'next sequential account' is somewhat ambiguous given that a required account_id is supplied, and no sibling tool is named.

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

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

The description gives explicit constraints: never switch across unknown submissions, pending review plans, or verification, and the caller must finish or record the current account's tasks before advancing. This is strong when-to-use and prerequisite guidance, though it does not name a specific alternative tool for other account-switching scenarios.

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 real semantics: it will not stop, re-login, navigate or rebuild existing workers, and conflicts are reported rather than overwritten. That is genuinely useful non-destructive context, but nothing is said about permissions, idempotency on duplicate accounts, or what the call returns.

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

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

The core action and its non-destructive guarantee are front-loaded in the first two sentences, with the conflict and retry rules following. It is compact with little waste, though the final retry sentence reads as a fragment whose referent tool is unclear.

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 no annotations mean the description must cover behavior and return shape, yet it omits what the per-account object must contain, what happens on partial success, and what the 'reported' conflicts look like. For a mutation tool that ingests an opaque array, this is a significant shortfall.

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 four parameters, and the description explains none of them. Critically, 'accounts' is a required array of untyped objects with additionalProperties:true, so the description had to define the per-account fields, and it does not; 'rate', 'state_dir' and 'browser_mode' are likewise unmentioned.

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 'Append' plus the resource 'imported accounts' and the target 'this supervisor' is specific and tells an agent this is an additive registration step, not a full setup. It implicitly separates the tool from setup_learning_accounts/import_accounts, though it never names those siblings, so the differentiation is left to inference.

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?

'Use retry only for terminal failures' points toward retry_parallel_account and gives one usage rule, and 'conflicting existing queues are reported, not replaced' implies when not to expect replacement. But there is no explicit statement of when to choose this over import_accounts, setup_learning_accounts, or start_parallel_learning_batches.

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 safety burden and does disclose something genuinely useful: no network calls and no platform writes, i.e. a pure read-only offline transform. However it says nothing about behavior on malformed/empty HTML, whether it fails or partial-parses, or what it extracts.

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 front-loaded sentence with zero filler; the offline/read-only constraint is stated up front.

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 a one-parameter tool is simple. The remaining gap is provenance of html_source, which an agent must guess at among many capture-related siblings.

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 the single required html_source param, so the description must compensate. It only hints that the value is previously captured exam HTML; it does not specify raw HTML string vs. file path vs. saved capture artifact, which is the main ambiguity 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 concrete verb (parse) and resource (exam HTML) with the scope qualifier 'already captured ... offline', which separates it from live-page siblings like inspect_exam_page. It does not name any sibling explicitly, so it falls short of full 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?

'already captured exam HTML offline' implies the precondition that HTML must have been obtained beforehand (e.g. via capture/observation tools), but no alternative tool is named and no explicit when-not guidance is given. 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?

No annotations are provided, so the description carries the full behavioral burden. It mentions submitting once in the observed popup, but does not explain side effects, permissions, error handling, or what happens on retry, rejection, or repeated confirmation.

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, but for an 8-parameter mutation tool with no schema descriptions, that concision comes at the cost of essential structure and detail.

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 tool is complex: 8 parameters, 5 required, no annotations, and 0% schema description coverage. The one-sentence description gives only the core action and omits parameter meaning, prerequisites, alternatives, and behavioral constraints; an output schema helps with return values but not with calling the tool correctly.

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

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

There are 8 parameters with 0% schema description coverage, and the description does not meaningfully explain required fields like question_token, basis, certain, model_reviewed, or the retry/repeat flags. 'Reviewed' and 'once' loosely gesture at model_reviewed and repeat behavior, but this is far from adequate compensation.

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: select one reviewed radio answer and submit it in the observed video popup. It distinguishes the action from pure observation tools like observe_video_question, though it does not explicitly name sibling alternatives.

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 'observed video popup' and 'reviewed radio answer' imply use after observation and review, and 'submit once' hints at single-submission behavior. However, the description does not explicitly say when to use this instead of observe_video_question or continue_rejected_video_question.

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 meaningful negative behavior: no browser is launched, and a live tab plus controller-supplied DOM are required. It says nothing about prerequisites (must start_course_browser run first?), failure modes if the tab_id is stale, or whether binding steals focus or invalidates the prior session.

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 terse sentences, front-loaded with the action and followed by the key constraint; there is no filler. It is arguably too short given the parameter load, but that gap is scored under completeness rather than here.

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 four-required-parameter binding tool with no annotations cannot be adequately specified in two sentences. The output schema covers return values, but prerequisites, what 'bind' changes about the page/browser state, and the meaning of the inputs are all 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 description coverage is 0% across four required parameters, so the description must compensate and largely does not. "Controller supplies DOM" hints that html_source is the page markup handed in by the caller, but tab_id, browser_id, and page_url have no stated meaning, format, or source.

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: bind (attach to) an existing Edge tab. The second sentence adds scope — the controller supplies DOM and MCP launches nothing. It does not, however, distinguish itself from near-siblings like attach_exam_browser or start_course_browser, leaving the agent to infer which attach variant 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?

"Bind the existing Edge tab" implies the precondition that a tab already exists, and "MCP opens no browser" implicitly contrasts with start_course_browser. But no alternative is named and no explicit when-not condition is given, so the routing is inferred 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?

With no annotations, the description carries the full burden and does well: it explicitly states the read-only boundary (no cookies, no debugger commands, no script execution, no platform writes) and that all UI actions remain with the controller. It omits what the binding itself changes on the MCP side and what happens if the supplied DOM is malformed or the tab is stale.

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 action in the first clause, followed by the mechanism and the safety boundary. Three short sentences with almost no waste; only the redundant restatement of "read-only API" plus the trailing negative list adds slight bulk.

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/mechanism story is covered. Still missing for a tool in a dense exam-browser family: how it relates to attach_exam_session and refresh_exam_browser, and what state exists after binding.

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 three required parameters. The description meaningfully explains html_source's provenance (document.documentElement.outerHTML via the controller's read-only API), which is the least obvious argument, but leaves tab_id and exam_url entirely undefined in both schema and prose.

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

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

"Bind an existing extension-controlled tab using its observed DOM" gives a specific verb and resource, and the qualifier "no CDP or login" narrows the mechanism. It never distinguishes itself from near-identical siblings such as attach_exam_session, attach_course_browser, or refresh_exam_browser, so an agent cannot route on the description alone.

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

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

Usage is implied rather than stated: the tool is for the case where a browser controller already holds a tab and can hand over outerHTML. There is no explicit when-to-use/when-not or pointer to the sibling that should be chosen for a fresh attach, a refresh, or a course (non-exam) page.

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 burden and does well: it discloses the no-launch/no-login/no-navigate boundary, the endpoint-must-already-exist prerequisite, the exactly-one-tab constraint, and the run_id reuse pattern. It omits failure behavior when multiple or zero tabs match.

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, the core action front-loaded, with the negative constraints next and the workflow note last. No filler, though the line wrapping is unnecessary.

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 shape is covered, and the run_id note helps. Still missing is any disambiguation from similarly named attach_* siblings and any parameter format guidance for a tool with 0% schema coverage.

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 parameters, so the description must compensate. It hints that cdp_endpoint is an explicitly configured local endpoint and that exam_url identifies the tab, but gives no format for the endpoint (host:port vs ws://) or how the URL is matched. The gap remains substantial.

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: attach exactly one existing exam tab through a configured local CDP endpoint. But siblings attach_exam_browser and attach_exam_session are near-identical in name, and the description gives no cue distinguishing session attachment from browser attachment.

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

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

Implies the precondition that a browser is already running and exposing the endpoint, and rules out launching, logging in, or navigating. It never names an alternative tool or says when to pick this over attach_exam_browser or attach_course_browser.

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 disclosure burden, and it discloses almost nothing: it does not say whether auditing mutates state, whether it consumes or finalizes preview answers, what permissions or session state it needs, or what 'unverified' means operationally. With zero annotations and a mutation-ambiguous verb, this is a significant gap.

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 and front-loaded, but the brevity comes from ambiguity rather than efficiency; the second clause is cryptic and does not clearly earn its place given how little the first clause establishes.

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, but with four required undocumented parameters, no annotations, and no explanation of the audit's effect on session state, the definition is far short of what an agent 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?

Schema description coverage is 0% and all four parameters (run_id, tab_id, exam_url, html_source) are undocumented in both schema and description. The description adds no meaning whatsoever about what any parameter should contain or how html_source relates to the audit.

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 phrase 'Audit all observed preview answers' gestures at a verb-plus-resource, but 'audit' is undefined and the second clause ('earlier unreviewed questions remain unverified') reads more like a caveat than a scope statement. It is not distinguishable from close siblings such as audit_exam_preview or preview_owned_exam_questions, which use nearly identical vocabulary.

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

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

There is no statement of when to call this versus audit_exam_preview, preview_owned_exam_questions, or review_current_exam_answer. The clause about unreviewed questions hints at a precondition but never says what to do about it or when the tool should be preferred.

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 of behavioral disclosure. It implies a read-only comparison, but does not state whether the operation is read-only, whether it records mismatches, what happens on failure, or whether it has side effects. The existence of an output schema means return structure need not be described, but behavior is still under-specified.

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 filler. It is efficiently sized, though the terms 'full preview' and 'reviewed saved answers' are ambiguous enough that conciseness comes at the expense of 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?

For a one-parameter audit tool with no annotations, the description is too thin. The output schema covers return values, but the definition lacks behavioral context, usage conditions, and parameter meaning needed for an agent to invoke the tool 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 single parameter 'run_id' has no schema-level description. The phrase 'this run's' faintly gestures at run_id, but the description does not explain what a run is, where run_id comes from, or how the preview and saved answers are scoped to that run. The description must compensate for the schema gap and does not.

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

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

The description states a specific verb and resource: 'Compare every answer in the full preview against this run's reviewed saved answers.' This gives a clear idea of an audit/comparison operation. However, it does not differentiate this tool from the similarly named sibling 'audit_exam_browser_preview' or explain what 'full preview' and 'reviewed saved answers' mean in this system.

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 guidance on when to use this tool versus alternatives such as 'audit_exam_browser_preview', 'verify_owned_exam_saved_answer', or 'preview_owned_exam_questions'. It implies an audit scenario but provides no when-to-use, when-not-to-use, or prerequisite 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?

With no annotations, the description must carry the behavioral burden. It discloses an important edge case (empty skips mail) and a delivery prerequisite (shared sender), but says nothing about permissions, reversibility, or how the binding affects existing notification settings. The presence of an output schema reduces the need to explain return values.

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 very short and front-loaded, with no wasted clauses. The phrasing is compact to the point of being slightly cryptic, but it conveys the key behavioral caveat efficiently.

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

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

For a two-parameter mutation tool with no annotations, the description covers the empty-recipient behavior and shared-sender prerequisite. It still omits the relationship to nearby notification configuration tools and the meaning of account_id, leaving the agent to infer important context.

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

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

Schema description coverage is 0% for both parameters. The description clarifies the recipient field by noting that an empty value skips mail, but it leaves account_id unexplained beyond 'this learning account's', so the schema gap is only partially compensated.

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 ('Bind') and target ('this learning account's recipient'), making the purpose of associating a notification email clear. It does not explicitly distinguish this from notification setup siblings such as configure_smtp_sender or configure_smtp_notifications, but the binding action itself is identifiable.

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

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

It gives the useful condition that an empty recipient skips mail and requires a shared sender for delivery, which is a prerequisite. However, it does not say when to choose this tool versus configuring SMTP notifications or sending notification tests, leaving usage implied rather than explicit.

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 behavioral burden. It discloses that the tool optionally writes a JSON file, which is useful, but it does not say whether writing overwrites an existing file, whether the operation requires permissions, how large the log may be, or whether reading the log clears it.

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 filler. Every clause adds information: the return value and the optional file-write 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?

An output schema exists, so return values need not be described. However, for a tool with a file-writing side effect and a parameter at 0% schema coverage, the description omits when to use it, how writing behaves, and what the path should point to.

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 alone gives little meaning to 'path' beyond being an optional string defaulting to empty. The description compensates by explaining that a path causes the log to be written to a JSON file, though it does not clarify whether the path is a file or directory, overwrite behavior, or extension handling.

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: 'Return the full structured stage log.' It is clear what the tool does, but it does not distinguish itself from nearby diagnostic siblings such as browser_status, runtime_health, or implementation_status.

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

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

There is no guidance on when to use this tool versus the many other browser and status tools, nor any preconditions or exclusions. The only implied usage is retrieving a stage log, which the name already suggests.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the returned content (lifecycle state plus recent stage log), which is useful, but does not explicitly state that it is read-only, whether it requires an active owned browser, or any side effects or permission constraints.

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 filler. It efficiently states the resource and the two pieces of information returned.

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 present, the description does not need to explain return values in detail. It adequately covers the tool's scope, though it could improve sibling differentiation by naming when to use this instead of related log/status 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 there are no parameter semantics to explain. The baseline for a zero-parameter tool is 4, and the description does not need to compensate for any schema gaps.

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 (owned browser) and states two concrete outputs: lifecycle state and recent stage log. It is clearer than a bare status tool, though it does not explicitly distinguish itself from nearby log/status siblings such as browser_run_log or owned_window_status.

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 guidance, no mention of alternatives, and no exclusions. The agent can infer this is a status-checking tool, but given the many sibling status and log tools, selection guidance is missing.

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 that the output includes 'explicit mutation boundaries,' which is useful behavioral context for an agent assessing safety. It does not explicitly state that the tool itself is read-only or side-effect-free, nor mention any auth requirements, leaving a gap.

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. Every word contributes to the stated purpose.

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. For a zero-parameter meta tool, however, it still fails to scope what 'supported operations' means (whole server? current account? tool set?) and omits any safety statement, leaving the agent to guess.

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 does not waste space on parameters that do not exist.

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 verb ('Describe') and an object ('supported operations and explicit mutation boundaries'), which is more than a tautology. However, it never says what these operations belong to (this server, the tool suite, the account?) and gives no hint of how it differs from adjacent introspection tools like runtime_health or implementation_status.

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 versus alternatives such as runtime_health or implementation_status, nor any stated preconditions. The agent must infer that this is a discovery/introspection tool from the name 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?

No annotations are provided, so the description must carry behavioral disclosure. It usefully says no login or browser is required, but it does not explain lease duration, exclusivity, idempotency, or what state is changed when the worker is registered.

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?

Single sentence, front-loaded with the verb and key constraint, with no filler. It is appropriately sized for a zero-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?

The output schema can explain return values and the empty input schema means invocation is trivial, but the description still leaves selection among many account/browser siblings ambiguous. It is minimally adequate but not complete for an agent navigating this large toolset.

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

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

With zero parameters, the schema has no semantic burden and the baseline is 4. The description adds no parameter detail, which is appropriate because there are none.

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

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

The description names a specific action ('Register') and resource ('current worker's OS lease') and adds a constraint that separates it from login/browser-based siblings. 'OS lease' is somewhat jargon-heavy, but the purpose is still identifiable.

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 hints at usage by saying no login or browser is needed, but never states when to choose this over login_accounts, open_account_browser, or start_account_workspace. There are no explicit exclusions or preconditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that the tool avoids fabricating navigation URLs; it does not say whether the operation is read-only, what it returns, what errors may occur, or whether it requires prior page 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?

The description is a single front-loaded sentence with no wasted words. It is very terse and somewhat fragmentary, but that is a content gap rather than structural verbosity.

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 output schema exists, so return-value details need not be in the description. For a simple one-parameter classifier, the description covers the core purpose and an anti-fabrication constraint, but it leaves usage context and parameter meaning under-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?

Schema description coverage is 0% for the single page_url parameter. The description mentions portal hosts/paths but does not explain that page_url is the input, what URL format is expected, or how the host/path should be supplied.

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

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

The description states a specific verb/resource pair: classify exact portal hosts/paths. The anti-fabrication constraint also signals this is a classification tool rather than a navigation tool, which helps distinguish it from sibling tools like goto_course_page. It does not name a sibling alternative, so a 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?

The phrase 'without fabricating navigation URLs' implies a constraint on how results should be used, but there is no explicit when-to-use, when-not-to-use, or alternative-tool guidance among the many sibling navigation and inspection tools. The agent must infer the usage 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 are absent, so the description must fully convey behavior. It mentions preserving exam/write guards but does not explain what that entails, what side effects occur, or what happens if guards are not preserved. The description is too vague to inform safe invocation.

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. However, the phrase 'only after preserving exam/write guards' is somewhat cryptic and could benefit from clarification.

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?

Even with zero parameters and an output schema, the description is incomplete because it does not clarify what 'pause this account' means operationally, what 'exam/write guards' are, or under what conditions the tool should be used. More context is needed 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?

The tool has zero parameters, so the baseline score is 4. The description correctly provides no parameter details, as there are none.

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 specific actions: 'pause this account' and 'close its browser', with a condition about preserving exam/write guards. This distinguishes it from siblings like start_account_workspace or return_account_to_background, but does not explicitly name alternatives.

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 explicit guidance on when to use this tool versus alternatives such as return_account_to_background or stop_course_browser. The phrase 'only after preserving exam/write guards' implies a prerequisite but not a usage 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?

With no annotations, the description carries the burden and does well: it discloses that the process-owned browser is reused across accounts, that a mode change closes the old browser FIRST, and that no second concurrent instance is ever opened. It omits what happens if the call is made mid-login or whether the batch must be restarted.

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?

Short and front-loaded with the most important constraint (one mode, chosen before login) followed by mode definitions and side effects. The telegraphic fragments ('headless: no window.') are efficient, though the line breaks make it slightly less scannable than a single structured sentence.

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 described; what remains — scope (whole batch), timing (before login), and lifecycle side effects — is covered. Missing only the failure mode when the precondition is violated.

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 carry the single parameter — and it does, defining both enum members (headless = no window; minimized = visible-capable independent Edge starting minimized). Only the default/omitted behavior is left to the schema.

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

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

The description makes clear this sets the browser display mode for the whole account batch, and enumerates the two modes with brief definitions. It doesn't differentiate itself from nearby window tools such as minimize_owned_window or use_window_viewport, so an agent must infer the boundary.

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?

Explicit timing constraint: 'Choose ONE mode for the entire account batch BEFORE login' — that is real usage guidance about when to call it. It does not name alternatives or say what happens if invoked after login, so it stops short of a full when/when-not statement.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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 discloses a lot: auth must use an authorization code not the QQ password, empty fields disable notifications entirely, recipient defaults to sender, and secrets stay in process memory and never appear in responses. It does not say whether a call overwrites existing configuration or whether configuration is per-account isolated from the global sender settings.

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

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

Four tight sentences with zero filler; the critical authentication warning is front-loaded immediately after the purpose statement, and the security note is appropriately last.

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 description covers auth method, defaults, scope limits, and secret handling. The remaining gap is the meaning of account_id and the enabled flag relative to the 'empty fields' rule, which an agent would want to know before calling.

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 every parameter's meaning must come from the description; it explains smtp_auth_code (authorization code, not password), recipient_email (defaults to sender), and the empty-field semantics that apply to all string params. It leaves account_id and the enabled boolean entirely unaddressed, so compensation is 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?

States the specific resource and scope: per-account QQ SMTP notification configuration. The word 'configure' is implied by the tool name and the paragraph clearly delimits scope ('Notification permission covers only verification reminders and actual verification QR PNGs'). It does not explicitly differentiate itself from the sibling configure_smtp_sender or bind_account_notification_email.

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?

'Optional' signals this is a setup step, and the note that all-empty fields skip notifications implies the caller may use it to disable or to configure partially. However, there is no explicit statement of when to prefer this tool over configure_smtp_sender, send_notification_test, or bind_account_notification_email, nor any prerequisites beyond needing an authorization code.

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 burden and does add real context: the QQ ordinary password is not used, the authorization code lives only in memory, and no test email fires. It omits what happens on reconfigure (overwrite? merge?), what enabled=false disables, and what privileges are needed.

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 scoping rule, followed by three short sentences that each add a distinct fact. No filler, though the telegraphic fragments read as notes rather than a structured description.

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. But this is a configuration mutation with zero annotations and zero schema descriptions, and key questions — overwrite semantics, effect of enabled=false, handling of blank defaults — remain unanswered.

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% across three parameters, so the description must compensate. It meaningfully clarifies smtp_auth_code (an SMTP authorization code, not the account password, held in memory) and implies sender_email's role, but says nothing about 'enabled' or how the empty-string defaults behave.

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+resource ('configure ... sender') and pins the scope precisely: ONE shared QQ sender for all learning accounts, with per-account recipients handled elsewhere. This cleanly separates it from recipient-binding breadth without naming the sibling tool 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?

Gives clear context for when to call it — setting up the shared SMTP identity — and two implicit exclusions: per-account recipients are a different operation, and no test email is sent here (pointing usage of send_notification_test elsewhere). It stops short of naming those alternative tools directly.

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 behavioral burden. It does disclose the key non-obvious trait ('This does not save answers'), which tells the agent this is a read-only verification, but it says nothing about side effects on the run/tab, failure conditions, or what happens if the readback mismatches. Adequate but thin 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?

Three short lines: purpose first, then the rationale/precondition, then the explicit non-behavior. Front-loaded and free of filler, though the phrasing is telegraphic enough that some sentences need re-reading.

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 five required, wholly undocumented parameters and no annotations, the description leaves the agent guessing how run_id/plan_id/tab_id relate to the browser session. The output schema covers return values, but the calling contract is incomplete given the dense sibling set it must be distinguished from.

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 all five parameters are required and undocumented. The description only obliquely hints at html_source ('must obtain HTML after navigation/reload or from the full preview') and says nothing about run_id, tab_id, plan_id, or exam_url, so it 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?

States a specific verb (verify) and a specific object (the original question's saved answer) plus the evidence source (independent navigation DOM readback). It is clear what the tool does, but it never distinguishes itself from the near-identical sibling verify_owned_exam_saved_answer, and the jargon ('controller', 'DOM readback') assumes domain fluency.

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?

'In-place selected state alone is insufficient: controller must obtain HTML after navigation/reload or from the full preview' gives a concrete precondition for calling it and rules out a tempting wrong usage. It stops short of naming an alternative tool or stating the pipeline order relative to save_owned_exam_answer / verify_owned_exam_saved_answer.

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 does well: it discloses that grading is retained unchanged, no answer is resubmitted, completion is neither sought nor claimed, and no automatic dismissal policy is created. Still missing are idempotency/repeat behavior and any permission or failure-mode 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?

Two tight sentences with the core behavior front-loaded and no filler. The phrasing is dense and slightly jargony ('continue callback', 'seeks or claims completion'), which costs a little immediate comprehensibility.

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?

Behavioral narration is solid and an output schema exists, so return values need not be explained. However, a three-parameter mutation-like tool with zero annotation coverage and zero schema descriptions leaves the agent guessing about two boolean flags — a significant gap in what is otherwise a well-described 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 three parameters, so the description is the only source, and it says nothing about question_token, user_requested, or repeat_confirmed. 'Explicit user-requested' and 'one-time operation' faintly gesture at the two booleans, but an agent cannot determine what question_token is or when to set repeat_confirmed.

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

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

States a specific action (explicit dismissal of a rejected video question) and the mechanism used (the player's existing continue callback). The second sentence implicitly distinguishes it from answer_video_question by asserting it never resubmits an answer, though no sibling is named directly.

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?

'Explicit user-requested' and 'one-time operation' imply a precondition (only call on explicit user request, only once), but the guidance is embedded rather than stated as a rule. No alternative is named — answer_video_question, observe_video_question, and defer_current_learning_task are never referenced, so an agent must infer what to do instead of dismissing.

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 full behavioral burden. It hints at muted UI on play, local watching, and a no-seek restriction, but omits state changes, permissions, and the effects of the minimize/bring_to_front flags, and the jargon obscures rather than clarifies behavior.

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

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

The text is short (two sentences) with no obvious filler, but it is dense with unexplained jargon and front-loads a vague verb. Brevity is achieved at the cost of clarity.

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

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

With 5 undocumented parameters, 0% schema coverage, and no annotations, the description leaves most invocation details unexplained. The output schema covers return values, but the input side remains inadequate for correct use.

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 5 parameters, so the description must compensate. It only touches rate ("rate=1 for normal speed") and loosely implies action/minimize; bring_to_front and allow_completed_replay are entirely undocumented, and the action enum is never revealed.

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 "Inspect media" but then drifts into jargon like "applies inspected 1.25 adapter," which does not clearly state what the tool does. It never defines the tool as a video-playback controller nor distinguishes it from siblings such as set_owned_video_rate or monitor_owned_video.

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

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

It gives constraints ("Never seek", "Use rate=1 for normal speed") but no guidance on when to use this tool versus alternatives. With siblings like set_owned_video_rate and monitor_owned_video present, 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 must carry the full behavioral burden. It usefully discloses that the task is retained unfinished and never submitted, but it does not explain side effects, state changes, prerequisites, idempotency, or what 'defer' means operationally.

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 definition is a single compact sentence with no wasted text. It is not ideally front-loaded because 'Explicit host decision' is vague, but it is appropriately sized and structured.

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 gives only the barest behavioral clue ('retain unfinished task, never submit') for a tool with no annotations, no output schema, and three undocumented required parameters. It is not complete enough for an agent to call it confidently without inference.

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?

All three required parameters have 0% schema description coverage, and the description adds no information about issue_id, reason, or evidence_url. The parameter names alone must carry all semantics, which is insufficient.

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 implies deferral by saying to retain the unfinished task and never submit, but it does not explicitly state the core action or clearly distinguish the tool from task-related siblings such as recover_current_task or route_learning_task. The phrase 'Explicit host decision for a new evidenced issue' is vague and requires interpretation.

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 implies a usage condition ('new evidenced issue') and an exclusion ('never submit'), but does not name alternatives or explain when to choose this over recover_current_task, route_learning_task, or inspect_current_task. The guidance is present but minimal.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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 only says 'click' — it doesn't say a navigation occurs, what happens if zero or multiple exams are visible, or whether the action is reversible. The word 'uniquely' hints at a precondition (exactly one matching exam) but never states the failure behavior.

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

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

A single short sentence with no padding, which is structurally fine, but the terseness comes at the cost of clarity ('uniquely visible named exam') rather than through efficient precision.

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, but for a stateful browser-click tool in a large exam workflow the description omits required page state, the meaning of the sole argument, and post-click behavior. It is not enough for an agent to call this confidently without inspecting the schema or code.

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 parameter with 0% schema description coverage, so the description must explain course_name — but it never mentions it. Worse, it says 'named exam' where the parameter is a course name, muddying rather than clarifying the mapping.

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 ('Click') and rough target (a named exam in the owned exam list) are stated, but the phrasing 'uniquely visible named exam' is jargon that leaves unclear whether the name refers to the exam or the required course_name argument. It also doesn't differentiate itself from nearby siblings such as open_course_exam or inspect_exam_page.

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 this tool should be chosen over open_course_exam, inspect_exam_page, or the browser/exam-loop families. There are no stated prerequisites (e.g., that the owned exam list must already be displayed) and no exclusion 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?

With no annotations, the description carries the burden, and it does disclose one genuinely important trait: returning alerts does not deliver notifications, so the call has no messaging side effect. It does not state whether the evaluation itself mutates state, what the result contains, or how now_iso/threshold_hours affect 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 no filler, but the first is wasted on a vague, mismatched phrase. The more useful caveat about notifications is buried second rather than 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?

An output schema exists, so return values need not be described, but with no annotations and zero parameter documentation the description leaves the agent without the semantics of the threshold or reference time needed to call it correctly.

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

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

Schema description coverage is 0% across three parameters, so the description must compensate and does not – items, now_iso, and threshold_hours are never explained. "Observed inventory" only loosely hints that items is the inventory payload, leaving defaults and formats 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?

"Evaluate observed inventory" uses a generic verb with a resource that does not match the tool name at all – nothing in the description mentions homework, deadlines, or thresholds. An agent reading only this text could not tell what is being evaluated nor distinguish it from siblings like export_deadlines_ics.

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 call it, what prerequisites exist, or which sibling to use instead. The second sentence implies a downstream step (sending notifications) still needs a separate tool, which is minimal usage context but not guidance on 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?

No annotations exist, so the description carries the full behavioral burden, yet it discloses only that the tool 'reads'. It does not confirm read-only safety, clarify what 'verified' or 'handoff mode' entails, or note any preconditions on the run state. An output schema exists, so return shape is partly covered, but the operation's behavior remains opaque.

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 tightly-scoped sentence with no filler, and the object of the read is front-loaded. It is efficient, though its brevity borders on under-specification rather than crispness.

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 embedded among dozens of exam-browser siblings with no annotations and an undocumented parameter, the description is far too thin. The output schema offsets the need to describe return values, but nothing explains the run_id's role, the mode's meaning, or invocation context, leaving the definition incomplete.

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 (run_id) is never mentioned in the description. Although run_id is a fairly self-evident name, the description provides no meaning about what run it identifies or whether it must match a live session. With coverage this low, the description was expected to compensate and does not.

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

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

The description states a verb (Read) and a resource (verified draft count) for a specific mode (browser-controller handoff). However, 'actual verified draft count' and 'handoff mode' are jargon-laden, and it does nothing to distinguish this from near-neighbor siblings like exam_loop_progress, confirm_exam_browser_draft, or prepare_exam_browser_step. An agent can guess it reads a count but cannot confidently place it among the many exam-browser 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 statement of when to use this tool, when not to, or which sibling it replaces. Given the dense cluster of exam_browser_* / owned_exam_* tools, the absence of any routing guidance is a real gap. The agent is left to infer selection entirely 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?

With no annotations, the description carries the full burden, and it does disclose the key trait: this is a pure read that neither opens nor mutates a browser page. Beyond that it says nothing about whether a run must be active, what happens with an unknown run_id, or any rate/session constraints.

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 short, front-loaded sentence with no filler and the read-only guarantee stated up front. Its brevity is efficient, though it brushes against under-specification given the undefined term 'loop'.

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, but the definition still leaves the required run_id undocumented and provides no basis for choosing between this and the several overlapping progress/read siblings. For a tool in a crowded exam-progress namespace, that is a substantial gap.

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

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

Schema coverage is 0% and the single required parameter run_id has no description in either schema or description. The description could have clarified what a run_id identifies and where to obtain it, but adds no meaning beyond the parameter name.

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' and object 'loop progress' are stated, but 'loop' is undefined jargon and the definition never says which loop (exam question loop?) or what progress means. It also fails to distinguish itself from close siblings like exam_browser_progress and get_exam_progress, which sound like they read similar state.

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 the negative constraint 'without opening or changing any browser page', which hints at a lightweight read path. There is no stated condition for choosing this over exam_browser_progress or get_exam_progress, and no prerequisites or preconditions for run_id.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says the output is an ICS file but does not disclose where the file is written, whether it overwrites an existing file, what permissions are needed, or what the return value 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, front-loaded sentence with no wasted words. It conveys the core action, input shape, and output format efficiently.

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 output schema exists, so return values need not be explained. However, with no annotations, the description is thin on file-writing behavior and the meaning of 'reviewed' reminders. It is minimally adequate for a simple export tool but leaves 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%, but the description clarifies the required 'items' parameter as containing objects with 'title' and 'due_at' in ISO-8601 format, which adds significant meaning beyond the bare array-of-objects schema. The optional 'filename' parameter is not described, though its default is self-explanatory 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 (Export) and resource (reviewed reminders) and specifies the output format (ICS file). It does not explicitly differentiate from any sibling tool, but the purpose is immediately 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?

The phrase 'reviewed reminders' implies a precondition and intended use case, but the description does not explicitly state when to use this tool 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 burden and does reasonably well: it declares the operation read-only, scopes it to the owned page, and explains the exact selection rule (nodes with id starting 'cur', plus anchors to study/knowledge pages). It omits failure behavior when no owned page is attached and how the limit truncates results.

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, with the core action front-loaded in the first line and the return semantics following. No redundant restatement of the name or padding.

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 the selection criteria well. However, for a browser-dependent tool with no annotations, it leaves out the precondition (an attached/owned page session) and the meaning of the one parameter, which are needed to invoke it correctly.

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

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

Schema coverage is 0% and the single parameter 'limit' is never mentioned in the description, so an agent gets no guidance on what limit counts (links, nodes, results) or what happens at the default of 60. The description must compensate for the empty schema and 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 and resource ('Read chapter/task links') plus the mechanism ('read-only DOM query') and what it returns (absolute hrefs for chapter nodes). This is clearly distinguishable from navigation tools like open_course_chapter, though it doesn't name any 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 phrase 'so the caller can navigate to an explicit chapter without guessing URL shapes' implies a use case (resolving chapter URLs before navigating), but it never states when to prefer this over open_course_chapter, inspect_owned_page, or goto_course_page, and gives no exclusions or prerequisites such as requiring an attached owned page.

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 provided, the description carries the full behavioral burden. It does disclose one useful exclusion rule — single-question pages do not count as whole-paper progress — but it omits required state, side effects, and what the snapshot represents.

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 very short and contains no filler, but it is under-specified rather than efficiently concise. It front-loads the counting rule but leaves the core action implicit.

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 a nested required parameter, no annotations, and an output schema, the description is incomplete. The output schema can cover return values, but the description still fails to explain the snapshot input, the progress calculation, or when this tool should be selected over siblings.

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 sole required parameter, 'snapshot', is a nested object with additionalProperties true and 0% schema description coverage. The description never mentions the parameter or explains what must be passed, so it does not compensate for the schema 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 implies that progress is based on counting observed saved answers, but it never explicitly states that the tool returns exam progress or what the returned progress represents. It also does not distinguish this tool from sibling progress tools such as exam_loop_progress or exam_browser_progress.

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

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

There is no guidance on when to use this tool versus the many related exam-progress and capture-status tools. The single caveat about single-question pages is a counting rule, not an alternative-selection guideline.

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 does add real behavioral context: the data is local ('locally archived'), the read is exhaustive ('complete'), and no answer-key correction/inference is performed. It omits pagination, ordering, and what happens when the archive is empty.

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

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

One sentence with the read verb front-loaded and no filler, though the phrase 'mistakes and rejected combinations' spends words on jargon instead of a precise noun.

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 shape need not be described. However, for a tool sitting among dozens of exam/review readers, the description lacks the scope and filter semantics an agent needs to call it correctly.

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

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

The single parameter question_contains has 0% schema description coverage, so the description carries the full burden — yet it never mentions filtering, substring matching, or that an empty default returns everything. The schema-only baseline of 4 is not earned here.

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' and the scope 'locally archived' are clear, but 'mistakes and rejected combinations' is domain jargon that never resolves into a concrete resource (exam questions? video questions?). It also fails to distinguish itself from the many sibling readers such as preview_owned_exam_questions and owned_exam_review_inventory.

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 tool, when not to, or which sibling to prefer despite a dense cluster of overlapping question-reading tools. The only guidance is a negative qualifier ('without inferring corrected keys'), which constrains output rather than selecting the 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?

With no annotations, the description carries the full behavioral burden and does disclose bounded retries and per-attempt logging, which is useful. However, it does not state failure behavior, idempotency, permissions, or what 'owned' means in this 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 a single front-loaded sentence with no filler. Every phrase adds either the action or a behavioral trait.

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 the retry/logging note adds some context. Still, for a navigation tool with no annotations and zero schema descriptions, the description leaves key details about page_url expectations and failure handling unstated.

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, but it only indirectly links retries to the attempts parameter and does not explain the expected format or constraints of page_url. The default attempts value is visible in schema but its semantics are only thinly supported.

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: navigate an owned page, with bounded retries and per-attempt logging. This is more than a tautology and gives the core verb+resource. However, it does not distinguish this tool from nearby navigation siblings such as inspect_owned_page, observe_course_browser, or open_course_chapter, 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?

There is no explicit guidance on when to use this tool versus the many sibling navigation and inspection tools. The phrase 'owned page' implies a context, but no alternatives, prerequisites, or exclusions 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?

With no annotations, the description carries the full burden. It usefully discloses that reading requires no credentials or network, implying a safe, local, auth-free operation, but it says nothing about return format, freshness, or preconditions.

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 filler. It is efficient, though its brevity leaves behavioral and usage details underspecified rather than adding structural 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?

For a zero-parameter read-only status tool, the description covers the core idea and the no-credentials/no-network constraint. However, without annotations or an output schema, it should say more about what 'source identity' and 'current process' mean and what the caller receives.

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 there is no parameter semantics burden. The baseline score of 4 applies because the description does not need to document 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?

The description states a specific verb and resource: 'Read adapter source identity and current process.' It is clear enough to distinguish from refresh_*_implementation siblings, though it does not explicitly contrast with runtime_health, capabilities, or other status 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?

No guidance is given about when to use this tool versus alternatives such as runtime_health, capabilities, or refresh_inventory_implementation. The agent must infer usage from the tool name and sibling list 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?

With no annotations, the description carries the full burden and does contribute: required credentials, the all-or-nothing coupling of the three mail fields, the legacy per-account sender path, and the 'never echo secrets' safety rule. But it is silent on the most consequential behavior — what `replace` does to existing stored accounts, whether the import merges or overwrites, and whether the operation is reversible. For a mutation tool with zero annotation coverage that is a material omission.

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

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

Front-loads the required fields and uses labeled groupings ('Required:', 'Optional TOGETHER:'), which aids scanning. But the sentence 'Without a shared sender that binding awaits setup' is ambiguous about whether that is a soft deferral or an error, and the closing instruction about asking the user mixes agent workflow policy into a tool definition rather than describing the 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 explained, and the description does a good job on the per-record fields and mail configuration. Given that this is a bulk mutation with no annotations and a fully undocumented schema, the omission of `replace` semantics (overwrite vs merge, effect on existing accounts) leaves the definition short of what an agent needs to invoke it safely.

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 accounts array is free-form (additionalProperties: string), so the description's enumeration of account_id, username, password, smtp_email, smtp_auth_code, notify_email is genuinely load-bearing and compensates for the opaque item schema. The second parameter, `replace`, is never mentioned at all, leaving the top-level boolean entirely 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?

States a specific verb+resource: import learning accounts into memory, plus a qualifier about optional per-account SMTP notices. An agent can tell it is a bulk-load operation rather than a login or update. It never differentiates itself from near-siblings like setup_learning_accounts, login_accounts, or add_parallel_learning_accounts, which is the missing step for 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?

Gives real conditional guidance inside the mail sub-problem: 'Prefer configure_smtp_sender ONCE, then each record supplies only notify_email' and 'Omit all mail fields to skip email', which explicitly names an alternative tool and its selection condition. However, there is no guidance on when to choose import_accounts over the sibling setup/login/credential tools, so the core routing question is left implicit.

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 disclosure burden. 'Inspect' implies a read, but the description never confirms read-only behavior, does not say whether an attached course browser session is required (several siblings such as attach_course_browser/start_course_browser suggest it might be), and says nothing about side effects, latency, or rate limits.

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

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

A single front-loaded sentence with no filler and the key qualifier ('enrolled', 'user-selected') placed early. It is efficient, though efficiency here partly reflects under-specification 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 two undocumented parameters, no annotations, and a large, confusingly similar sibling set, the description does too little. An output schema exists so return values need not be explained, but prerequisites (enrolled course, account selection, browser attachment) and the relationship to the score/exam page inspectors are 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 description coverage is 0% for both parameters. The description only loosely maps to course_url ('user-selected enrolled course URL') and gives no explanation at all for account_id — which account identifier format, and whether it must be claimed/active, is left entirely 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?

States a specific verb (inspect), resource (a course URL), and the output it is looking for (task and deadline hints). This differentiates it reasonably from siblings like inspect_course_score_page and inspect_exam_page, which target other page types, though the description never names those alternatives directly.

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 'user-selected enrolled course URL' hints at a prerequisite, but there is no explicit when-to-use, when-not-to-use, or routing advice among the many sibling inspect_* tools. An agent must guess whether to call this, list_courses, or inspect_course_score_page first.

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

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

With no annotations, the description carries the full burden; it does disclose non-navigation and non-submission, which is the most important safety trait here. It says nothing about whether a live browser session must already be attached, what 'observed links' means operationally (harvested hrefs? filtered?), or what happens on a page it cannot 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?

One front-loaded sentence with the safety constraint attached immediately; nothing is redundant. 'Observed links' is the one phrase that costs clarity without earning its place.

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

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

An output schema exists so return values need not be described, but with 0% parameter coverage and a mutation-adjacent browser tool that has no annotations, the description should at minimum explain the page_url default and the session prerequisite. As written it is too thin for a 3-parameter browser-inspection 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?

Zero of the three parameters have schema descriptions, and the description adds no meaning for account_id or course_url beyond echoing 'enrolled-course'. The optional page_url with an empty-string default is completely unexplained — an agent cannot tell whether omitting it means 'use course landing page' or 'inspect all pages'.

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?

Specific verb (read) plus resource (enrolled-course score pages), and it names a secondary artifact (observed links). It does not distinguish itself from close siblings like inspect_owned_page, inspect_course, or inspect_exam_page, so scope overlap remains for an agent to guess at.

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 'never navigate or submit' sets a hard boundary and implies this is a passive inspection step, but it never says when to prefer this over inspect_owned_page / inspect_exam_page or what precondition (attached browser, logged-in account) must hold. Usage is implied rather than guided.

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 behavioral burden, and it discloses almost nothing: no side effects, no permission/auth requirements, no statement of what is returned for each distinguished state. 'Fresh' vaguely implies a non-cached read but nothing about mutation 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?

A single short sentence with no filler, front-loading the inspection action and then the distinguishing states. The compressed adjectives ('compact fresh') are slightly jargon-y but occupy minimal 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 read tool with no output schema, the description at least enumerates the categorical states an agent can expect to see, which partially substitutes for return-value documentation. It still omits what the inspection does in ambiguous cases and how to act on each result, leaving gaps for a no-annotation 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 tool takes zero parameters, so there is nothing for the description to explain beyond what the empty schema already conveys. 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 description names an inspection of the 'current task' and enumerates the states it distinguishes (quiz, completed video, player, loading), which is more specific than the bare tool name. However, it never states what class of object the 'current task' is or how this differs from siblings like recover_current_task, route_learning_task, or defer_current_learning_task.

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

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

Only the qualifiers 'compact' and 'fresh' hint at usage, implying a lightweight re-check of current page state. There is no statement of when to prefer this over sibling inspection tools (inspect_owned_page, recover_current_task) or when not 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?

With no annotations, the description does add meaningful behavioral guarantees: no submission occurs, preview or unsupported structures never establish 100%, and no cache entry is promoted based on model conclusions or partial credit. However, it does not disclose permissions, error/failure behavior, or what happens when the HTML is rejected as unsupported. The disclosed traits are relevant but incomplete for carrying the full behavioral burden.

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 is front-loaded in the first sentence, and the later sentences carry behavioral constraints rather than filler. However, phrases like 'never establish 100%' and 'promote any cache entry' are jargon-heavy and lack enough context to be immediately actionable. The description is short but somewhat fragmented.

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 tool takes one required string and has an output schema, so the description does not need to explain return values. It provides key no-submission/no-cache-promotion guarantees but omits routing guidance against several closely related grading and exam inspection siblings. For an inspection tool in a dense sibling set, that leaves a meaningful gap.

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

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

Schema description coverage is 0% for the single html_source parameter, so the description must compensate. It says the HTML is 'actual grading-page HTML supplied by the browser controller,' which clarifies origin and expected content, but gives no format requirements, size limits, or error behavior for the input. That is only marginal compensation for a completely undocumented 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 first sentence states a specific verb and resource: read actual grading-page HTML supplied by the browser controller. It explicitly notes 'with no submission,' which separates it from submission-oriented siblings. It does not name the closest read alternatives (e.g., read_owned_exam_grading, inspect_exam_page), so the sibling differentiation is only partial.

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 constraints ('preview pages or incomplete/unsupported grading structures never establish 100%') but never states when an agent should call this tool instead of read_owned_exam_grading, inspect_exam_page, or analyze_exam_html. There are no explicit when-to-use or when-not-to-use conditions, and no prerequisites beyond the implied browser-controller source.

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 two useful traits: JS is not executed (so dynamically rendered content will be absent) and the GET may mutate exam access state. It stops short of saying what that refresh affects (timer, session, progress) or whether auth/account state is required, so the mutation risk is named but not characterized.

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 waste, key constraint front-loaded. The trailing clause "may refresh exam access state" is vague enough that it hints rather than informs, keeping it below a 5.

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, but for a read tool sitting in a very dense exam/browser sibling cluster with no annotations and undocumented parameters, the description should say how it differs from the other page-inspection tools. As written the agent lacks the context to place it correctly.

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

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

Schema description coverage is 0% and both required parameters (account_id, exam_url) are bare strings with only titles. The description never mentions either parameter, so it does not compensate for the coverage gap — e.g., what form exam_url takes, or why account_id is required to read a URL.

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 an existing exam page") and adds a negative scope ("without running JS or saving answers") that separates it from saving/answering siblings. It does not name any sibling explicitly, so a 4 rather than 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 signal is the embedded exclusion (no JS, no answer saving); there is no statement of when to choose this over analyze_exam_html, inspect_owned_page, or inspect_exam_grading_html. The agent must infer the selection rule from the tool name 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?

With no annotations, the description carries the full burden and does meaningful work: it discloses that only the empty-list structure is verified and that writes on nonempty assignments are out of scope until an adapter exists. That is safety-relevant context. It stops short of stating read-only status explicitly or describing side effects/return 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?

It is short and front-loads the action before the constraint. The remaining sentences are terse but each carries a real constraint; the phrasing is slightly cryptic but not padded.

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. But with four required, undocumented parameters and no annotations, the description should say more about where browser_id/tab_id/page_url come from. Scope and safety are covered; invocation mechanics are not.

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 description adds almost nothing: only 'fresh homework-list DOM' loosely maps to html_source, while browser_id, tab_id, and page_url are left entirely undocumented. 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 names a specific verb and resource ('Inspect a fresh homework-list DOM') and explicitly separates itself from chapter/exam submit tools in the sibling list. It is not tautological, but it does not clarify the distinction from other inspect-type siblings such as inspect_owned_page or observe_course_browser.

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?

'Never reuse chapter/exam submit tools' and the note that nonempty assignments need their own observed adapter convey scope boundaries. However, there is no explicit statement of when to choose this tool over the many other inspection tools, so usage must be inferred from the 'fresh homework-list' framing.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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

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

No annotations are provided, so the description carries the full behavioral burden. "Read" implies it is non-mutating, and the optional screenshot implies a write to disk, but the description never states prerequisites (e.g. an attached browser/window), what the screenshot side effect actually is, or how the paths interact.

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 wasted clauses, which is structurally good. But the brevity comes at the cost of clarity — the compression leaves key nouns ("owned page", "task markers") undefined.

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. But with no annotations and four undocumented parameters, the definition does not give an agent enough to call the tool correctly — it cannot tell what each path argument means or what verification_only toggles.

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 all four parameters must be explained by the description. It only alludes to one (screenshot_path); quiz_html_path, video_html_path, and especially verification_only are entirely opaque, and it is unclear whether the html paths are inputs to parse or outputs to write.

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?

"Read the real owned page, cards, frame text, and task markers" gives a verb and a list of artifacts, so the general intent is graspable. However, "owned page" is undefined and nothing distinguishes this from close siblings such as read_owned_browser_view, inspect_current_task, or inspect_course_score_page.

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 tool, when not to, or which sibling to prefer for page inspection. The only contextual hint is the optional screenshot clause, which describes a capability rather than a usage condition.

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 the behavioral burden. It usefully discloses passive, non-mutating observation and names the observed response stream, but omits permissions, side effects of flags like refresh_task_metadata, or rate/refresh 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?

Single front-loaded sentence with no repetition or filler. It is efficient, though its brevity leaves gaps handled under completeness rather than 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?

An output schema exists, but with no annotations and 0% parameter coverage the description should explain the three flags and the interaction model. It only provides the passive/non-mutating stance and leaves an agent without guidance on what the booleans change.

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 three boolean parameters, and the description does not explain read_task_inventory, capture_media_events, or refresh_task_metadata. It adds no meaning beyond the bare schema.

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

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

States a specific action (passively observe) and target (actual player report responses), and clarifies that it never sends or alters reports. It does not explicitly differentiate from video-related siblings such as monitor_owned_video or control_owned_video, so it is clear but not sibling-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?

Implies the tool is for passive inspection and excludes sending or altering reports, which provides a when-not boundary. However, it does not name alternatives or say when to use this rather than monitor_owned_video or control_owned_video.

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 does disclose a meaningful behavioral trait: this is a cached, local-only read that triggers no network or model activity. However, it does not state read-only semantics explicitly, data freshness, or what 'compact state' contains, leaving gaps for a status 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?

One short, front-loaded sentence with no wasted words. It is efficient, though its terseness borders on cryptic and could have added a few words of purpose without becoming 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?

In a large batch/exam/learning ecosystem, this zero-param status tool needs to clarify which batch state it reports and how it relates to start_learning_batch, stop_learning_batch, resume_learning_batch, and parallel_learning_status. It also lacks an output schema, so the description should say more about what 'compact state' includes.

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 are no argument semantics to explain. The schema is empty and fully described; the description adds no parameter confusion, matching the baseline for a zero-param 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?

The description is a constraint fragment ('Cached compact state only; no page reads, HTTP calls or model API') rather than a purpose statement. It never says it returns the status of a learning batch; an agent must infer the action from the tool name alone.

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 implicitly signals a cheap cached read by excluding page reads, HTTP calls and model API use, but gives no when-to-use guidance, no exclusions, and does not name alternatives such as parallel_learning_status or inspect_current_task.

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 behavioral burden. It usefully discloses that returned state is redacted and excludes credentials and cookies, which is a meaningful safety detail. It does not mention read-only semantics, authentication requirements, ordering, or rate limits, so transparency is 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?

The description is a single, front-loaded sentence with no wasted words. It states the action and the key redaction constraint immediately.

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 tool is simple, has no parameters, and has an output schema, so the description need not explain return structure. It covers the main behavioral caveat—redaction—but leaves some ambiguity about scope, such as whether all accounts or only active accounts are listed.

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 there are no parameter semantics to explain. The baseline score for a parameterless 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 description gives a clear verb and resource: 'List redacted account state.' It also distinguishes itself from credential-focused siblings by stating that credentials and cookies are not returned. However, it does not explicitly differentiate from other account-related listing or inspection 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 guidance on when to use this tool versus alternatives such as login_accounts, import_accounts, desktop_accounts, or other account inspection tools. The implied use is simply to list accounts, but no context, prerequisites, or exclusions are provided.

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 full burden. 'Fetch and parse' implies a read operation, but it does not state whether the tool is safe/read-only, whether it requires logged-in accounts, what side effects (if any) it has, or how it handles errors or rate limits. Behavioral context is minimal.

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 efficiently structured and easy to parse.

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 output schema covers return values, but the description is too sparse for a tool that likely interacts with external web pages. It lacks essential context about account selection, authentication requirements, and potential side effects, leaving the agent under-informed despite an 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%, and the description only vaguely refers to 'selected accounts' without explaining that account_ids is a list of account identifiers. It does not clarify what happens when account_ids is null (the default), whether it means all accounts, or what format the identifiers should take.

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 ('Fetch and parse') and resource ('current enrolled-course pages') scoped to 'selected accounts'. It does not explicitly differentiate from siblings like list_accounts or inspect_course, but the purpose is clear enough to distinguish from most.

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 is given on when to use this tool versus alternatives such as inspect_course or list_accounts, nor on prerequisites like authentication state. The phrase 'for selected accounts' implies a selection mechanism but does not explain how to choose accounts or when the tool is appropriate.

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. It discloses two useful behavioral claims — no browser restart and no loss of memory credentials — but omits critical context such as whether this mutates state, what permissions are required, and what happens to existing batch queues.

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

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

The description is short, but that brevity comes at the cost of clarity. It is not front-loaded with a clear action or resource, and the single sentence is too vague to earn its place as the tool's complete guidance.

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

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

Given the large sibling ecosystem, zero schema coverage, and no annotations, this description is inadequate. The output schema covers return values, but the description still fails to explain the operation's effect, parameter semantics, or usage context.

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

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

Schema description coverage is 0%, and the description does not mention either `refresh` or `completion_replay_policy`. It adds no meaning beyond the parameter names, leaving the agent to guess the behavior of both parameters.

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 it will 'expose account script queues' but does not clarify what 'load_batch_implementation' actually does — whether it loads, runs, or prepares a batch implementation. It also fails to distinguish the tool from siblings like start_learning_batch, resume_learning_batch, or implementation_status.

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 guidance on when to use this tool, when not to use it, or which sibling tools are alternatives. The mention of avoiding browser restarts and credential loss implies a niche use case, but the agent is left to infer when that matters.

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 does disclose non-obvious traits: HTTP-only login by default, reuse of already-logged-in sessions, and no implicit switching of another account's browser. What it omits is the effect of the force flag and any destructive/side-effect or credential-handling context, which matters for a login tool with zero annotation coverage.

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

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

Four short sentences, no filler, and the most decision-relevant constraint (HTTP-only, no implicit browser switching) is front-loaded. It leads with a caveat rather than the action, which slightly delays the reader's orientation.

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 behavioral notes cover session reuse and activation defaults. However, for a 0%-coverage three-parameter tool, leaving force, account_ids, and activate_browser solely to inference is a real completeness gap an agent could trip on.

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

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

Schema description coverage is 0% across three parameters (force, account_ids, activate_browser) and the description never names or explains any of them. 'HTTP login only by default' hints that browser activation is off by default, but force and account_ids — the parameters that most change behavior — are entirely unexplained in both schema and 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?

The description establishes that this performs an HTTP-based login and reuses existing sessions, and it distinguishes itself from setup_learning_accounts (which explicitly activates its first account) and from browser-activation siblings by stating it never implicitly switches browsers. The core verb 'login' is carried by the name and only echoed, not restated with a resource object, so it falls short of a fully self-contained purpose statement.

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

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

It gives a clear negative-side guideline: after a platform rejection, change credentials or inspect verification instead of retrying the same password, which routes the agent to update_account_credentials or inspection siblings. It also contrasts with setup_learning_accounts for explicit activation. There is no explicit positive trigger ('call this when you need authenticated sessions for accounts X'), so a small inference remains.

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 burden, and it does disclose one meaningful trait: no focus or visibility emulation side effects. It does not say whether the minimized state persists, how to undo it (restore_owned_window), or whether the operation requires an attached browser session.

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 action and immediately qualified. No filler, nothing repeated from structured fields.

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 zero parameters the surface is small. The only gap is the missing pointer to restore_owned_window for reversing the action.

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

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

Zero parameters, so the baseline is 4; there is nothing for the description to document about inputs. The statement about focus/visibility correctly signals the tool takes no behavioral arguments.

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 (minimize) and a specific resource (this owned browser), and adds a scope qualifier clarifying it will not emulate focus or visibility. That distinguishes it from viewport/focus-emulation siblings like use_window_viewport, though it never names restore_owned_window as the inverse 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?

'do not emulate focus or visibility' implies the context in which this tool is appropriate rather than an alternative, and no sibling is named as a substitute. An agent can infer the intended situation but gets no explicit when-not or prerequisite 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?

With no annotations, the description carries the full burden and does it reasonably well: it declares the tool is event-driven, that it makes no model/API calls, no seeking, no visibility emulation, and that 'status reads cached state only'. These are exactly the hidden-side-effect facts an agent needs. It stops short of describing lifecycle, whether the watcher must be running while playback continues, or cleanup expectations.

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 lines, front-loaded with purpose followed by exclusions and one operational rule; every sentence carries information. Minor fragmentation ('pause recovery.' as a dangling fragment) slightly hurts readability but nothing is wasted.

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