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

With no annotations, the description carries the transparency burden. It discloses that deletion only occurs with confirm=True and returns a preview otherwise — a helpful safety behavior. However, it does not mention the irreversible nature of the wipe, potential side effects on other tools, or whether it affects server-side state beyond local cookies. The preview mechanism is a positive step but incomplete for a destructive operation.

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

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

Two sentences, zero fluff. The primary action is stated first, and the controlling parameter is explained in the second. The structure is front-loaded and efficient, with every word contributing to the tool's usage.

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 one optional parameter and an existing output schema, the description covers what the tool does and the key behavioral toggle. It stops short of warning about the destructive nature or when to use it, but the presence of an output schema handles return-value details. Missing caveats about irreversible consequences and recommended usage contexts keep it from a 5.

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

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

The schema provides zero description coverage (0%), so the description must clarify the parameter. It does exactly that: 'Requires confirm=True to actually delete' and explains the preview when false. This fully conveys the boolean meaning beyond the schema's default of false, making the parameter's role unambiguous.

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 begins with 'Wipe persisted cookies, session metadata, and window state' — a specific verb and resource set that clearly conveys destructive cleanup. It differentiates from siblings like minimax_window (which likely manages rather than clears) and minimax_status (read-only), so the agent can distinguish it without opening the schema.

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

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

No guidance is given on when to use this tool versus its siblings (e.g., minimax_window, minimax_login). It only explains the confirm parameter, not the contextual trigger for clearing state. The description would benefit from an explicit note like 'Use when you need to reset session state before re-authentication.'

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 discloses that the operation increments a local counter, implying a state mutation. It does not elaborate on side effects such as persistence, overflow, or reset behavior, but it does mention the 'local' scope and the 5h window. Given the simplicity, a 3 reflects the core disclosure without deep behavioral detail.

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

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

The description is two sentences, with the primary action front-loaded. Every word serves purpose: the first sentence states the core function, the second provides usage context and integration with a sibling. No fluff or redundancy.

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

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

The tool is extremely simple (one optional integer parameter). The description covers purpose, usage timing, and its role alongside minimax_status. An output schema exists but is not needed to explain return values. All information an agent needs to call it correctly is present.

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

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

Schema description coverage is 0%, so the description must compensate. It names 'delta' and explains it as the increment amount. This adds meaning beyond the schema, which only gives the type and default. It does not detail edge cases (e.g., negative values), but the meaning is intuitively clear from the context.

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 ('increment'), a specific resource ('local 5h-window consumption counter'), and clearly differentiates from siblings by tying usage to per-API-call tracking. It also names the sibling minimax_status as the complementary tool, making its purpose unmistakable.

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

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

The description explicitly says when to call it ('once per MiniMax API call (or batch)') and explains its role in pacing via minimax_status(). It does not explicitly list exclusions or alternatives, but for a simple counter this guidance is sufficient. The context is clear and actionable.

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 of disclosing behavior. It mentions 'last-known' metadata, implying the data may not be real-time, which is a useful behavior hint. However, it does not state whether the operation is read-only, whether any side effects occur, or how the tool behaves if no session exists.

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 extremely concise, using a single phrase to convey the core purpose without any filler words. It front-loads the verb and resource, making it easy to scan. Every word earns its place.

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

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

Despite having an output schema and no parameters, the description remains vague. It doesn't clarify what 'static configuration' includes or what 'session metadata' entails, nor does it mention any operational constraints or error conditions. An agent would need to inspect the output schema or call the tool to understand its full behavior.

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 schema is trivially 100% covered. Per the rubric, a baseline of 4 is appropriate since there is nothing to explain about parameters; the description does not need to add parameter semantics.

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

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

The description states a clear verb (Return) and resource (static configuration + last-known session metadata), which conveys the tool's function. However, it does not explicitly distinguish this from minimax_status, which likely also returns state-related information, so the differentiation is only implicit.

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

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

The description provides no guidance on when to use this tool versus siblings like minimax_status or minimax_window. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent to infer usage from the tool name and description 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 transparency burden. It discloses that the browser is headful (visible to the user), that it waits for manual login, and that login success is detected automatically via the _token cookie. It does not mention timeout behavior or error handling, but the core behavioral traits are well communicated.

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 concise—two sentences—and front-loaded with the primary action and then the return condition. Every sentence adds value, and there is no redundant phrasing. The structure is clean and scannable.

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 that involves manual user interaction and a login flow, the description covers the main steps but omits important details like what happens on timeout (does it throw? does it close the browser?) and whether repeated calls are allowed. The presence of an output schema (though not shown) may cover return values, but the behavioral context around failure/timeout is missing, leaving the agent with some uncertainty.

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 input schema has one parameter, timeout_seconds, with no description (schema coverage 0%). The description does not mention this parameter at all, leaving the agent without any guidance on what it controls (e.g., how long to wait before giving up). Since the description must compensate for missing schema documentation and fails to do so, the parameter semantics are poorly conveyed.

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

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

The description clearly states the action: 'Launch a headful Camoufox browser so the user can log in manually.' It specifies the resource (browser), the purpose (manual login), and the completion condition (when the _token cookie appears). It is distinct from sibling tools like minimax_status or minimax_window, which likely handle other aspects of the session.

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

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

