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

With no annotations, the description carries the behavioral burden and does disclose useful traits: cheap checks run first, inapplicable checks are skipped with a reason, and the result is a single summary. It does not discuss side effects or error handling, but for a read-only analysis tool this is reasonable.

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, front-loaded with the core purpose, and every sentence adds value. The examples and the note about cheap checks and skipping are placed effectively without 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?

Given the output schema exists, parameter schema is fully covered, and the description explains when to use the tool and what behavior to expect, nothing essential is missing for an agent 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 coverage is 100%, so the schema already documents all three parameters. The description adds no additional parameter-level meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

States a specific action ('Run every check at once') and resource ('the graph'), and clearly differentiates itself from the sibling check tools by being the aggregate summary tool. The examples further clarify its role as a broad analysis entry point.

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

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

Explicitly says to prefer this tool for open-ended questions and gives two concrete example queries. It does not explicitly state when to use a specific sibling tool instead, but the guidance is clear enough for an agent to select it appropriately.

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 behavioral disclosure. It discloses the core behavior: classification of every edge and reporting quasi-b-invariant edges with the two nontrivial barriers of G - e. However, it does not explicitly state that the operation is non-mutating, what happens for non-brick inputs, or any performance/error characteristics, leaving some burden on the agent.

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 tight sentences, each earning its place. The primary operation is front-loaded, and the additional barrier-reporting detail and brick precondition are provided without waste.

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

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

For a one-parameter graph-theory tool with an output schema, the description is largely complete: it defines the operation, the one precondition, and the key output detail. It could be more complete by naming sibling tools or explaining behavior on invalid/non-brick inputs, but those are modest gaps.

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

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

The input schema already fully describes graph as 'a graph6 string or a registry name' (100% coverage). The description adds important extra semantic context by stating the graph must be a brick, which constrains valid parameter values beyond 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 begins with a specific action and scope: 'Split every edge of a brick into b-invariant and quasi-b-invariant.' This clearly distinguishes classify_edges from siblings like is_edge_binvariant (a single-property test) and has_qbinv_edges (an existence check), since it handles all edges and produces both categories.

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 states a clear precondition: 'Only defined for bricks,' which tells an agent not to call it on non-brick graphs and suggests verifying brickness (e.g., via is_brick) first. It does not explicitly name alternatives or when-not cases such as using has_qbinv_edges for a quick existence check.

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 of explaining behavior, and it does disclose the key result semantics: the returned value is the smallest k when the cyclic edge connectivity falls in range, and null otherwise. It does not mention exhaustive-search performance limits or max_order behavior, though those are captured in the schema.

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

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

Two compact sentences: the first states the core computation, and the second explains interpretation and the next action. There is no filler, and the most important semantic information is front-loaded.

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

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

For a four-parameter computational tool with an output schema, the description covers the essential selection and interpretation workflow. It is not fully complete because it does not explicitly relate the tool to the sibling has_cyclic_edge_cut or explain the max_order exhaustive-search ceiling, but an agent can still 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 100%, so the baseline is 3, but the description adds meaning beyond the schema by explaining how kmin and kmax bound the search for the minimum cyclic k-edge-cut and how a null result should drive kmax adjustment. The graph and max_order parameters are already well documented 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?

The description defines the operation precisely: find the smallest k in the search range for which a cyclic k-edge-cut exists, and equate that with the cyclic edge connectivity. This distinguishes it from the sibling has_cyclic_edge_cut, which likely tests existence rather than computing the minimum.

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 useful post-invocation guidance: a null answer means no cut was found and kmax should be raised. However, it does not explicitly say when to choose this tool over alternatives such as has_cyclic_edge_cut or is_efec, so some selection context is left to inference.

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

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

No annotations are provided, so the description must carry the burden. It communicates that this is a basic informational read operation, but it does not state side effects, errors, or behavior for invalid graph strings. The mention of output schema in context signals helps, but the description itself is still light on 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 tight sentences with no filler. The most important content — what the tool returns — is front-loaded, and the usage guidance is a natural second 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?

For a single-parameter tool with a documented schema and an output schema present, the description provides enough orientation: what it returns and when to call it. It could mention the registry-name option itself, but the schema already covers that, and the sibling list_named_graphs fills the 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 100%, with the single 'graph' parameter already documented as accepting graph6 strings or registry names and pointing to list_named_graphs. The description adds no parameter-level detail beyond the schema, so the baseline-3 score 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 clearly identifies the resource ('a graph') and the kind of result ('order, size, connectivity, girth, edges'), which distinguishes it from the more specialized property-test siblings. It lacks an explicit action verb, but 'Basic invariants' and the usage sentence make the purpose reasonably 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?

