neurogenesis

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

There are no annotations, so the description carries the full burden. It discloses the ranking mechanism (learned edge weight and trust) but does not indicate whether the tool is read-only, whether it has side effects, or what happens when inputs are missing or invalid. Behavioral context is minimal.

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

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

The description is a single, compact sentence with the core idea front-loaded and no filler. It efficiently communicates the tool's main function and ranking criteria.

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 no annotations and no parameter descriptions, this description is too thin. It fails to explain the role of agent_id, the meaning of limit, the distinction from route_task, or the safety profile. The output schema covers return structure but not the surrounding operational context.

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

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

Schema description coverage is 0%, so the description must compensate. It only indirectly clarifies from_node via 'from a given node'; agent_id and limit are left entirely to their property names. The description adds little meaning beyond the raw 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 specific outcome: recommending the strongest next cognitive steps from a given node, ranked by learned edge weight and trust. It is concrete about the resource and selection criteria, though it does not explicitly contrast with routing siblings like route_task.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. With sibling tools like route_task and record_route_outcome, an agent gets no direction on choosing this tool over those alternatives; usage context is only implied by the name and description.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Free read' explicitly communicates no side effects, and 'Estimates and observations stay distinct' discloses an important data-handling guarantee. It does not mention pagination or authorization, but for a read-only report with an output schema, this is reasonably transparent.

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 dense sentence with no filler. It front-loads the read-only status and then lists concrete content areas. The phrasing is compact and every phrase adds meaning, though 'Landauer-floor context' is somewhat jargon-heavy.

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

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

For a tool with one optional parameter and an output schema, the description covers the core subject matter and read-only nature. However, it omits when-to-use guidance and does not explain how limit affects the report or how this tool relates to get_ledger, leaving meaningful gaps for an agent deciding which tool to invoke.

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 never mentions the only parameter, limit. The schema's title and default value provide minimal meaning, but the description adds no detail about pagination, result caps, or how the limit affects the report, so it fails to compensate for the lack of 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 identifies a read-only reporting tool and enumerates specific content areas: decision/outcome receipts, route modes, compute avoided, predicted savings, predicted-vs-observed coverage, and Landauer-floor context. It is more specific than a generic phrase, but it does not explicitly contrast with siblings like get_ledger or record_route_outcome.

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

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

There is no guidance on when to use this tool versus alternatives such as get_ledger or best_next_steps. 'Free read' implies safe usage, but the description does not state the conditions that should lead an agent to choose this report over other 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?

With no annotations provided, the description carries the full behavioral burden. It clearly discloses that the tool creates an agent, enforces constraints like unique initial_nodes and at least one fitness metric, and returns an agent_id plus initial graph summary. It does not mention persistence or authorization, but the core side effect and response shape are transparent.

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 action, and uses a structured inline list to convey constraints without wasting words. Every element contributes to the agent's ability to invoke the tool correctly.

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 nested genome object, zero schema descriptions, and no annotations, the description covers most of what an agent needs: input structure, validation constraints, and return summary. The output schema covers detailed return shape, and the only notable gap is the undocumented request_id parameter.

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

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

Schema description coverage is 0%, so the description must compensate. It adds substantial meaning to the genome parameter by specifying required fields, uniqueness rules, minimum counts, and optional growth_rules/safety_axioms. The optional request_id parameter is left undocumented, which prevents a perfect score.

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

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

The description states a specific action ('Create a developmental agent') and a clear resource ('from a digital genome'), with the required and optional genome fields enumerated. It is immediately distinguishable from sibling tools like delete_agent, describe_agent, and list_agents because only this one creates.

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 used when constructing a new agent from genome data, but it does not explicitly state when to choose create_agent over alternatives such as import_state. There are no when-not-to-use exclusions or explicit routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It communicates that the action is destructive, but it does not mention irreversibility, side effects on related data, permission requirements, or what happens if the agent does not exist.

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, focused sentence with no filler or repetition. The core action and scope are front-loaded, making it easy for an agent to parse quickly.

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 destructive mutation with no annotations, this description is too thin. It omits behavioral context such as permanence, cascading effects, and the role of 'request_id'. While an output schema exists, the description still leaves important operational context unstated.

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

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

