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

No annotations exist, so the description carries full burden. It does not disclose any behavioral traits like computational cost, side effects, or required data formats. Only states the function without elaboration.

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 sentence, which is concise but lacks structure. It could be expanded to include more information without becoming overly long.

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 3 parameters and an output schema (not shown), but the description does not cover return values or the expected format of characters. Incomplete for an agent to reliably invoke the 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%, yet the description only vaguely mentions 'tree' and 'characters'. It does not explain the meaning of tree_key, dataset_id, or characters_key, nor their relationships. Fails to compensate for missing schema descriptions.

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 'Compute' and the resource 'total parsimony (number of mutations)' and the dependency on a tree and characters. It is specific and distinguishes from sibling tools like compare_trees or compute_dissimilarity.

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 vs. alternatives. The context implies use in phylogenetic analysis, but no exclusions or prerequisites are mentioned.

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 cover behavior. It discloses the two metrics and implies read-only comparison, but does not state that it is non-destructive, what happens with mismatched tree sizes, or whether branch lengths are ignored. The existence of an output schema is not referenced.

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 plus bullet list) and front-loaded with the main purpose. Every sentence adds information. However, the metrics list could be integrated more cleanly.

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 4 parameters and an output schema, the description is incomplete. It partially explains one parameter and lacks behavioral details. It does not mention return format or how results relate to the metrics. The presence of many sibling tools makes the lack of differentiation a 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%, so the description must explain parameters. It only describes the 'metric' parameter (listing 'rf' and 'triplets'), but does not explain 'dataset_id', 'tree_key1', or 'tree_key2'. This leaves three required parameters undocumented.

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

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

The description clearly states the tool's action: 'Compare two trees in the same dataset.' It lists two metrics (RF and triplets), giving a specific verb and resource. However, it does not distinguish from sibling tools like compute_dissimilarity or plot_tree, which could cause confusion.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, constraints, or when to choose a different tool for comparing trees. The context signals show 17 sibling tools, but no differentiation is offered.

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 discloses that the result is stored in tdata.obsp[key_added] and returns a short confirmation. With no annotations provided, this adds some behavioral context but lacks details on side effects, permissions, or error conditions.

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: three sentences plus parameter list. It is front-loaded with the main purpose and provides necessary details without extra words. Every sentence adds value.

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 has 4 parameters and an output schema, the description covers the main functionality, parameter purposes, and output storage. However, it does not mention prerequisites (e.g., dataset must have characters in obsm) or the exact format of the confirmation, leaving minor 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 explains all parameters: dataset_id (handle), method (examples of metrics), characters_key (obsm key), key_added (obsp key). This fully compensates for the schema's lack of descriptions.

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?

Clearly states the tool computes a pairwise dissimilarity map over cells, with a specific use case (useful before nj/upgma). This distinguishes it from siblings like reconstruct_tree or calculate_parsimony.

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 mentions the tool is useful before neighbor-joining or UPGMA tree reconstruction, providing clear context for when to use it. However, it does not discuss when not to use it or mention alternative tools for similar purposes.

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. It discloses the computational method (spatial autocorrelation), the required data (expression matrix, tree), where results are stored (tdata.uns['moranI']/['gearyC']), and the effect of the method parameter. No destructive actions or side effects are mentioned, but the description is informative.

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 well-structured: a one-line summary, a brief explanation, and a parameter list. It is front-loaded with the main question. While the parameter list is somewhat lengthy, each line adds necessary detail. Minor redundancy (e.g., 'Tree neighbors' could be slightly tightened) but overall 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?

The description explains input requirements, algorithmic steps, and output storage (in tdata). However, it does not mention the function's return value despite an output schema existing. The description could be more complete by noting what the tool returns (e.g., a table of features and scores), but it covers the essential context for 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?

With 0% schema description coverage, the description must compensate. It explains each parameter's role: dataset_id, tree_key, keys, n_neighbors, method, layer, top_n. It adds context like 'var_names are the features scored' and default behavior. However, it could more explicitly state the valid values for method (e.g., 'moran' or 'geary') and that keys defaults to all var_names.

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 ranks features by heritability on a tree using Moran's I or Geary's C, and it answers a specific biological question: 'which genes are most heritable on this lineage tree?'. This distinguishes it from sibling tools like calculate_parsimony or reconstruct_ancestral_states, which serve different analytical purposes.

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 explains when to use this tool: to rank features by heritability on a tree. It also specifies prerequisites (an expression matrix in .X or a layer) and the required tree. However, it does not explicitly state when not to use it or provide direct alternatives, though the context of sibling tools implies other options exist.

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. It does not disclose behavioral traits such as that the tool is read-only or that it only works on already loaded datasets.

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, but slightly too terse. Every word serves a purpose, though it could benefit from a bit more context.

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 existence of an output schema, the description does not need to detail return values. However, it lacks context about prerequisites (e.g., dataset must be loaded) and does not fully match the complexity of the sibling tools set.

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 adds minimal meaning beyond the parameter name, not explaining what dataset_id refers to or its expected format.

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

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