The description implies this is for logging in but does not explicitly contrast it with alternatives or state when to use it vs. siblings. It does provide context that after login no further action is needed, but it lacks guidance on prerequisites, when to avoid, or how it relates to other minimax tools. Thus, usage guidance is present but not 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 provided, the description carries the full burden of behavioral disclosure. It clearly states that the tool launches a headless browser and loads a specific URL, which is transparent about its action. It does not mention side effects, but as a smoke test the behavior is self-evident. No contradictions exist between the description and annotations (none provided).

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, tight sentence with no filler. It front-loads the 'Quick health check' label, immediately conveying the tool's niche, and then specifies the exact action. Every word earns its place – highly efficient.

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

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

For a parameterless tool with an output schema (present), the description fully covers the action. It does not explain return values or success criteria, but the output schema presumably handles that. The description is complete for an agent to decide when to invoke it and what it will do.

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 schema coverage is trivially 100%. The description adds no parameter details because none are needed. Per the rule, a 0-parameter tool receives a baseline score of 4; the description is adequate without param information.

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: 'launch headless Camoufox and load example.com.' This is a concrete, scoped health check that clearly differentiates from siblings like minimax_status (which likely reports status) and minimax_window (which manipulates windows). The verb 'launch' and resource 'example.com' make the purpose unambiguous.

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

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

The phrase 'Quick health check' implies a verification use case, but the description does not explicitly state when to use this tool versus alternatives like minimax_status or minimax_info. There is no guidance on exclusions or conditions, leaving the agent to infer that this is for a lightweight setup validation.

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 transparency burden. It discloses that the tool fires two distinct HTTP requests, uses persisted web-session cookies for auth, and saves a failure body to a file on missing/stale cookies. It stops short of explicitly stating whether the operation is read-only, though the purpose implies it, so a 4 is appropriate.

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 organized and front-loads the purpose and usage, then provides a numbered list of the two requests. It is slightly long but each sentence adds value—the request details and auth handling are necessary for correct use. Minor redundancy exists ('same numbers shown on the page' vs 'matches what the user sees'), but overall it is efficient.

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 zero parameters, an existing output schema, and moderate complexity (multiple requests, auth, failure handling), the description covers all essential context: when to use, what the tool mirrors, auth requirements, and failure handling. It even references the sibling tool for the wait action. Nothing needed for correct invocation is missing.

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

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

The tool takes zero parameters, and the schema has 100% coverage (empty object). The baseline for no parameters is 4; the description correctly avoids padding and simply documents the requested behavior. No further parameter explanation is needed.

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

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

The description opens with a specific verb ('Return') and a clear resource ('current Token Plan status'), then details the exact metrics (5h window remaining/used percent, time to reset, weekly window). It also names the two backend requests it mirrors, making it unambiguous what the tool does and grounding it in observable behavior.

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

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

It explicitly states when to use it: 'Use this before any substantial work that will call MiniMax models.' It also gives conditional behavior ('If should_pause is true...') and points to a specific alternative (minimax_wait_for_quota), providing both a when and a corresponding alternative action.

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

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

With no annotations, the description carries the full burden and discloses blocking behavior, polling interval, cancellation via MCP connection close, and the default threshold source. This is comprehensive and gives an agent confidence about the tool's runtime semantics.

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 reasonably concise and front-loads the primary action, but it repeats the threshold condition ('exceeds' and 'threshold is satisfied') in consecutive sentences. Still, it is efficient and well-organized.

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 that an output schema exists, return values need not be described. The description covers blocking, polling, cancellation, and default, which is sufficient for an agent to invoke the tool. Minor gap: no mention of potential indefinite blocking or timeouts, but cancellation is noted.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly references both parameters: poll_seconds as the polling interval and target_remaining_percent as the threshold with a default. This adds meaning beyond the raw schema fields.

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 ('Block') and resource ('5h window remaining percent'), and explicitly contrasts with a fixed sleep. It distinguishes from sibling minimax_status by referencing it as the polling function, making the tool's unique role unambiguous.

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

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

It provides a clear use case ('truly pause' vs. fixed sleep) and implies when to use this tool. However, it does not explicitly enumerate when not to use it or compare with other siblings like minimax_window or minimax_consume, so the guidance is good but not exhaustive.

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?

Since no annotations are provided, the description bears the full burden of behavioral disclosure. It does disclose the key behavioral trait of making no API call, but it does not mention potential errors, performance characteristics, or state dependencies. For a simple zero-parameter tool this is acceptable but not comprehensive.

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 zero wasted words. It efficiently communicates the core purpose and a critical behavioral distinction, making it perfectly sized for this simple 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?

Given the tool's simplicity (zero parameters, no side effects), the description fully covers what an agent needs to know to call it correctly. An output schema exists, so the description correctly omits return-value details. The description clearly states what is returned and its local nature.

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, and the schema fully documents that (100% coverage). Per the baseline for 0 parameters, a score of 4 is appropriate. The description adds no parameter-related meaning because there are none, which is acceptable.

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

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

The description clearly states the verb 'Return' and the specific resource 'agent-local 5h observation window', and explicitly notes 'no API call', which distinguishes it from sibling tools that likely make network requests. This is precise and leaves no ambiguity about what the tool does.

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

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

The description implies usage context via 'only' and 'no API call', indicating this is for when the agent needs local observation data without any network interaction. However, it does not explicitly name alternatives or state when not to use it, so it falls short of fully explicit guidance.

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