Schema description coverage is 0%, and the description adds no explanation of 'agent_id' or 'request_id'. The parameter names are somewhat self-explanatory, but the optional 'request_id' field is completely unexplained, and the description does not compensate for the low 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 uses a specific verb ('Remove') and names the exact resource ('developmental agent') and scope ('from this mount'). This clearly distinguishes it from sibling tools like create_agent, get_agent, and list_agents, which all have different verbs and 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 states what the tool does but gives no guidance on when to choose it over alternatives, when not to use it, or any prerequisites. For a destructive operation, the lack of boundary conditions or alternative routing is a meaningful gap.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. 'Return' implies a read-only operation, but the description does not explicitly state side-effect profile, permissions, or context limitations. For a zero-parameter introspection tool, the risk is low, so a middle score is appropriate.

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

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

At six words, the description is extremely concise and contains no filler. Every word earns its place, and the main action and target are 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?

Given the tool has no parameters and an output schema exists, the description provides the essential information about what the tool returns. It is somewhat vague about the exact meaning of 'capabilities' and 'input contract', but the output schema likely fills that 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 tool has zero parameters, so there is no parameter documentation to provide. The description correctly avoids adding parameter details; the baseline score of 4 for zero-parameter tools 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 uses a specific verb, 'Return', and identifies the resource as 'capabilities and input contract', clearly stating the tool's function. However, it does not explicitly distinguish itself from sibling tools like get_agent or list_agents, 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?

The description provides no guidance on when to use this tool versus alternatives such as get_agent or list_agents. It only states what the tool does, leaving the agent to infer when it should be selected.

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 burden of behavioral disclosure. It reveals that the output is portable and can be restored in another environment, including a self-hosted installation, which is meaningful context. However, it does not state whether the operation is read-only, what side effects exist, or any permission or state-capture details.

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 front-loads the core concept and adds the portability/recreation detail in a parenthetical. Every clause earns its place, and there is no redundant restating of the tool name or 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?

The tool is simple with one required parameter and an output schema, so the description need not explain return values. It covers the purpose, the restore counterpart, and portability, making it broadly complete, though a bit more detail on the nature of the exported state would close the remaining 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 should compensate, but it never mentions agent_id or explains how to specify which agent's state to export. The phrase 'for an agent' hints at the parameter's role, but it does not clarify the expected value or meaning beyond the schema's bare 'Agent Id' title.

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

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

The description identifies the tool as producing a 'portable state document for an agent' and references import_state as the counterpart that recreates it, which makes the export purpose clear. It does not use an explicit verb like 'exports', but combined with the tool name and the import_state contrast, the action is 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 description gives useful context by explaining that import_state can recreate the document 'anywhere', implying export_state is the tool for capturing portable state. It does not explicitly say when not to use it or name alternative tools for similar tasks, but the workflow relationship with import_state 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?

With no annotations, the description carries the behavioral burden. It does disclose the scope and contents of the returned state, which is useful. However, it does not explicitly state read-only behavior, potential payload size, or any side effects, though the 'get' verb strongly implies read-only.

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

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

The description is a single, well-structured sentence with a clear leading concept ('Full current state') followed by a scannable list of components. There is no filler or repetition.

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

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

For a simple getter with one self-explanatory parameter and an output schema, the description covers what the tool returns. However, the presence of describe_agent as a sibling creates ambiguity about which retrieval tool to use, and the description does not resolve that.

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

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

Schema description coverage is 0%, and the description does not mention agent_id at all. The single parameter is fairly self-explanatory from its name and type, but the description fails to compensate for the schema's lack of textual guidance, which the rubric requires at this coverage level.

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 a retrieval action for an agent and enumerates the specific state components returned: genome, cognitive graph with weights/trust, and summary counts. This distinguishes it from list/create/delete tools, but it does not explicitly differentiate it from the similarly named describe_agent sibling.

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

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

The phrase 'Full current state' implies this tool is for comprehensive state retrieval, but there is no explicit guidance about when to choose this over describe_agent, export_state, or other siblings. No exclusion or alternative routing 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It adds useful facts: the ledger is append-only and entries are returned verbatim rather than transformed or summarized. It does not describe side effects, ordering, or pagination, though the 'get' nature and 'returned' wording strongly imply a read-only operation.

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

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

The description is a single compact sentence that front-loads the resource and its core trait: the append-only developmental ledger. The 'NG3 — returned verbatim' clause is cryptic, but it does not add excessive bulk, and the description remains efficient.

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

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

For a simple read tool with an output schema, the description covers the ledger's content and verbatim return behavior. It is incomplete on parameter semantics and usage guidance, but agent_id and limit are straightforward enough that a basic call can be constructed from the schema and description alone.

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

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