The description uses a specific verb ('Inspect') and clearly identifies the resource ('loaded dataset') and the output details (shape, tree keys, obsm/obs/layers/uns keys). It effectively distinguishes from sibling tools like load_dataset or list_datasets.

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 the tool is for inspecting datasets that have been loaded, but does not explicitly state when to use it versus alternatives, nor does it mention 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?

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as whether the operation is read-only, potentially destructive, or requires specific authentication. The minimal description leaves the agent guessing about side effects.

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: a single-sentence summary followed by a clean arg list. Every word is necessary and relevant, with no 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 tool's simplicity and the presence of an output schema, the description covers the basic purpose and parameters. However, it lacks usage context and behavioral transparency, making it only minimally complete for an agent to use 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%, but the description adds inline explanations for all 4 parameters (e.g., 'Which tree in tdata.obst to export'). This provides useful context not present in the schema alone, though each explanation is brief.

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

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

The description uses the specific verb 'Export' and resource 'reconstructed tree to a Newick string', clearly distinguishing it from sibling tools like reconstruct_tree (which builds the tree) and plot_tree (which visualizes it).

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

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

No guidance on when to use this tool versus alternatives like compare_trees or plot_tree. The description only lists parameters without contextual hints on scenarios 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It mentions the matrix is stored in obsm[characters_key] and that the data is 'ready for reconstruction', but does not detail side effects (e.g., overwriting), error conditions, or performance characteristics. The description is moderately transparent but lacks depth for a tool with no annotations.

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

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

The description is well-structured with a clear sentence for the main purpose, followed by a paragraph on CSV format requirements, and an Args section for parameters. It is focused and front-loaded. However, the Args section could be integrated into the schema to reduce redundancy, but given the lack of schema descriptions, it earns its place.

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

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

With an output schema present (not shown but context indicates true), the description need not explain return values. It covers input format, storage location, and sentinel meanings. It lacks explicit error handling or prerequisite checks, but overall provides sufficient context for an import 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 coverage is 0%, so the description compensates fully by listing all four parameters with explanations: csv_path (absolute path), characters_key (obsm key with default), missing_state and unmodified_state (sentinels with defaults). This adds significant meaning beyond the schema's type and default values.

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

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

The description uses a specific verb ('import') and resource ('character-matrix CSV into a new TreeData'), clearly distinguishing it from sibling tools like simulate_characters or reconstruct_tree. It also states the purpose is 'ready for reconstruction', adding context.

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 explains the required CSV format (cell ids, columns per character, integer states, sentinels) and the mapping to data storage (obsm[characters_key]). While it doesn't explicitly state when to use vs alternatives, the context implies this is for importing external data, contrasting with simulation or reconstruction 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?

No annotations are provided, so the description carries the burden. It mentions that labels are written to a column (indicating mutation) and partitioning occurs at a given depth. However, it does not disclose default behavior when depth is null, constraints on input, or potential side effects beyond the mentioned key.

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

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

The description is a single sentence that efficiently conveys the main action and side effect with no wasted words. Every part is essential.

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 moderate complexity (tree partitioning with 4 parameters) and the existence of an output schema, the description is minimally complete but lacks crucial parameter details. It provides the core action but not enough context for effective use without additional 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?

Schema description coverage is 0%, meaning no parameter descriptions exist in the JSON schema. The description does not provide any additional meaning or explanation for any of the 4 parameters (depth, tree_key, key_added, dataset_id), leaving the agent to infer from names alone.

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 (partition a tree into clades at a given depth) and the outcome (labels written to obs[key_added]). It is specific and distinguishes this tool from sibling tools that perform other tree operations like computing parsimony or plotting.

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

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

The description provides no guidance on when to use this tool versus alternatives, no when-not-to-use conditions, and no mention of prerequisites or context. It simply states what the tool does.

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 goes beyond the lack of annotations by disclosing that it spawns a background process, returns URL and PID, requires an optional package, and runs a long-lived web server. It does not cover potential side effects like resource consumption or manual termination necessity.

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 well-structured with clear sections and bullet points, front-loading the main action. It is concise but includes all necessary details without being 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?

Given the tool has 3 parameters, no annotations, and an output schema (not shown), the description covers the essential aspects: input types, process behavior, return values (URL/PID), and prerequisites. It could mention error scenarios or stopping the process more explicitly.

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

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