'Use this first when you need to know what a graph is' provides clear placement in a workflow, and 'before asking sharper questions about it' implies the alternative class of specialized tools. It does not name specific sibling tools or give explicit when-not conditions, so it stops short of a 5.

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 explains the exhaustive search method, the vertex-count refusal behavior, the way to override it, and the witness output. This goes well beyond a bare 'returns whether...' statement.

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 well-structured: it opens with the precise question, follows with the formal definition and witness behavior, and closes with the computational constraint. Every sentence earns its place with no filler or redundancy.

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

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

Given that an output schema exists and the parameter schema is complete, the description provides enough context for correct invocation: the property being tested, the witness output, and the practical search limit. The only notable omission is explicit routing relative to sibling tools, which is more a usage-guideline gap.

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

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

The input schema already documents all three parameters with 100% coverage, so the baseline is 3. The description reinforces that k is the exact crossing-edge count and that max_order bounds the exhaustive search, but it adds little semantic detail beyond what the schema already provides.

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 tool answers a specific decision problem: whether the graph has a cyclic edge cut of size exactly k. It gives the precise bipartition condition, defines what 'cyclic' means here, and mentions that both shores are returned as a witness, distinguishing it from numeric tools like cyclic_edge_connectivity.

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 useful operational context: the search is exhaustive over 2^(n-1) bipartitions and is refused above max_order vertices, with an instruction to raise max_order to override. However, it does not explicitly say when to use this tool versus siblings, such as using cyclic_edge_connectivity when only the numeric value is needed.

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 the return behavior: the count and the edges themselves. However, it does not explain behavior for non-brick inputs, invalid graph strings, or graphs with no invariant edges beyond what the output schema might capture.

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 short sentences: a focused question followed by the return value. It is front-loaded, contains no filler, and every word contributes to understanding the tool's purpose and output.

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 query with an output schema, the description gives the essential output information. However, it lacks a definition or context for 'quasi-b-invariant edges' and provides no guidance about valid inputs or how this relates to the similarly named sibling 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 input schema already documents the single 'graph' parameter with a clear description ('a graph6 string or a registry name'), so schema coverage is 100%. The description adds no extra meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action: it checks whether a brick has any quasi-b-invariant edges and returns a count and the edges. It is specific enough to be understood, but it does not distinguish itself from siblings like is_edge_binvariant or classify_edges beyond using a different term.

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 closely related sibling tools. The word 'brick' implies it applies to bricks, but no explicit prerequisite or alternative-selection hint is 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?

With no annotations, the description carries the full burden of explaining behavior. It discloses the key behavioral trait: matching up to isomorphism rather than requiring exact string equality. It also indicates accepted input kinds (graph6 string or registry name). Return details are left to the output schema, which is acceptable.

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 short sentences with no filler. The core purpose is front-loaded as a question, and the usage hint follows immediately. Every word earns its place.

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

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

For a single-parameter tool with an output schema, the description covers the core question, the isomorphism nuance, and the typical use case. It is complete enough for an agent to select and invoke the tool correctly, though it could optionally mention what kind of result is returned.

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 already fully describes the only parameter as 'a graph6 string or a registry name,' so schema coverage is 100%. The description adds context about relabelling and well-known graphs, but it does not materially expand the parameter semantics beyond 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 states a precise predicate: whether an input graph is one of the registry's named graphs up to isomorphism. This clearly distinguishes it from sibling tools like graph_info or analyze, which do generic graph analysis.

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 notes it is useful for a bare graph6 string that may be a relabelling of a well-known graph, giving clear context for when to invoke it. It does not explicitly mention alternatives or when not to use it, but the context is sufficient for a single-purpose 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 provided, the description carries the behavioral disclosure burden. It fully specifies the tested condition, including the requirement for every distinct vertex pair and perfect matching existence, which is strong transparency for a predicate 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?

The description is a single efficient sentence that states the property precisely and front-loads the main purpose. Every part of the sentence earns its place with no redundancy 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?

For a one-parameter predicate with a fully documented schema and an output schema available, the description is complete enough. It provides the exact mathematical semantics needed to invoke the tool correctly and interpret its result.

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 already documents the graph parameter at 100% coverage, so the baseline is 3. The description adds useful context about how the graph is interpreted in the bicritical condition, but it does not add new parameter-level format or usage details beyond 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 clearly states the tool checks whether a graph is bicritical and defines the condition in mathematical terms. It lacks an explicit contrast with sibling tools like is_brick or is_matching_covered, but the verb and resource are 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 definition implies the tool is for determining bicriticality, but it does not state when to prefer it over related predicates such as is_brick or is_matching_covered, nor does it mention any exclusions or prerequisites.

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 behavioral burden. It discloses a key trait: the result is not a single boolean but reports the two conditions separately, so a negative answer identifies the failed condition. It does not describe return format or invalid-input behavior, but the output schema presumably covers response 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?