Schema description coverage is 0%, and the description does not mention agent_id or limit at all. The agent must infer that agent_id selects whose ledger to fetch and that limit caps the returned entries; ordering, default behavior, and how the word 'every' relates to a default limit of 100 remain unclear.

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

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

The description identifies the resource as an append-only developmental ledger and enumerates its contents: growth, pruning, and evaluation events with reasons. It is more specific than a generic 'get ledger' and is distinguishable from siblings like get_agent and describe_agent. The action is not explicitly stated as 'retrieves', but 'returned verbatim' and the tool name make the read intent clear.

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

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

The description offers no explicit when-to-use or when-not-to-use guidance, and it does not name alternative sibling tools. The phrasing implies this is for inspecting developmental history, but an agent is not told how this relates to options like export_state, get_agent, or describe_agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether import overwrites an existing agent, creates a new agent, is reversible, or requires special permissions. 'Recreate' hints at mutation but leaves an agent unaware of 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 a single sentence with no filler and front-loads the core operation. However, the brevity comes at the cost of omitting helpful context about behavior and parameters.

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?

Although an output schema exists, this is a state-restoring tool with no annotations and minimal description. A safe invocation requires knowing the relationship to export_state, the expected state structure, and whether the operation is destructive, all of which are missing.

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

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

Schema description coverage is 0%, so the description must compensate for the input schema, but it only indicates that 'state' comes from an export_state document. It provides no structure for the deeply nested state object and no explanation of request_id, leaving most parameter semantics unexplained.

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 operation ('Recreate an agent') and the source ('an export_state document'), which makes the tool's purpose understandable. It does not explicitly differentiate itself from the sibling create_agent, but the use of 'recreate' and the reference to export_state provides meaningful distinction.

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 a restoration workflow from an export_state document and pairs naturally with the export_state sibling. However, it does not explicitly state when to use import_state versus create_agent, nor does it mention prerequisites or alternative selection criteria.

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 conveys that this is a read-only listing operation scoped to the current mount and that summary counts are included, which is reasonable for a simple list tool. It does not discuss authorization, edge cases, or side effects, but the listing nature makes destructive behavior unlikely and the output schema covers return structure.

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 concise phrase with no filler: it names the resource, the scope, and the summary aspect of the result. Every word contributes meaning, and the key differentiator 'all' 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?

Given the tool has no parameters and an output schema exists, the description is largely complete: it specifies what is listed and at what scope. It does not define 'mount' or 'summary counts' in detail, or mention sibling tools, but those are minor gaps for a low-complexity list 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?

The tool has zero parameters and 100% schema description coverage, so the baseline is 4. The description adds the 'mount' scoping context, which is useful even though no parameters exist to document.

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 the resource ('developmental agents'), the scope ('on this mount'), and the output nature ('summary counts'), which makes the tool's purpose reasonably clear. It lacks an explicit verb like 'list' and does not directly contrast with singular siblings such as get_agent or describe_agent, so it falls just 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?

The use case is implied by 'All developmental agents' – an agent needing an overview of every agent would pick this over get_agent or describe_agent. However, the description does not explicitly state when to use this tool versus alternatives or mention any exclusions.

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

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

With no annotations, the description carries the behavioral burden. It clearly discloses append-only semantics, hash-bound uniqueness, one-record-per-decision enforcement, and that omitted metrics remain explicitly unknown rather than becoming zero. It does not describe failure behavior for duplicates, but the core side-effect constraints are well covered.

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 three short, purposeful sentences. It front-loads the core purpose and then adds only necessary constraint information, with no filler or repetition.

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

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

The output schema covers return value shape, and the description covers the most important behavioral constraints. However, for a 7-parameter tool with no annotations, it lacks usage context relative to siblings and leaves the semantics and range of success_score unexplained, so an agent's guidance is incomplete.

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

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

Schema description coverage is 0%, and the description only loosely mentions 'actual cost, latency, and energy' without naming the exact parameters. It does not explain the two required parameters, decision_id and success_score, or the meaning of notes and request_id. The only added parameter value is the optionality/unknown semantics for the metric fields.

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

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

The description states a specific action ('Attach one observed outcome'), a clear resource ('a Wu Wei decision'), and a cardinality constraint ('one ... outcome is allowed per decision'). This makes the tool's purpose distinguishable from sibling tools that create routes or inspect agents.

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 it should be used after a decision has been made and an outcome is observed, but it does not explicitly say when to use this tool versus route_task, submit_evaluation, or get_ledger. No when-not-to-use guidance or alternative conditions are given.

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

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