With 0% schema description coverage, the description compensates by explaining that dataset_id_or_path can be a loaded dataset ID or file path, and provides default values for port and host. It adds meaning beyond the schema's property names and defaults.

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 'launch the cellxlineage interactive web viewer on a dataset', specifying a unique verb (launch) and resource (viewer on dataset). It distinguishes from sibling tools like plot_tree by focusing on interactive viewing rather than static plots.

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 for interactive visualization and notes the need for the cellxlineage package and that it starts a long-running server. However, it does not explicitly state when not to use this tool or suggest alternatives among siblings.

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

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

No annotations provided, so description carries full burden. The description states the action but does not disclose any additional behavioral traits (e.g., no side effects, permissions). Adequate for a read-only list 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?

Single 8-word sentence that is front-loaded and contains no fluff. Every word adds value.

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 and presence of output schema, the description is sufficiently complete. No missing context needed for correct invocation.

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

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

No parameters exist (schema coverage 100%), so description needs no param info. Baseline set at 4.

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

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

Clearly states the verb 'list' and the resource 'datasets currently loaded in the session', distinguishing it from sibling tools like load_dataset or dataset_info.

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

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

No guidance on when to use or not use this tool, nor any mention of alternatives. It is a simple listing tool with no exclusions.

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

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

No annotations provided, so description bears full burden. It mentions return value but omits behavioral traits like file access permissions, error handling, or side effects. Minimal behavioral disclosure.

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?

Description is concise with a brief introductory sentence and a clear args section. It is front-loaded and efficient, though the docstring format is slightly redundant with the structured schema.

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

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

Given simple tool with 1 param and output schema existing, description covers basic usage and return. Missing details on error cases, file access, and prerequisites, but adequate for straightforward load operation.

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?

Only one parameter 'path' with schema coverage 0%. Description adds meaning: 'Absolute path to a .h5td/.h5ad file', specifying path type and file format, which is useful 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?

Description clearly states 'Load a TreeData file' with specific file extensions (.h5td, .h5ad) and mentions returning a dataset_id handle and summary. It distinguishes from sibling load_example_dataset by specifying 'existing datasets'.

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 instruction 'Use this for existing datasets that already contain trees, expression, and/or a character matrix' guides when to use. No explicit when-not-to-use, but context implies load_example_dataset is for examples.

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 provided, but description fully compensates: notes 'downloaded on first use' and describes return type and content (TreeData with tree and expression). No contradictions.

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?

Concise and well-structured with introduction, use case, dataset list, and args section. Every sentence adds value 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?

Covers parameter semantics, behavior, and return type adequately. Could explicitly mention when not to use vs load_dataset, but overall complete for tool usage.

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%, but description defines name parameter with three named options and their specific option keys, and options parameter explained as forwarded kwargs. Adds full meaning.

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?

Description clearly states 'Load a built-in pycea example lineage-tracing dataset' with specific verb and resource. Lists datasets with distinct examples, differentiating from siblings like load_dataset.

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?

States 'Great for demos and testing without your own data', providing clear usage context. Does not explicitly exclude alternatives or compare to siblings, which would be ideal.

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?

Despite no annotations, the description discloses that the tool renders with pycea, returns the figure inline, and saves to a path. However, it omits whether the save_path overwrites existing files and any potential side effects.

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 structured with a brief intro and an Args list, but the Args section is somewhat verbose with multiple lines per parameter. It could be more concise while remaining clear.

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 complexity (12 parameters, no output schema), the description covers return values, rendering details, and all parameters thoroughly. No critical information is missing.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining each parameter's meaning, allowed values, and defaults (e.g., keys can be obsm key, obs cols, or var_names; branch_color as color or attribute 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 description clearly states it plots a lineage tree with optional character-matrix heatmap, using a specific rendering library (pycea). It distinguishes from sibling tools like export_newick or reconstruct_tree by focusing on visualization.

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 implicitly suggests usage for plotting trees with annotations, but does not explicitly compare to alternatives (e.g., launch_viewer) or provide conditions when not to use.

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 disclose behavior. It states results are written as node attributes, but doesn't detail side effects, permissions, or performance implications.

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, fairly concise, with key information front-loaded. Could be slightly more structured but no waste.

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

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

Given complexity and that an output schema exists but is not described, the description is incomplete about return value. It mentions results are written as attributes but doesn't clarify output format.

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 description must compensate. It adds meaning for 'keys' (obs cols/var/obsm) and 'method' (mean, parsimony), but does not describe dataset_id or tree_key beyond 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 it infers internal-node states for given keys on a tree, with specific methods (mean, parsimony-based). It distinguishes from siblings like calculate_parsimony and reconstruct_tree.

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 mentions methods depending on data type but lacks explicit guidance on when to use this tool vs alternatives. No 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?