The description is two concise sentences with no filler. The definition is front-loaded in a question form, and the second sentence adds genuinely useful behavioral detail about separate condition reporting.

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 predicate tool with full parameter schema coverage and an output schema, the description is complete enough. It defines the property, explains the input's accepted forms, and clarifies the tool's distinguishing 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?

Schema description coverage is 100%, and the schema already explains that 'graph' is a graph6 string or registry name. The tool description adds no additional parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description states a specific predicate ('is the graph a brick') and immediately defines the term as '3-connected and bicritical.' It also distinguishes itself from the sibling is_bicritical by noting that the two conditions are reported separately.

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 when the tool is useful: to check the brick property and to learn which condition fails on a negative answer. However, it never explicitly names alternatives or states when to prefer is_bicritical, has_cyclic_edge_cut, or other sibling tools.

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?

The description mentions the additional output ('Also returns the nontrivial barriers of G - e'), which informs the user about what to expect. As a query tool, it likely has no side effects, but since there are no annotations, it would benefit from explicitly stating read-only behavior. Still, the provided output details add transparency.

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 to the point, with no redundant wording. It conveys the core function and an additional return value in two concise sentences, making it easy to quickly understand.

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 specialized domain and the presence of sibling tools, the description is sufficient for an expert user. It does not define b-invariant or quasi-b-invariant, but such definitions are likely standard in this context. The additional return value is noted, rounding out the tool's 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 schema already provides basic descriptions for each parameter (endpoint, graph6 string). The tool description adds minimal extra meaning beyond stating that the graph is a brick. It does not elaborate on the format or domain of the parameters, so the schema carries the main burden.

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 that the tool checks whether an edge in a brick is b-invariant or quasi-b-invariant. It uses a specific verb and identifies the resource, though it does not explicitly differentiate from sibling tools, the specialized terminology makes 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?

It provides a condition ('Only defined for bricks') that tells when the tool is applicable, but does not explicitly contrast with sibling tools or state when to prefer alternatives. This gives partial guidance but leaves the selection criteria 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?

With no annotations, the description carries the burden of behavioral disclosure. It does well by explaining the True condition and, notably, that a False result includes the disconnecting witness triple. It does not mention edge cases like disconnected graphs or invalid inputs, but the core behavior is clearly disclosed.

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 efficient: a direct question, a one-sentence definition of the property, and a one-sentence note about the False output. No filler or redundant information.

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

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

The description defines the property, states the True condition, and explains the False-case witness, which covers the essential behavior for a single-parameter predicate. With an output schema present, this is mostly complete, though it leaves minor gaps around prerequisites or behavior on degenerate graphs.

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 already documents the only parameter ('graph') as 'a graph6 string or a registry name', with 100% coverage. The description adds no additional parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: it checks whether a graph is essentially 4-edge-connected (efec) and gives a precise criterion ('no three pairwise non-adjacent edges disconnect the graph'). It does not explicitly distinguish itself from the sibling is_efec_cubic_brick, 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 guidance about when to use this tool versus alternatives, such as is_efec_cubic_brick or is_brick. The definition of the property is provided, but no context on prerequisites, exclusions, or preferred use cases.

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

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

With no annotations, the description carries the behavioral burden and does meaningfully disclose the check order, short-circuiting, and the failed_check output field. It does not describe error behavior or return-value details, but the presence of an output schema reduces the need for that.

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

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

The second paragraph is dense and informative, with no wasted words. The first sentence largely restates the title, which is mild redundancy, but the overall length is appropriate.

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 predicate with an output schema, the description covers the essential behavior: what properties are checked, in what order, and where failure is reported. It omits definitions of the technical graph classes, but those are domain-specific and not critical for the intended audience.

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 already fully documents the single graph parameter as a graph6 string or registry name, which is 100% coverage. The description adds no parameter-level nuance beyond restating that the graph is the object being tested.

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 precise predicate and spells out the ordered conditions: cubic, then essentially 4-edge-connected, then brick. This clearly distinguishes it from sibling tools like is_efec and is_brick by identifying the composite nature of the test.

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

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