With no annotations provided, the description carries the full burden. It does add a meaningful behavioral guarantee: routing will not fabricate capacity or energy evidence, which clarifies how registered data is used. But it does not disclose side effects such as whether registration overwrites existing profiles, whether it validates the profile, or what the response contains.

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

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

Two sentences with no filler; the core action is front-loaded and the second sentence adds relevant parameter semantics. It is dense but every clause contributes useful information. The lack of headings or examples prevents a perfect score.

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?

Although an output schema exists and return values need not be described, the tool is incomplete for practical use. The 'profile' parameter is an open-ended object with no concrete structure, no example, and no relationship to sibling tools like route_task or compute_efficiency_report is stated. An agent would struggle to construct a valid profile or understand the registration lifecycle.

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

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

Schema description coverage is 0%, so the description must compensate. It does add substantial meaning for the required 'profile' parameter by listing allowed profile types and declarable attributes (quality, reliability, costs, latency, energy, carbon, cache metrics). However, it does not specify the exact structure, required keys, or formatting of the profile object, and the optional 'request_id' is not described at all.

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

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

The description opens with a specific verb and resource: 'Register a caller-owned Wu Wei execution profile', and enumerates the profile kinds. This clearly names the operation and object, and it is distinguishable from sibling tools like create_agent or route_task. It loses one point because 'Wu Wei' is a domain-specific term that is never explained, but the overall intent is 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?

Usage context is implied rather than explicit. The sentence 'Routing never invents capacity or energy evidence' suggests this tool supplies evidence that routing relies on, so a caller would register profiles before routing. However, the description does not state when to use this over alternatives such as record_route_outcome or compute_efficiency_report, and no when-not-to-use guidance is given.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds meaningful transparency by noting that a no-work decision may be produced, that no result is claimed in that case, and that the return is a hash-bound decision receipt. It does not fully disclose side effects or state changes, but the core decision behavior is well 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 four concise sentences with no filler. It front-loads the main purpose, then adds constraints, optional behavior, and return value information in a logical order. Every sentence contributes distinct 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?

Given the minimal input schema and absent annotations, the description is not complete enough for reliable invocation. It omits operational details such as how to structure the task object, how to express hard constraints, how baselines are supplied, and what request_id does. The output schema exists, but the input-side gaps remain significant.

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

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

Schema description coverage is 0%, so the description must compensate for explaining task and request_id, but it only partially does so. It mentions task-related concepts like baselines and allow_defer/value/urgency fields, yet it never explains the required task object shape, the valid values for these fields, or the purpose of request_id. The compensation is insufficient for a low-coverage 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 a specific verb and resource: choosing the least-burden eligible route for a task. It also enumerates hard constraints, making the tool's purpose unambiguous and distinguishable from siblings like record_route_outcome or compute_efficiency_report.

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 state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. It describes optional behavior around allow_defer/value/urgency fields, but that is not tool-selection guidance. An agent is left to infer when route_task is the appropriate sibling to call.

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 explicitly states the mutation effects: success strengthens used edges, failure weakens them, and growth/pruning follow genome rules under safety axioms. It also discloses that new developmental-ledger events are returned. Minor gaps remain around idempotency and whether repeated submissions are allowed, but the core behavior is well covered.

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

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

The description is compact and front-loaded, with each sentence earning its place: the purpose and input format, the behavioral effects, and the return value. Some jargon such as 'NG1' and 'developmental-ledger events' is not expanded, but the overall structure is efficient and readable.

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 complex tool with a nested object and no annotations, the description covers the essential invocation details: evaluation fields, success/failure consequences, safety constraints, and return type. Since an output schema exists, return formatting need not be spelled out. The main remaining gaps are request_id semantics and the relationship to record_route_outcome.

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

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

Schema description coverage is 0%, so the description must compensate. It does a good job for the evaluation object by listing task_id, task_type, success_score range, and optional fields. However, agent_id and request_id receive no explanation, and request_id's purpose remains ambiguous beyond having a null default.

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 a specific verb and resource: evolving an agent based on a task outcome, and it enumerates the exact evaluation fields and their meanings. It distinguishes itself from siblings like record_route_outcome by describing a full agent evolution process, though it does not explicitly name or contrast sibling tools.

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

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

There is no explicit guidance on when to use this tool versus record_route_outcome or other sibling tools. The phrase 'with one task outcome' implies it is meant to be called after a task with evaluation results, but no exclusions, prerequisites, or alternative routing are provided.

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