Discloses that the tree is stored in tdata.obst[key_added] as a rooted DiGraph. No annotations provided, so description carries burden; lacks mention of side effects, idempotency, or required permissions, but covers the essential output 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 concise paragraphs with bullet-style method list. Every sentence adds value, no redundancy. Front-loaded with purpose, then structured details.

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?

Covers all 6 parameters, methods, and output location. Could mention the DiGraph attributes or return value explicitly, but output schema exists (not shown). Adequate for effective 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?

With 0% schema coverage, the description compensates by explaining each parameter's role, defaults, and examples (e.g., method options, extra_options). Adds meaning beyond the schema structure.

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?

Clearly states the tool reconstructs a lineage tree from a character matrix, with specific verb 'Reconstruct' and resource 'lineage tree'. Distinguishes from siblings like plot_tree or calculate_parsimony by focusing on tree 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?

Provides detailed method descriptions with usage notes (e.g., 'good default', 'exact; requires Gurobi; small trees only') that guide selection. Does not explicitly contrast with sibling tools, but the intent is clear.

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?

Without annotations, the description carries full behavioral disclosure burden. It does not mention side effects (e.g., overwrite behavior), required permissions, or error conditions. Only the return value (absolute path) is 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?

Two concise sentences, front-loaded with key information. Efficient but could include brief parameter hints without excess.

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 moderate complexity (2 parameters, save operation), the description lacks critical details: what happens on file conflicts, required permissions, and the role of the 'path' parameter. The output schema exists but is not leveraged for completeness.

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

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

Schema description coverage is 0%, and the description adds minimal parameter context. It implies the default path pattern but does not explain the 'path' parameter semantics or constraints of 'dataset_id'.

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: persist a dataset to a .h5td file. It specifies the default file location and format, and distinguishes from siblings like load_dataset and list_datasets.

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

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

No guidance on when to use this tool versus alternatives such as export_newick or other export methods. The description does not mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It mentions the main action (stochastic tracing) and optional post-processing (missing data, noise). However, it does not state whether the tool modifies the dataset in place, overwrites existing characters, or requires specific permissions. The description is adequate but lacks details on side effects and error conditions.

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 well-structured: a two-sentence summary followed by a detailed parameter list. It front-loads the purpose and provides necessary details for each parameter. While slightly long, the length is justified given the lack of schema descriptions. A minor improvement would be to shorten redundant phrases in the parameter descriptions.

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 8 parameters and no annotations, the description covers the main functionality and parameter semantics. It does not explicitly state preconditions (e.g., dataset must have a simulated tree) or side effects (e.g., modifies dataset). However, since the tool has an output schema, the lack of return-value explanation is acceptable. Overall, it is fairly complete but could be more explicit about dependencies.

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?

Since the input schema has 0% description coverage (only titles, no descriptions), the description's 'Args' section fully compensates by explaining each parameter's meaning and role. For example, it clarifies that 'dataset_id' must contain a simulated tree and defines each simulation parameter. This adds significant value 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's purpose: 'Simulate a lineage-tracing character matrix on a dataset's simulated tree.' It specifies the exact output ('populates obsm["characters"]') and the method ('stochastic Cas9-style tracing'). This distinguishes it from sibling tools like simulate_tree (which creates the tree) or import_character_matrix (which imports existing data).

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 does not explicitly state when to use this tool or when to avoid it. It does not mention prerequisites (e.g., that the dataset must already have a simulated tree) or provide alternatives. The context of sibling tools suggests it is used after simulate_tree, but this is not stated, making it less helpful for decision-making.

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 burden of behavioral disclosure. It explains that the tree is stored in obst[key_added] and is a simulation, but does not discuss side effects (e.g., overwriting), permissions, error conditions, or the fact that it creates a new dataset.

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 well-structured, starting with a clear purpose, then detailing methods and output, and ending with an arg list. It is concise but includes necessary examples. The arg list is slightly redundant with the schema but acceptable.

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 complexity (three parameters, two methods, output schema exists), the description covers purpose, methods, parameters, and the follow-up workflow. It does not detail return values but the output schema fills that gap. Minor omission: no mention of how to retrieve the stored tree.

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

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

With 0% schema description coverage, the description effectively explains the meaning of all three parameters: method options with examples, key_added as the storage key, and extra_options as keyword arguments with sample inputs. This adds significant value 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?

The description clearly states the tool simulates a ground-truth tree topology and registers it as a new dataset, listing two specific methods with examples. It distinguishes itself from sibling tools like simulate_characters by stating that the tree is stored and can be followed by character simulation.

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 for generating synthetic trees and hints at a workflow with simulate_characters, but does not explicitly state when to use this tool versus alternatives such as import_character_matrix or reconstruct_tree. No exclusions or caveats are provided.

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