The description implies usage through its explicit check sequence and 'stopping at the first failure' behavior, but it never states when to prefer this tool over separate is_efec or is_brick calls. There is no explicit when-not or alternative 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 behavioral disclosure burden. It explicitly states the tested condition, including both required components: connectedness and every edge lying in some perfect matching. It does not discuss edge cases or registry-name expansion, but the behavior of this read-only predicate is otherwise clearly conveyed.

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

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

The description is a single compact sentence that front-loads the operation and then defines the property. It contains no redundant restatement of the schema or fillers, so every word earns its place.

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

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

For a one-parameter predicate with an output schema, the description is largely complete: it states exactly what property is checked and the schema defines the accepted input. It could benefit from a short note on when to prefer this check over sibling graph-property tools, but that is primarily a usage-guidance gap.

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

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

The input schema already fully documents the single parameter as 'a graph6 string or a registry name,' so schema coverage is 100%. The description adds no additional parameter-level meaning, making the baseline score of 3 appropriate.

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

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

The description clearly identifies the operation as checking whether a graph is matching covered and defines that property precisely: connected, with every edge in some perfect matching. It does not explicitly differentiate itself from sibling graph-property tools, but the predicate and resource are 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?

No guidance is provided about when to use this tool versus alternatives such as is_bicritical, is_brick, classify_edges, or graph_info. The property definition implies a use case, but the description never states when to choose this check or when to prefer another sibling 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 burden and does well: it defines the exact condition and reveals the important behavioral detail that the removed edge pair comes back as the witness. It does not discuss failure behavior, but for a read-only predicate this is a minor 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?

Two short sentences with no redundant wording. The property question is front-loaded, followed immediately by the precise definition and witness behavior. Every clause earns its place.

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

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

The input is fully covered by the schema, the output schema covers return structure, and the description explains the witness behavior. It is complete for a single-parameter graph predicate, though it could add a note about invalid graph6 strings or registry names.

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

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

Schema description coverage is 100% for the single graph parameter, so the schema already documents input format. The description adds no additional parameter semantics, which is acceptable under the baseline for high schema coverage.

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

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

The description explicitly states the tool is a predicate for the near-bipartite property and gives the defining condition: removing some pair of non-adjacent edges leaves a bipartite matching covered graph. This distinguishes it from the many sibling graph-property predicates.

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: an agent should call this when it needs to know whether the provided graph is near-bipartite. However, the description does not explicitly mention alternatives or when not to use it, leaving the choice among sibling property tools to inference.

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

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

No annotations are provided, so the description carries the full burden. It states that it returns a list of graph metadata, which implies a read-only operation, but it does not explicitly mention that it has no side effects or any other behavioral traits such as 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?

The description is concise, using two short sentences to convey the purpose and the returned fields. There is no redundant information.

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

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

For a simple list operation with no parameters and a clear return description, the tool is adequately specified. No additional context is needed to understand its function.

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 no parameters, so the description does not need to explain any. The description's mention of return fields is not relevant to parameter meaning, so it neither adds nor detracts from 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 clearly states that the tool lists all graphs in the registry that can be referred to by name, and it specifies the returned fields. This distinguishes it from sibling tools that perform graph operations.

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

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

The description implies that this tool is for retrieving available named graphs, but it does not explicitly say when to use it versus alternatives like identify_graph or run_sage. Since it is a simple list operation, the usage is somewhat implied.

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 prominently discloses that nothing is returned implicitly, that users must print output, and that execution happens in a fresh Sage process isolated from other tools. This gives an agent a strong mental model of the tool's runtime 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?

Three tightly written sentences, each earning its place: the first states what the tool does, the second explains when to use it and the printing requirement, and the third clarifies the fresh-process behavior. No redundancy 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?

The tool has an output schema, so return format details are already covered structurally. The description supplies the missing contextual facts: arbitrary code execution, escape-hatch role, fresh process isolation, and explicit-printing semantics. For a two-parameter tool, this is fully sufficient.

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 100%, so the parameters are already documented. The description adds meaningful semantic guidance beyond the schema by explaining that explicit printing is required and that no implicit result is returned, which clarifies how the 'code' parameter should be used.

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: 'Run arbitrary SageMath code' and clearly identifies what is returned (stdout, stderr, exit status). It also distinguishes itself from the specialized sibling tools by framing itself as an 'escape hatch' for questions those tools do not cover.

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 clearly indicates when to use this tool: when the typed sibling tools do not cover the question. It does not explicitly name alternatives or state when not to use it, but the 'escape hatch' phrasing strongly implies it is a fallback rather than a first choice.

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