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

No annotations are provided, so the description must fully disclose behavioral traits, but it does not. 'IRB Neural Welfare Check' only vaguely suggests a read-only assessment; it does not state side effects, permissions, failure modes, or 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?

The description is extremely short, but this is under-specification rather than effective conciseness. There is no structure, no verb, and no explanatory content beyond a label-like phrase.

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 no output schema and no annotations, the description needed to explain what the check returns and how it relates to sibling tools. Instead it leaves the agent guessing what 'IRB Neural Welfare Check' means in practice, making selection and invocation unreliable.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is nothing to document. The description adds no parameter semantics, but none are needed. The baseline 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 is a noun phrase, 'IRB Neural Welfare Check,' rather than a sentence with a verb and object. It hints at an ethics/welfare inspection but does not clearly say what the tool does or returns. The name itself already contains 'check,' so the description mostly restates the tool's name in different words.

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

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

There is no guidance about when to use this tool versus the many sibling status/check tools such as get_system_status, get_acm_score, or get_snn_state. No conditions, prerequisites, or alternatives 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?

With no annotations at all, the description must disclose side effects, output behavior, and access requirements, but 'Full State Snapshot' says nothing about whether the operation is read-only, what format is returned, whether data is persisted, or whether it requires special privileges. This is a total gap in behavior disclosure for a no-annotation tool.

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

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

The description is extremely short, but this is under-specification rather than conciseness. It is a single noun phrase with no structure and no breakdown of behavior, output, or use cases. It does not earn its place because it conveys almost no useful information beyond the tool name.

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 absence of annotations, output schema, and parameter info, the description carries the whole burden of explaining the tool. 'Full State Snapshot' leaves the agent completely without context on what state is included, what the output looks like, how it differs from sibling state/status tools, or whether it is safe to call. The definition is inadequate for reliable selection and 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?

The tool has zero parameters, and the input schema shows an empty properties object. Since there are no parameters to document, the description does not need to add parameter semantics; the baseline of 4 applies. The description adds no param detail, but none is required.

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 'Full State Snapshot' is a noun phrase echoing the tool name 'export_snapshot' with no verb, leaving unclear whether the tool exports, returns, or saves a snapshot. It does not differentiate itself from siblings like get_snn_state, get_system_status, or wm_status, all of which could plausibly provide state-related information. This is closer to a tautology than a functional description.

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

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

No usage context is provided. The description offers no guidance on when to call export_snapshot versus alternatives such as get_snn_state, get_system_status, or get_platform_status. The agent is given no basis for deciding between overlapping sibling tools.

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

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

With no annotations, the description carries the burden and does add value: it says the tool explains comparability and explicitly treats incomparability as a valid partial-order result rather than a deficiency. It does not disclose return format, error behavior, or side effects, though a compare operation is naturally 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?

Two tight sentences; the first front-loads the action and expected output, the second preempts a common misconception. No filler.

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

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

For a two-parameter tool with no output schema, the description conveys the result's semantic content (ordering or incomparability) and the subtle partial-order interpretation. It stops short of specifying the exact returned shape, but the agent has enough to select and invoke it correctly.

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

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

Schema coverage is 100% and both parameters already have clear descriptions with examples; the description adds only the 'species–function pair' context. That meets the baseline but supplies no parameter-level meaning 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?

States a specific operation ('Compare') on a specific resource ('two species–function pairs') and the expected output (why they are ordered or incomparable). It doesn't explicitly distinguish itself from fcs_taxonomy or fcs_conformance, but the compare action is clearly unique among siblings.

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

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

The description implies the obvious use case—whenever an agent needs the ordering relationship between two species–function pairs—but it provides no explicit when/when-not guidance or alternatives among the many fcs_* siblings. There are no exclusions, but nothing steers an agent away from similar 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, the description carries the full burden; it discloses that the tool binds live IRB welfare biomarkers (Ca²⁺, ATP/ADP, firing rate, viability) to taxonomy classes and that it returns a category profile rather than a scalar score. It does not explicitly state whether the operation mutates state, though 'Audit' and 'Returns a profile' strongly imply 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?

Three dense sentences, front-loaded with the core action and scope; every clause adds a distinct piece of information (scope, result categories, biomarker binding, output type). 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 6-parameter, no-output-schema tool, the description conveys the conceptual output (four category types) and how live biomarkers feed the taxonomy, which is enough to invoke the tool correctly. It does not sketch the profile's concrete shape or interaction of biomarkers with substrate selection, so a little more structure would make it fully complete.

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?

Because schema coverage is only 33%, the description compensates by mapping each biomarker parameter to its taxonomy class (Ca²⁺ → class 1, ATP/ADP → class 7, firing rate → class 3, viability → class 2b). It also clarifies substrate semantics ('one substrate — or all three') but leaves calciumNm, atpAdpRatio, firingRateHz, and viabilityPct without unit or format details.

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

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

States a specific verb ('Audit') and resource ('one substrate — or all three — against the seventeen species–function pairs'), and enumerates exactly what the result reports (realised/simulated/absent/undeterminable). The closing qualifier 'never a conformance score' disambiguates it from its own name and from sibling tools like fcs_report or fcs_compare.

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 'one substrate — or all three' tells the agent when the tool applies and that omitting substrate audits all, and 'returns a profile, never a conformance score' warns against using it as a scoring tool. It does not explicitly name sibling alternatives or state when not to use it, so it stops short of a 5.

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

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

With no annotations and no output schema, the description carries full responsibility for disclosing behavior. It does not state whether the tool is read-only, what the return format looks like, whether pagination or ordering matters, or if any side effects or prerequisites exist. The description covers content but not call-time behavior.

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

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

The description is a single dense sentence that front-loads the framework name and immediately lists the four levels, followed by the specific attributes returned. Every phrase adds information, and there is no redundancy or filler.

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

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

For a read-only reference tool without an output schema, the description adequately enumerates what the caller receives: formalism, epistemic status, complement reading, implementing ASTRA modules, and the remaining gap. It is sufficient for an agent to understand the tool's domain, though it would benefit from noting that it returns a structured list or document.

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

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

Schema coverage is 100% for the single optional parameter, and the schema already documents the enum values and that omission returns all four levels. The description reinforces the level-specific nature of the content but does not add meaning beyond what the schema provides, warranting the baseline 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 clearly identifies the tool's subject—a four-level framework—and enumerates the specific details it provides (formalism, epistemic status, complement reading, ASTRA modules, gaps). However, it lacks an explicit verb like 'retrieve' or 'describe', requiring inference that this is a read-only informational tool.

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

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

No guidance is given on when to use this tool versus the many related siblings (fcs_taxonomy, fcs_report, fcs_stratify, fcs_compare). It does not state what differentiates fcs_levels from these alternatives or suggest conditions under which an agent should select it.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Screen' implies an inspection/validation action rather than a mutation, and the description names the criteria, but it does not state whether the tool returns violations, throws, or is side-effect free. This leaves the outcome behavior under-specified.

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

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

Two short sentences, front-loaded with the action and scope, then a crisp usage trigger. No redundant filler or repetition of schema 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?

The schema fully documents parameters, but there is no output schema and no description of the return/result format or what the caller should do when a prohibition is violated. For a lint/validation tool this is a meaningful gap, though the invocation trigger is clear.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description adds only the high-level mapping of string/aggregation/inference to the parameters, not additional syntactic or semantic detail, which matches the baseline 3.

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 'Screen' and enumerates the three kinds of inputs (string, aggregation, constitutive inference) and the rule set (five prohibitions). It is not a tautology and gives a concrete idea of the operation, though it does not name a sibling tool to differentiate from, and 'series' negative heuristic' is domain jargon.

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

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

'Use before emitting any user-facing claim that touches the FCS layer' is a clear, actionable trigger for when to call this tool. It does not list exclusions or alternatives, so it stops short of a full when-not/alternative statement.

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

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

With no annotations, the description carries the transparency burden. It clearly discloses a key behavioral constraint: the report carries no aggregate score because 'prohibition 4 forbids one.' The 'status' framing implies a read-only report, and the enumeration of what is and is not included gives agents a good behavioral picture, though side effects, auth, and output format are not explicitly addressed.

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 dense but efficient, front-loading the core 'Consolidated ... status' concept before listing report sections. The final sentence adds a valuable caveat without padding. It could be slightly better structured for readability, but every element earns its place.

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

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

For a report tool with one optional parameter and no output schema, the description gives a detailed inventory of the report's contents and an important exclusion (no aggregate score). Together with the parameter schema, this is sufficient for an agent to know what invoking fcs_report will produce, though it does not describe output format or usage alternatives.

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 for the single optional parameter useLiveBiomarkers is 100%, and the schema description already explains its meaning and default. The tool description adds no parameter-specific information, so it stays at the baseline 3 for high schema coverage.

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

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

The description states exactly what the tool is: a consolidated substrate-constrained functionalism status report, and enumerates its contents (four-level framework, core/belt partition, seventeen species–function pairs, conformance audit, prohibitions, revision order). The noun 'status' plus the tool name 'report' make the operation clear, but it does not explicitly distinguish itself from the specialized fcs_* siblings (e.g., fcs_taxonomy, fcs_conformance).

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 word 'Consolidated' implies this is the umbrella status report versus the more specialized sibling tools, and the caveat 'Carries no aggregate score of any kind' tells agents when not to expect an aggregate result. However, no sibling tools are named and there is no explicit when-to-use or when-to-use-alternative guidance.

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

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

With no annotations, the description carries the transparency burden. It discloses that the tool recomputes, reports a yes/no-style reproducibility result, and that the τ cuts alter the resulting order. It stops short of explicitly stating whether state is mutated or describing the output format, but the analysis-oriented wording makes the behavior understandable.

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 carry the full purpose, the scientific context, the default behavior, and the parameter rationale. No filler; the most important information is front-loaded.

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

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

For a one-optional-parameter tool with no output schema, the description is nearly complete: it states what is computed, what is reported, and the meaning/effect of the only parameter. The only real gap is the precise return structure, but the prose indicates a reproducibility verdict.

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

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

Schema coverage is 100% and the schema already defines tauCutsLog10 as ascending decimal-exponent cuts defaulting to [-1, 0]. The description adds real value by mapping those cuts to 10⁻¹ s and 10⁰ s, naming the conscious-episode window, and explaining why changing the parameter is meaningful.

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

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

The description names a precise action and resource: recompute the partial order by Pareto dominance over the three ordinal sub-criteria and report whether it reproduces the eight strata from document IV §3. This is specific and distinguishes fcs_stratify from sibling tools like fcs_compare or fcs_conformance.

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 conveys that the default τ cuts reproduce the published window and that changing the parameter changes the order, which is the point of exposing it. It implies a validation/sensitivity use case but never explicitly says when to prefer this tool over a sibling or when not to call it.

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

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

With no annotations, the description carries the behavioral burden. It adds useful interpretive context, notably that ordering is by functions rather than substances and that one species may occupy two distant positions. However, it does not explicitly state that the tool is read-only, how filter parameters affect results, or what a default (unfiltered) call returns.

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

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

The description is compact and front-loaded with the core content. The second sentence adds a conceptually important clarification about ordering and multi-membership. Every sentence earns its place with no filler.

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

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

For a query tool with three optional filters and no output schema, the description conveys the conceptual payload but omits practical details: how filters combine, what an unfiltered response looks like, whether pairId is required for single-pair retrieval, and the expected output format. It is adequate but leaves clear 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 100%, so each parameter (role, pairId, stratum) is already documented in the schema. The description mentions causal role and Pareto stratum, which map to two of the three filters, but it does not add meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly identifies the resource: a taxonomy of thirteen molecular classes expressed as seventeen species–function pairs, with the relevant attributes enumerated. It does not use an explicit action verb like 'returns' or 'lists', and it does not explicitly distinguish itself from sibling tools, but the subject matter and content are unambiguous.

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

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

No guidance is given about when to use this tool versus alternatives such as fcs_stratify, fcs_levels, fcs_compare, or fcs_report. The description implies a read/query operation but does not state conditions, exclusions, or preferred usage contexts.

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, and it does useful work: it discloses that unset outcomes remain undetermined and never collapse to a negative, and it explicitly flags the asymmetry that a favourable human grain outcome does not corroborate M2. These are non-obvious interpretive rules beyond what a schema could convey. It stops short of stating side effects or read-only guarantees, but for an evaluation tool the disclosed rules are substantial.

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: two sentences, no filler, and the core evaluation purpose is front-loaded. The density of jargon makes it less accessible, but every sentence contributes either the core behavior or critical caveats.

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?

This is a moderately complex tool with 8 parameters, no annotations, and no output schema, yet the description does not explain the output shape, how to interpret the result beyond broad categories, or which parameter drives the M2 asymmetry. It gives the conceptual model but not enough operational detail for an agent to invoke it correctly with specific inputs. The missing parameter mapping and absent use-case guidance leave clear 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% and there are eight undocumented boolean/null parameters, so the description must compensate by explaining their meaning. It provides general outcome semantics and one indirect reference to a 'human grain outcome', but it never maps parameter names like bridgeCovariation or fieldBeyondFiringInHumans to the concepts being evaluated. The agent is left to guess which parameter corresponds to which thesis.

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 operation ('Evaluate the protective belt against experimental outcomes') and the concrete questions it answers: which theses are withdrawn, stand, or are undetermined. It is not a tautology and reads as distinct from sibling tools like fcs_report or fcs_taxonomy. However, terms like 'protective belt' and 'M2' rely on domain jargon, so a general-purpose agent would need more framing to fully understand the resource.

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

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

There is no guidance about when to call this tool versus similar fcs_* siblings such as fcs_stratify, fcs_compare, or fcs_conformance. The description implies a use case (after experimental outcomes exist) but gives no conditions, prerequisites, or exclusions. This is a significant gap given the large sibling list.

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 the tool is read-only, what kind of score it returns, how the proxy is computed, whether there are side effects, or what the response contains. 'Consciousness Assessment (Proxy)' is a label rather than a 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?

The description is extremely short and front-loaded, but this is under-specification rather than effective conciseness. It reads as a title or label rather than a usable tool description, and the parenthetical 'Proxy' is the only substantive hint.

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 no annotations, no output schema, and a nontrivial domain of sibling tools, the description is far too incomplete. An agent cannot determine what ACM means, what the proxy is based on, what value will be returned, or how this differs from related assessment and status tools.

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

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

The tool has zero parameters and the schema is empty, so there are no parameter semantics for the description to clarify. The baseline for a zero-parameter tool is appropriate here; the description adds no parameter information but none is needed.

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

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

The description names the resource ('Consciousness Assessment') and adds the qualifier 'Proxy,' which suggests an indirect measure. However, it lacks a verb and does not explain what ACM stands for or what the proxy actually represents, leaving the purpose somewhat vague and not clearly differentiated from sibling tools like get_system_status or get_metrics.

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. The description does not mention any context, prerequisites, or exclusions, and the 'Proxy' hint is too underspecified to count as usable usage direction.

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 full responsibility for disclosing behavior. It hints at a real-time read operation, but does not state whether the tool is read-only, what side effects it might have, how data is scoped, or what 'metrics' refers to.

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 only two words long and is under-specified rather than efficiently complete. It contains no verb, no object, and no supplementary detail, so it does not earn credit for conciseness.

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

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

A zero-parameter tool still needs context about what it returns and how it differs from at least the most similar siblings. There is no output schema and no clarification of what counts as 'metrics,' making the description inadequate for reliable tool selection.

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 nothing for the description to clarify. The empty input schema covers all parameter semantics by construction, earning the baseline score of 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?

The description 'Real-time Metrics' is a noun phrase rather than a statement of what the tool does. It restates the tool name ('metrics') with the modifier 'real-time,' but never specifies a verb or resource, and it does nothing to distinguish get_metrics from sibling tools like get_system_status or get_platform_status.

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

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

There is no guidance on when to use get_metrics versus any of the many sibling getter tools. The phrase 'Real-time' weakly implies current data, but no context, exclusions, or alternative conditions are provided.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, and it discloses nothing beyond the phrase 'Bio-Computing Platforms'. It does not indicate whether this is a read-only status check, what output to expect, or whether any side effects occur.

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

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

The description is short but under-specified; the phrase 'Bio-Computing Platforms' does not earn its place because it conveys no actionable information. This is not effective conciseness but rather a lack of content.

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

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

Even for a zero-parameter tool, the description is incomplete: it fails to state the tool's purpose, behavior, output, or relationship to sibling status tools. An agent cannot reliably decide when to call this tool based on the provided definition.

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

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

The input schema has zero parameters and 100% schema coverage, so no parameter descriptions are necessary. The description adds no parameter semantics, but there is no parameter gap to compensate for.

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 'Bio-Computing Platforms' is a noun phrase with no verb or explicit action, so it does not state what the tool does. The agent must infer 'get status' entirely from the tool name. It also provides no differentiation from status-related siblings like get_system_status or wm_status.

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

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

There is no guidance about when to use this tool versus alternatives such as get_system_status, get_metrics, or wm_status. The description gives no context, prerequisites, or exclusions that would help an agent choose correctly.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. 'SNN Engine State' reveals nothing about whether the call is read-only, what state information is returned, or any 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 brief, but brevity here is under-specification rather than effective conciseness. It lacks a verb, purpose statement, or any structural elements that would help an agent act on it.

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 no output schema and no annotations, the description should explain what 'SNN Engine State' actually contains and when the tool is useful. It does neither, leaving an agent without enough context to call it correctly or interpret its result.

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

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

The tool has zero parameters and the schema coverage is 100%. With no parameters to document, the description does not need to add parameter-level detail, earning the baseline score of 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?

The description is a noun phrase, 'SNN Engine State', that essentially restates the tool name without a verb. It does not clearly state what the tool does or how it differs from sibling status tools like get_system_status or wm_status.

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

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

There is no guidance on when to call this tool versus alternatives. Among many sibling status/state tools, no context is provided to help an agent select this specific tool.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but it only names the resource. It does not state whether the call is read-only, what kinds of status data are returned, whether any side effects occur, or whether authentication or system state dependencies 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 short, but it is under-specified rather than efficiently concise. It contains no predicate, no operational detail, and no information that would help an agent 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?

Although the zero-parameter schema keeps the call simple, the absence of an output schema, annotations, and behavioral context leaves an agent uncertain about the return format and the distinction from overlapping system-status tools. The single phrase does not provide a complete picture.

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

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

The input schema has zero parameters and 100% schema description coverage, so there are no parameter semantics to clarify. The description does not add anything, but no parameter explanation is needed.

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

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

The description 'ASTRA System Status' is a noun phrase that essentially restates the tool name 'get_system_status' with the product prefix, rather than stating a specific action and resource. It does not differentiate the tool from the sibling 'get_platform_status', which appears to overlap in purpose.

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

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

No guidance is provided about when to use this tool instead of siblings such as get_platform_status, get_metrics, or get_snn_state. There is no context about typical scenarios, 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does not state that this operation modifies the network state, whether the effect is reversible, whether it requires a running simulation, or what side effects it may have. The description only names the operation without describing any behavior.

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

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

The description is extremely short, but this is under-specification rather than conciseness. A concise description would use few words while packing meaningful information; this one simply restates the tool name. No useful content is front-loaded because there is no content.

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

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

For a tool that presumably manipulates a neural simulation, the description is far too minimal. It lacks any indication of effect, required state, parameters, or relationship to the surrounding toolset. With no output schema and no annotations, a two-word description leaves the agent without enough context to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description adds no meaning to the parameters. It does not explain what neuronIds refers to, what strength controls, how strength interacts with neuronIds, or what typical usage looks like. The raw schema provides types and ranges, but the description contributes nothing to parameter understanding.

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 'Spike Injection' is a noun phrase that simply restates the tool name without a verb or resource. It does not explain what the tool does, what 'spikes' are injected into, or what the outcome is. This is a tautology that fails to distinguish the tool from its siblings.

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

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

The description gives no indication of when to use this tool versus any of the many sibling tools such as snn_step, set_parameter, or simulation_control. There is no mention of contexts, prerequisites, or exclusions. An agent has no guidance on when inject_spikes is the appropriate choice.

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

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

With no annotations, the description must fully disclose behavior, but it only hints at the output ('descriptor + viability'). It does not state whether the operation is read-only or has side effects, nor does it mention permissions, rate limits, or failure modes.

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 short, but it is under-specified rather than concise. It reads as a fragment and omits essential information such as the action performed, making it less useful despite its brevity.

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?

Without an output schema, the description should explain what 'descriptor + viability' means in return terms, but it does not. It also fails to clarify whether this is a capture or retrieval operation, leaving major gaps in understanding the tool's purpose and behavior.

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

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

Schema coverage is 100% for the single parameter 'mea', which is fully described with constraints and default. The tool description adds no additional parameter meaning, but the schema already handles it, so baseline 3 is appropriate.

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

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

The description lacks a clear verb; 'Last MEA camera capture' is a noun phrase, so it's unclear whether the tool performs a capture or retrieves the last capture. It mentions the resource (MEA camera) and output (descriptor + viability), but does not explicitly state the action or distinguish from sibling tools like sensor_visual.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, use cases, or exclusions, leaving the agent without context for selecting it appropriately.

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

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

No annotations are present, so the description must disclose side effects and safety. It mentions optional SNN driving and ethics coupling, which hint at state changes, but does not explain whether the operation is read-only, modifies the organoid/SNN state, or what side effects occur.

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

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

A single sentence, front-loaded with the platform name and core concept. Every word contributes; no filler.

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

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

The tool is moderately complex with 4 parameters and no output schema, yet the description provides only a high-level pipeline. It doesn't explain expected return values, invocation behavior, or how parameters affect the closed loop, leaving the agent under-informed.

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

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

The schema covers 75% of parameters with descriptions. The description rarely references the parameters: 'optionally drive the SNN' corresponds to drive_snn, but window_ms and drive_strength are not addressed. The description adds minimal 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 identifies a closed-loop coupling action ('read organoid → couple to ASTRA fusion/ROS/ethics, optionally drive the SNN') but lacks an explicit verb naming the operation (e.g., 'run', 'trigger', 'configure'), making it ambiguous what invoking the tool does. It partially differentiates from siblings by mentioning ASTRA/ROS/ethics, but the purpose remains vague.

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

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

No guidance is provided on when to use this tool versus alternatives like np_send_trigger or inject_spikes. The description implies a closed-loop use case but does not state conditions, exclusions, or alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Define, validate & upload.' It does not mention side effects on hardware, permission requirements, reversibility, error behavior, or confirmation of successful upload, so the agent is left guessing about what actually happens.

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

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

A single sentence that is concise, front-loaded with the action, and contains the key domain context. There is no wasted text.

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

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

Despite a rich schema, the description is too sparse for an 11-parameter hardware-upload tool with no annotations and no output schema. It does not describe what the tool returns, how uploads are confirmed, failure modes, or prerequisites, so the agent would lack essential context for reliable 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?

Schema description coverage is 82%, so the parameters are mostly self-documenting with units, defaults, and ranges. The description adds the context of 'charge-balanced biphasic stimulation' but does not elaborate on how parameters interact or what 'validate' means for the charge-balance constraint.

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 set ('Define, validate & upload') and names a concrete resource ('StimParam (charge-balanced biphasic stimulation)'), clearly distinguishing this hardware-configuration tool from siblings like np_send_trigger or np_count_spikes.

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

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

No guidance is provided on when to use this tool versus alternatives, no prerequisites, and no exclusions. The description implies an upload/configuration action but does not explain when an agent should choose it over related np_* 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, the description must disclose behavior (e.g., read-only, side effects, required permissions). It only says 'Closed-loop', which is vague and does not clarify whether the operation is safe or part of an active control loop. No behavioral traits are explained.

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 and does not waste words. It is front-loaded with the tool name and purpose, though the phrasing is somewhat awkward.

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 only two parameters and no output schema, so the description does not need to be lengthy. However, it lacks context about the meaning of 'closed-loop' and does not explain what the tool returns (e.g., a list of electrode counts). This leaves gaps for a non-expert agent.

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

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

Schema coverage is 100% with both 'top_k' and 'window_ms' having descriptions. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly indicates a spike-counting function over a time window ('spikes per electrode over an N-ms window'). However, it does not explicitly differentiate from the similar sibling tool 'np_query_spike_count', and the phrase 'Closed-loop _count_spike' is somewhat cryptic.

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

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

No guidance is provided about when to use this tool versus alternatives such as 'np_query_spike_count' or 'np_query_spike_events'. There is no mention of conditions, 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, the description must carry the full burden of behavioral disclosure. It mentions 'NeuroPlatform v2 DB' and 'query', implying a read-only database operation, but it does not explicitly confirm read-only behavior, side effects, output format, or performance characteristics. Minimal contextual information beyond the tool's existence.

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 immediately conveys the tool's purpose, data source, and key output metric, using a clear front-loaded structure.

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 and has no output schema. The description communicates the core output concept (spikes/minute per electrode) but omits details about the exact return structure, defaults, or how window_sec and nonzero_only affect the response. It is adequate for a basic query tool but leaves room for interpretation.

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 descriptions cover fsname and window_sec, while nonzero_only lacks a description. The tool description's phrase 'over a time window' adds context to window_sec, but it does not explain nonzero_only or add meaning to fsname beyond the schema. With 67% schema coverage, the description only partially compensates for the missing parameter explanation.

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

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

The description defines the tool as a 'SpikeCountQuery' returning 'spikes/minute per electrode over a time window', clearly identifying the resource (spike counts per electrode) and the computation. However, it lacks an explicit verb like 'queries' or 'returns', and while it differentiates from event-based tools such as np_query_spike_events, it does not clearly distinguish from the similarly named np_count_spikes.

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 usage guidance is provided. The description does not state when to use this tool instead of siblings like np_query_spike_events or np_count_spikes, nor does it mention prerequisites, limitations, or alternative scenarios.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool returns spike timings over a window, but does not explain whether the window is relative to current time, how limit affects results, or what fsname refers to. This lacks the detail needed to anticipate tool behavior.

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

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

The description is a single sentence with no fluff, making it concise and front-loaded with the core concept. It is not overly verbose, but it could be slightly more structured by explicitly naming parameters or the action. Still, it earns a high score for conciseness.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description is too brief. It does not describe the return format, the meaning of the parameters beyond 'window', or any edge cases or limitations. The tool may be simple, but the description lacks essential context for reliable use.

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

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

Schema description coverage is only 33% (only window_sec has a schema description). The description adds minimal context by mentioning 'over a window,' which aligns with window_sec, but it says nothing about limit or fsname. Thus, it does not sufficiently 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 clearly states the tool returns 'individual spike timings over a window,' which identifies the resource (spike events) and distinguishes it from sibling count tools like np_count_spikes and np_query_spike_count. However, the verb is implied by the tool name ('query') rather than explicitly stated, and there's no explicit differentiation from other spike-related queries.

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 conditions, prerequisites, or comparisons to siblings such as np_query_spike_count, np_count_spikes, or np_query_triggers, leaving the agent without direction for tool selection.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It does not state whether the operation is read-only, what the return format is, or whether there are side effects. It only labels the query without adding context beyond the schema's window and dedup parameters.

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 brief and front-loaded, with no filler or redundant content. It sacrifices behavioral detail for brevity, but as a one-phrase description it is efficiently structured.

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

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

The description lacks an output schema and provides no usage context, leaving gaps about response contents and differentiation from sibling tools. The parameter schema is strong, but the description alone is incomplete for an agent deciding whether to call this 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 100% with both parameters (dedup and window_sec) having clear descriptions, so the description adds no extra parameter semantics. Baseline 3 is appropriate since the schema handles parameter documentation.

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

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

The description clearly identifies the tool as a query for triggers sent to an organoid over a window, distinguishing it from trigger-sending tools like np_send_trigger. However, it lacks an explicit verb (e.g., 'Lists' or 'Retrieves'), relying on the noun phrase 'TriggersQuery'.

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

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

No guidance is provided on when to use this tool versus alternatives like np_query_spike_events or np_query_spike_count. The description does not mention use cases, 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, the description carries full responsibility for behavioral disclosure. It does not explain side effects, safety, reversibility, permissions, or what happens when triggers are fired (e.g., hardware activation). This is a significant gap for a tool that likely has physical or system-level consequences.

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 and concise, but it uses jargon ('NeuroPlatform v2', 'StimParams', '16-bit trigger array') that might reduce clarity. It is not verbose, and every word adds some information, though the structure could be improved by separating context from action.

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 a simple schema but no output schema and no annotations. The description is insufficient for an agent to understand the full context: it lacks return behavior, side effects, prerequisites, and integration with sibling tools. For a trigger-sending tool, this is a notable 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 schema description covers 100% of parameters with clear descriptions for 'repeats' and 'triggers'. The description adds the context of 'uploaded StimParams' and '16-bit trigger array', which gives some extra meaning, but the schema already provides sufficient parameter documentation. Baseline 3 is appropriate.

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

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

The description clearly states the tool fires triggers and executes uploaded StimParams via a 16-bit trigger array, using specific verbs like 'fire' and 'execute'. While it doesn't explicitly distinguish from siblings, the purpose is understandable, though the meaning of 'execute uploaded StimParams' could be clearer for an agent.

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 like np_configure_stim or np_query_triggers. It does not mention prerequisites (e.g., StimParams must be uploaded first) or when not to use it. The context is implied but not stated.

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

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

With no annotations, the description must carry the burden of disclosing behavior. The word 'Status' weakly implies a read-only operation, but the description does not explicitly state that it returns information, what information it provides, or whether any side effects exist. It adds very little beyond the tool's name.

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 short, but this is under-specification rather than effective conciseness. A single noun phrase without a verb or context does not earn its place; it reads like a title, not a functional description. There is no structure that helps an agent understand the tool's purpose.

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

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

Given the presence of numerous sibling status tools, the description is not complete enough to disambiguate. It fails to explain what 'Platform & Controller' encompasses, what output to expect, or how this differs from get_system_status, get_platform_status, or other status tools. The lack of annotations and output schema makes this minimal description insufficient.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and there is no schema information to supplement. It cannot add value beyond the empty schema, so the baseline score holds.

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

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

The description is a noun phrase ('Platform & Controller Status') rather than a clear verb-action statement. It implies the tool reports status but does not explicitly state what it does (e.g., 'Retrieves current platform and controller status'). It also does not distinguish this from several sibling status tools like get_system_status, get_platform_status, or ovo_status.

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

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

There is no guidance on when to use this tool or how it differs from alternatives. With several status-related siblings, the description should mention that this is the go-to for platform/controller health or clarify its scope, but it omits any such context.

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

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

Without annotations, the description carries the burden of behavioral disclosure. It does reveal that the mass-displacement scale is exposed as a free parameter and that a sensitivity sweep is performed, which is helpful. However, it does not mention whether the tool is read-only, any side effects, or the return format (no output schema exists), leaving some ambiguity.

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 packs in the formula, the free parameter, and the sweep behavior without any filler. Every phrase contributes to understanding.

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 specialized scientific computation with three parameters and no output schema, the description provides the core formula and main behavior, but it does not specify the output structure, error conditions, or how the sweep results are presented. Given the complexity and lack of output schema, a bit more detail would make it more self-contained.

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

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

The schema already covers all three parameters with descriptions, but the description adds meaningful context by naming the mass-displacement scale (separationM) as the free parameter and indicating the tool sweeps across orders of magnitude. This supplements the schema by clarifying the intended use of the parameters.

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

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

The description clearly identifies the tool as computing Penrose's objective-reduction criterion τ = ℏ/E_G, with the mass-displacement scale exposed as a free parameter and a sensitivity sweep. It uses a formula rather than an explicit verb, which is slightly less direct, but the scope is well-defined and distinguishes it from related sibling tools like orch_decoherence.

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

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

The description implies that this tool is for sensitivity analysis via the sweep across four orders of magnitude, but it does not explicitly state when to prefer this over sibling tools or exclude alternatives. No direct comparison to orch_decoherence or other tools is provided.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It says the tool 'run[s] a TCAI cycle' and 'pass[es] the workspace competition through the gate', implying state changes, but it only mentions reporting a count. No info on side effects, prerequisites, reversibility, or failure behavior is provided.

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

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

The description is two sentences with no wasted words. It packs a lot of information into a compact format and ends with a clear statement about the report. Well-structured for the amount of content it conveys.

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 complexity of the operation, the absence of annotations, an output schema, and any explanation of the parameter, the description is incomplete. It does not clarify what 'epoch-quantised surrogate gate' means, prerequisites, or why this composite cycle exists versus calling sibling tools separately.

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

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

The only parameter, 'controllability', is completely unexplained in both the schema and the description. Schema coverage is 0%, and the description does not mention the parameter at all. The agent has no way to know what values to supply or the effect of the parameter.

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

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

The description clearly states a specific orchestrated action: reading an OVOMIND affect frame, running a TCAI cycle, and passing the workspace competition through a surrogate gate. This involves distinct verbs and resources, and the mention of the 'epoch-quantised surrogate gate' helps differentiate it from sibling tools like tcai_cycle or ovo_cycle. However, heavy jargon limits universal clarity.

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 composite use case but does not explicitly explain when to prefer this tool over alternatives like tcai_cycle, ovo_cycle, or orch_gate_config. No exclusion or alternative guidance is given, leaving the agent to infer usage from the action list.

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 describes the computation but does not disclose whether it has side effects, requires specific conditions, or what exact output format/residual gap means. It doesn't mention error behavior or assumptions. The description adds minimal behavioral context beyond the calculation itself.

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 words. It efficiently packs the key information: the quantity (decoherence time budget), the scope (target coherence window), the models compared, and the residual gap. Every part earns its place.

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

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

The tool has one optional parameter, no output schema, and no annotations. The description gives the core purpose but lacks details about the return value, interpretation of the residual gap, or edge cases. It is minimally viable for an expert but leaves gaps for an automated agent that needs to know what to expect as output.

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

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

The input schema has one parameter, requiredCoherenceS, with 0% description coverage. The description mentions 'target coherence window' which arguably maps to the parameter, providing some semantic context. However, it doesn't explicitly explain units, constraints, or how the parameter affects the calculation beyond what the schema already states (exclusiveMinimum: 0). The parameter name is self-explanatory, so the description adds limited value.

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 computes a decoherence time budget for a target coherence window, comparing Tegmark (2000) with the Hagan/Hameroff/Tuszyński (2002) correction and reporting the residual gap. This is a specific, concrete function that distinguishes it from sibling tools like orch_criterion or orch_gate_config, which address different aspects.

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. No exclusions, no alternative tool names, no context like 'use when X'. The only hint is 'for a target coherence window', but no comparison to 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?

With no annotations provided, the description carries the full burden. It discloses the mechanism (epoch-quantised, stochastic tie-break) and an important limitation (surrogate only, not real Orch OR). However, it does not mention side effects, persistence of configuration, or interaction with other system components.

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

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

The description is two sentences with no fluff. The first sentence front-loads the tool's action and subject, while the second adds a key caveat. Every word earns its place.

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

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

Given 4 optional parameters and no output schema, the description covers the core purpose and a key limitation but lacks information on configuration effects, validation, or return values. It is adequate for a simple config tool but has clear 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%, so the description must compensate, but it only indirectly hints at parameter roles (e.g., epochMs for 'epoch-quantised', tieBandFraction for 'stochastic tie-break'). It does not explicitly explain each parameter's meaning, default, or behavior, leaving significant ambiguity for an agent.

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 ('Enable or configure') and resource ('classical surrogate gate'), and adds technical specificity ('epoch-quantised ignition with stochastic tie-break'). The caveat about not instantiating objective reduction distinguishes it from related Orch 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?

Usage is implied: this is the tool for enabling/configuring the surrogate gate. The statement that it does not instantiate objective reduction gives an exclusion, but no explicit alternatives are named among the many sibling tools (e.g., actual reduction 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 must fully disclose behavior. It lists the report's contents, which helps set expectations for the output, but does not explicitly state whether the tool is read-only, triggers any computation, or has side effects. For a status report, this is a moderate gap in transparency.

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

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

The description is a single sentence that front-loads the key concept 'Consolidated Orch OR status' and then efficiently lists four specific report components in a structured, comma-separated manner. It avoids unnecessary verbosity, though it is slightly dense with jargon.

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

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

For a zero-parameter report tool with no output schema, the description provides a fairly complete indication of what the report contains: epistemic standing, Penrose criterion, decoherence budget, and verdicts for three substrates. It is sufficient for an agent to know what to expect, though terms like 'theory epistemic standing' could be clearer to a new agent.

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, as shown by the empty properties in the input schema, so the description does not need to explain parameter behavior. The baseline for a zero-parameter tool is 4, and the description adds no parameter-related information, which is acceptable.

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

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

The description clearly indicates this is a consolidated status report for Orch OR, enumerating specific contents: theory epistemic standing, Penrose criterion, decoherence budget, and ASTRA substrate verdicts. It distinguishes from sibling tools like orch_criterion or orch_decoherence by covering multiple aspects in one report, though it lacks an explicit action verb like 'retrieves' or 'generates'.

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 word 'Consolidated' implies this is the summary/overview tool, suggesting use when a high-level status is needed rather than detailed per-substrate data. However, there is no explicit guidance on when to prefer this over siblings or any exclusions, so usage context is implied but not clearly defined.

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 bears the full burden of disclosing side effects and operational characteristics. It does not state whether the tool is read-only, computationally expensive, requires specific permissions, or how it interacts with ASTRA's channel beyond the output components. The description focuses on content rather than behavior.

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

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

The description is a single sentence with no wasted words, listing the key output components in a compact structure. While it is efficient, the sentence is somewhat dense and would benefit from a clearer subject-verb-object structure to improve readability.

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 complexity of the domain (Orch OR, ASTRA, multiple optional parameters) and the lack of an output schema and annotations, the description is insufficient for an agent to confidently call the tool. It does not explain the semantics of the optional parameters, the expected return format, or enough context about the 'verdict' to interpret results. The description is a minimal stub rather than a complete usage guide.

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

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

The schema has 0% description coverage, so the description must explain parameter meaning and usage. It explicitly references only 'substrate' via the phrase 'for one substrate'; the other parameters (neuronCount, channelLatencyMs) are not mentioned. The description does not clarify whether these parameters influence the verdict or how they relate to the listed output components.

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 specifies that the tool provides an 'Orch OR verdict for one substrate' and enumerates the components (tubulin budget, epochs, reasoning), which distinguishes it from sibling tools that operate on different scopes or criteria. However, it lacks an explicit verb like 'retrieves' or 'computes', and the jargon (Orch OR, ASTRA's channel) is not explained, making the purpose somewhat opaque.

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 'for one substrate' implies that this tool is appropriate when a verdict for a specific substrate is needed, offering a context hint. However, it does not explicitly state when to use it over alternatives (e.g., orch_report, orch_criterion) or provide any exclusionary 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 present, so the description must carry behavioral disclosures. It reveals important consequences (arming places a human in the control loop) and a refusal condition. However, it does not describe disarming effects, success/failure outcomes, or any safety or side-effect details beyond the refusal.

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

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

The description is two sentences, with the core action front-loaded and the important consequence/precondition following. No word is wasted; it is compact and structured effectively.

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 (one boolean parameter), but the description lacks several contextual details: what constitutes a 'protocol reference', how it is provided (not in the schema), what happens after successful arming/disarming, and what the return/response is. This could leave an agent uncertain about prerequisites and outcomes.

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

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

Schema coverage is 0%, and the schema only specifies a boolean named 'arm'. The description adds meaning by mapping the boolean to 'arm or disarm', which clarifies true/false semantics. It does not explicitly map boolean values to arm/disarm, but the phrase 'Arm or disarm' strongly implies it.

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 as 'Arm or disarm closed-loop affective actuation,' using a specific verb and resource. It distinguishes itself from siblings like ovo_set_policy or ovo_cycle by focusing on the arming state, and adds context about placing a human in the loop.

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 (toggling the armed state) and mentions a precondition ('refused without a protocol reference'), but it does not explicitly compare to alternatives or state when-not-to-use. No exclusion or alternative guidance 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?

The description discloses one important behavioral trait: the human valence is NOT routed to rewardSignal. However, it omits other behavioral details such as side effects, state changes, or prerequisites for running the cycle, leaving the agent to infer the full impact.

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 brief and front-loaded, consisting of two sentences that state the core action and a key exception. It avoids filler but uses domain jargon without explanation.

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, no output schema, and a non-trivial execution (running a cycle), the description is too sparse. It doesn't explain return values, side effects, or how this tool relates to sibling tools, making it incomplete for safe autonomous 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?

The input schema covers 'actuate' but leaves 'controllability' undescribed, and the tool description doesn't elaborate on either parameter. With only 50% schema description coverage, the description should compensate but doesn't, leaving the agent without semantic clarity on the parameters.

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

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

The description clearly states the tool reads one affect frame and runs a TCAI cycle, with the human channel as 'body' specialist. It adds a specific behavioral exception (valence not routed to rewardSignal), which differentiates it from generic TCAI/OVO siblings, though it doesn't name alternatives.

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

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

No explicit guidance on when to use this tool versus alternatives like tcai_cycle or ovo_read. The description implies a specific use case (human affect frame processing with a routing exception) but doesn't provide exclusions or alternative recommendations.

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 full transparency burden. It mentions the caveat but does not disclose whether the tool is read-only, has side effects, requires authorization, or what output format to expect. This is a significant gap for a tool with no output schema.

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

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

A single, information-dense sentence that efficiently introduces the substrates, the comparison axes, and the caveat. Every clause adds value with no filler or redundant wording.

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 captures the core concept of comparing three substrates and the caveat, which is substantial for a 0-parameter tool. However, it does not specify what the tool actually returns (e.g., a report, a boolean, a rating), and without an output schema, that gap matters.

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 parameter-specific explanation is unnecessary. The description adds conceptual context about the comparison axes and caveat, but since there are no parameters, the baseline of 4 applies.

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

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

The description clearly states the tool performs a 'side-by-side comparison' of three named substrates (silicon SNN, organoid MEA, human wearable) feeding a PAD pipeline. It specifies the comparison axes and the caveat, distinguishing it from generic status or read 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?

The purpose implies when to use the tool—when a comparison of substrate constraints is needed—but there is no explicit 'use instead of' or exclusions. Sibling tools like orch_substrate or ovo_read could conceptually overlap, but no 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 takes on the responsibility of behavioral disclosure. It reveals return value details ('Every axis is returned with its epistemic tier, provenance and basis string') and a key constraint ('Dominance is never estimated from the human channel'). The verb 'poll' implies a non-mutating read. However, it doesn't disclose whether the call blocks, any prerequisites, or error behavior.

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

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

Three short sentences, each provides distinct information: the action, the return details, and a behavioral caveat. There is no filler or repetition; the core purpose is front-loaded in the first sentence.

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

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

The tool lacks an output schema, so the description's explanation of returned fields is valuable. However, it omits the meaning of the only parameter (controllability), provides no usage context, and does not address edge cases or call semantics (e.g., blocking, defaults). This is a significant gap for a simple tool with one 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?

The schema defines one parameter, 'controllability' (number 0-1), but the schema description coverage is 0% and the description does not mention this parameter at all. An agent has no way to infer what 'controllability' controls or how it affects the read. With zero schema descriptions, the description must compensate but fails to do so.

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 'Poll' with a defined resource 'OVOMIND affect frame' and states it 'lift[s] it into PAD'. It also clarifies what is returned ('Every axis is returned with its epistemic tier, provenance and basis string'). This distinguishes it from siblings like ovo_status or ovo_cycle, though it doesn't explicitly name alternative 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?

The phrasing 'Poll one OVOMIND affect frame' implies this is the tool to use when you need to read affect data in PAD format, but it does not provide explicit when/when-not conditions or mention alternative tools. No exclusions or conditional usage 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, the description carries full responsibility for behavioral disclosure. It only states the action 'Configure' without mentioning side effects, reversibility, authorization requirements, or whether changes take effect immediately or persist. This is a significant gap for a mutation tool.

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

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

The description is a single sentence, front-loaded with the verb and object, with no redundant or extraneous information. It is concise and well-structured.

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

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

For a configuration tool with 5 optional parameters and no output schema, the description is too brief. It omits essential context such as the effect of setting these policies, whether protocolReference is required to arm the control loop, and how this tool relates to the broader OVO workflow.

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 only 20% (only protocolReference has a description). The description mentions the two policies but does not map them to specific parameters like dominancePolicy or controlEnabled, nor does it explain the enum values or the role of maxStepPerCycle. It adds minimal 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 uses the specific verb 'Configure' and identifies two clear targets: the Russell→PAD dominance policy and the closed-loop control policy. This differentiates it from sibling tools like ovo_status or ovo_read, though it does not explicitly mention alternatives.

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

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

There is no guidance on when to use this tool versus related tools such as ovo_arm_control or set_parameter. No prerequisites, conditions, or context are provided, leaving the agent to infer usage from the name alone.

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

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

The description lists the kind of status data returned but does not state whether the operation is read-only, has side effects, or requires any setup. With no annotations provided, the description carries full responsibility for behavioral disclosure, and it falls short by not confirming it is a safe, non-mutating status check.

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 and front-loads the core concept 'OVOMIND bridge status'. It is efficient, though the dense jargon ('adapter mode', 'substrate descriptor', 'synthetic-phenomenology ethics assessment') could be clearer.

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 no output schema, the description should explain what the returned status looks like. It lists the categories of information but does not provide format, units, or examples. This is acceptable for a status tool but lacks completeness for a fully self-contained description.

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

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

There are zero parameters, so the baseline for this dimension is 4. The description correctly does not add parameter-specific information since none exist.

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

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

The description clearly states the tool reports OVOMIND bridge status, listing specific components (adapter mode, substrate descriptor, frame counters, ethics assessment). This distinguishes it from generic status tools like get_system_status or get_metrics, though it lacks an explicit verb like 'retrieve' or 'get'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description implies it is for OVOMIND-specific status, but it does not mention when not to use it or compare to sibling tools such as ovo_read or tcai_self_model.

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 present, the description carries the burden of behavioral disclosure. It does reveal the transformation stages (Waveform → Mel → Latent), which is useful, but it does not disclose whether audio capture is real or simulated, whether the operation has side effects, whether it requires a microphone, or what the returned latent representation looks like.

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 and front-loads the core purpose and pipeline with no filler. It is more of a title than a full explanatory sentence, but every element earns its place and there is 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?

For a tool with a nested input object, no output schema, and no annotations, the description is too thin to be fully actionable. It explains the processing pipeline but omits critical context such as expected output format, capture behavior, simulation behavior, and relationship to sibling sensor or encoding tools.

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

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

The input schema is well-structured with defaults, ranges, and descriptions for some parameters, so the schema carries most of the parameter semantics. The tool description does not add any explanation of how parameters like source, channels, durationMs, or sampleRate affect the encoding, but the high schema coverage keeps this at the baseline 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 identifies a specific operation (A-JEPA audio encoding) and a clear processing pipeline from waveform to mel to latent. It clearly marks this as the audio sensor tool among siblings such as sensor_visual and sensor_olfactory, though it does not explicitly state what the encoded latent is used for.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like sensor_fuse, sensor_process, or wm_encode. Usage is only implied by the tool name and the phrase 'Audio Encoding', with no conditions, exclusions, or references to 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. 'Cross-Modal Attention Fusion' offers only a conceptual hint and does not state whether the operation is read-only, mutates state, depends on prior sensor data, or returns a result. This is insufficient for an agent to anticipate 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 only three words and technically concise, but it is under-specified rather than efficiently informative. It reads as a title, not as a tool description, and every necessary behavioral or semantic detail is absent.

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 no annotations, no output schema, and no parameter explanation, the description leaves almost everything unspecified. An agent cannot tell what inputs to supply for a desired behavior, what the tool returns, or what effects it has on the system. The definition is not actionable.

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 includeAudio, includeVisual, or includeOlfactory. It adds no meaning about how these booleans affect fusion, such as modality selection, weighting, or output shape. The description completely fails to compensate for the absence of parameter documentation.

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 'Cross-Modal Attention Fusion' is a noun phrase rather than a clear verb-resource statement. It mostly restates the tool name and adds the vague qualifier 'attention,' leaving unclear what action the tool performs or what outcome it produces. It does not meaningfully distinguish sensor_fuse from sibling tools like sensor_process or sensor_visual.

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

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

There is no guidance about when to use sensor_fuse versus alternatives such as sensor_process, sensor_visual, sensor_audio, or sensor_olfactory. No use case, prerequisites, or exclusions are described, so an agent cannot determine the appropriate invocation context.

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

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

There are no annotations, so the description carries the full burden. It only states a conceptual pipeline ('Chemoreceptor → Latent'), with no mention of side effects, return value, simulation state changes, or requirements such as a running platform. This is too opaque to predict tool behavior.

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

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

The description is extremely short, which is good for speed, but it is under-specified rather than concise. It omits core behavioral information that a few extra sentences could safely supply, so brevity costs clarity.

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

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

For a tool with a nested input object, no output schema, and zero annotations, the one-phrase description leaves almost everything unknown: input semantics, output shape, and operational side effects. It is inadequate for an agent to decide whether and how to invoke this tool correctly.

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

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

Schema coverage is 100% and all subparameters have explicit types, defaults, enums, and ranges, so the baseline is 3. The description adds only the general chemoreceptor→latent framing and does not explain how individual parameters affect the encoding, but compensation is not required given full 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 names a specific capability (olfactory encoding via Koniku Kore, chemoreceptor → latent) and therefore distinguishes itself from the visual/audio/fuse/process/status siblings. However, it is a noun-phrase title rather than a verb+resource sentence, so it does not explicitly state what action the tool performs or what it returns.

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 sentence explains when to use this tool versus sibling sensor tools. It implies olfactory use through the word 'olfactory', but offers no exclusions, prerequisites, or alternative routing. The agent must infer usage from the name alone.

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

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

There are no annotations, and the description adds no behavioral details beyond the label 'Full Multimodal Pipeline (All Modalities → Fused z)'. It does not mention side effects, state changes, whether simulation is always used, what happens to existing sensor data, or any prerequisites for calling this tool.

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

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

The description is extremely terse and front-loaded, using a clear arrow notation to show the transformation from inputs to fused output. No filler words are present, though the brevity leaves room for important details that are handled in other dimensions.

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 no annotations, no output schema, many similarly named sibling tools, and three parameters, this description is far too sparse to be complete. An agent cannot know when to choose this tool, what invocation entails, or what the 'Fused z' output looks like.

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

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

Schema description coverage is 100%, so the schema already explains each parameter. The description's reference to 'All Modalities' loosely maps to compounds, visualSource, and audioFrequency, but it does not add any detailed semantic meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly identifies this as a full multimodal pipeline that takes all modalities and produces a fused output 'z'. It conveys the core operation and is distinct from individual sensor tools like sensor_visual, sensor_audio, and sensor_olfactory, though it does not clearly distinguish itself from sensor_fuse.

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

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

No guidance is provided about when to use sensor_process versus the sibling tools such as sensor_fuse, sensor_visual, or sensor_olfactory. The description implies it handles everything at once, but there are no explicit conditions, alternatives, 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. The description does not state whether the tool is read-only, whether it has side effects, what data it accesses, or what the status covers. It provides zero behavioral context beyond the name.

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 terse, consisting of a four-word noun phrase. While there is no fluff, it is under-specified to the point of being unhelpful. A concise description must still contain an actionable verb and enough detail to guide invocation; this does not.

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

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

For a zero-parameter status tool, the description still leaves major gaps: no indication of what the status output contains, whether this covers the entire pipeline or a subset, or how it relates to sibling tools like sensor_fuse and get_system_status. The lack of an output schema increases the need for the description to explain return values, which it fails to do.

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

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

The tool has zero parameters, and the input schema confirms this. With no parameters to explain, the description cannot add parameter meaning, and the baseline for a zero-parameter tool is 4. The description does not harm this dimension, but it also adds nothing extra.

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 'Multimodal Sensor Pipeline Status' is essentially a noun phrase restating the tool name. It lacks a verb like 'get' or 'retrieve' and does not distinguish this tool from siblings such as get_system_status, get_metrics, or sensor_fuse. It communicates a subject (multimodal sensor pipeline) but not the action or exact scope.

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

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

No guidance is provided on when to use this tool over alternatives. The sibling list includes get_system_status, get_metrics, and various sensor_* tools, but the description does not mention any context, exclusions, or conditions that would help an agent pick this tool.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the model family and input modality, but does not mention whether this is a read-only computation, what side effects exist, what the output representation is, or how parameters such as simulate and videoFrames affect behavior.

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

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

The description is extremely short and contains no filler, but it is under-specified rather than effectively concise. It is a fragment with no sentence structure and no front-loaded action or output expectation.

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 no output schema and no annotations, the description should explain what the encoding returns and how the tool behaves, but it only names the model and modality. The nested input object and the image/video distinction are left entirely to the schema, so an agent cannot reliably understand the result or invocation 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?

The schema has 100% parameter documentation coverage, including descriptions for simulate and videoFrames, so the schema carries the explanatory load. The description itself adds no additional parameter meaning beyond the image/video distinction that videoFrames already expresses.

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 this as V-JEPA 2 visual encoding and mentions image/video input, which weakly distinguishes it from sensor_audio and sensor_olfactory. However, it is a noun phrase rather than a clear statement of what the tool does, and it does not specify what kind of output the encoding produces.

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 guidance on when to use this tool versus alternatives such as sensor_process, sensor_fuse, or sensor_status. The intended context is only implied by the word 'visual,' with no exclusions, conditions, or named alternatives.

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

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

With no annotations, the description must carry the full burden of disclosing side effects and expectations. "Modify" conveys mutation, but there is no information about whether changes persist, affect a running simulation, require reset, or return any confirmation.

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

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

The phrase is short, but under-specification is not conciseness. A single vague clause omits essential context while adding no distinctive content, so the structure does not earn 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?

Given no annotations, no output schema, and no parameter documentation, this description is far from complete. An agent cannot know which state parameter paths are valid, what value changes do, or what the result of the call is.

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 undocumented path and value fields. It does not: it only repeats the generic modify/parameter idea and gives no hint about path format, value range, allowed values, or units.

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?

"Modify State Parameter" essentially restates the tool name set_parameter rather than adding specific meaning. It identifies a verb and resource but does not clarify what kind of state parameter is affected, leaving the tool indistinguishable from other state-related tools like simulation_control or snn_step.

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 guidance on when to use this tool versus siblings such as simulation_control, snn_step, or wm_train_step. There are no conditions, exclusions, or alternative tools mentioned, so an agent has no basis for routing to this tool.

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

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

No annotations are provided and the description discloses no behavioral traits. It does not say whether start/stop mutate simulation state, whether status is read-only, or whether commands have side effects or prerequisites.

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 only two words, which is concise but not effectively structured. It reads as a title and provides no front-loaded information that helps an agent decide to invoke the tool.

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

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

For a tool that controls simulation lifecycle, the description is far too incomplete. There is no output schema, no annotation coverage, and no explanation of command effects, return behavior, or failure conditions.

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 meaning beyond the parameter name "command" and its enum values. The enum provides some self-documentation, but the description itself does not compensate for the low 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 is exactly "Simulation Control", which restates the tool name. It does not state what action the tool performs, what simulation resource it affects, or what outcome the commands produce.

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

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

There is no guidance about when to use this tool versus alternatives like get_system_status, snn_step, snn_reset, or get_platform_status. An agent would have to infer all usage context from the command enum alone.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. 'Reset' implies a state-changing, likely destructive operation, but the description does not say whether it clears all SNN state, whether it is reversible, or whether it interrupts ongoing simulation. This is a notable gap for a reset 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 exceptionally concise at three words and is front-loaded with no filler. However, it adds little beyond the tool name itself, so it is efficient but not richly informative.

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

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

For a zero-parameter tool this is simple to invoke, but the absence of any note about side effects, reset scope, or relationship to the SNN lifecycle leaves the description incomplete. An agent cannot confidently determine the consequences of calling this tool.

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

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

The tool has zero parameters, so the input schema already fully covers invocation needs. The baseline of 4 is appropriate; no parameter documentation is required.

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 'Reset SNN Engine' uses a specific verb and resource, and the action is clearly distinct from sibling tools like snn_step or get_snn_state. It is not a tautology, though it gives no detail on what 'reset' encompasses.

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, no mention of prerequisites, and no indication of whether it should be run before or after other operations. The description simply states the action without any contextual direction.

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 present, the description carries the full burden and only says 'Advance SNN Simulation'. It does not disclose whether this mutates simulation state, is reversible, requires any precondition, or what the return/response looks like.

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, front-loaded, and contains no filler words. It is appropriately compact for a simple tool, though it is too terse to convey parameter semantics or effects.

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 parameter, no output schema, and no annotations, the description is not complete enough: it leaves the meaning of 'steps', side effects, and the relationship to siblings unstated. An agent can take the core action but may mis-invoke the parameter or confuse it with simulation_control.

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

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

The schema describes one parameter, 'steps', with type, default, and bounds, but the description does not explain that the value is a count of simulation steps or how it affects behavior. Since schema description coverage is 0%, the description should compensate but does not.

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

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

The description states a specific action, 'Advance', applied to 'SNN Simulation', so an agent can tell this tool moves the simulation forward. It does not, however, contrast with the sibling simulation_control or snn_reset, which could also relate to simulation progress.

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

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

No guidance is given about when to use this tool versus alternatives like simulation_control or snn_reset. There are no exclusions, prerequisites, or context hints to route the agent to the correct sibling.

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

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

With no annotations, the description carries the transparency burden. It explains the conceptual meaning of the telemetry values and their principled nature, but it does not explicitly state whether the operation is read-only, if it has side effects, or if it requires specific system state. The term 'telemetry' implies a read, but operational details beyond output semantics are missing.

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

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

The description is two sentences, with the main point front-loaded ('Active-inference core telemetry') followed by a precise, colon-separated list of contents. The second sentence adds essential context (halting criterion, principled vs. heuristic) without waste. Every clause earns its place.

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

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

Given no output schema and no annotations, the description provides rich conceptual context by naming and explaining each telemetry field (F, G(π), task quality, entropy, action) and its role in halting. It stops short of specifying the exact return format, units, or data types, which would make it fully complete for an agent.

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 0 parameters, so the baseline is 4 per the rubric. The description adds no parameter info because none exist, but it enriches the understanding of what the returned data means, which is useful for interpreting the output.

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

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

The description clearly identifies the tool as 'Active-inference core telemetry' and lists specific quantities (F, G, task quality, entropy, action), making the resource and scope clear. It distinguishes itself from heuristic correlates by stating it is the 'principled quantity' for halting, but lacks an explicit verb like 'get' or 'return', which keeps it from 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 explicitly states this telemetry is what the halting criterion thresholds on, providing a clear when-to-use scenario. It also says 'not a heuristic correlate', implying it should be preferred over heuristic metrics, though it does not name specific alternative 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, the description carries the full burden. It discloses the main behavior: running warm-up cycles, recording |ΔF|, computing the median, and setting epsFreeEnergy. It also states the return values. It does not mention side effects beyond setting the threshold, but this is the core effect and is clearly stated.

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 sentences, each carrying meaningful information: purpose, mechanism, and rationale. It is front-loaded and avoids redundancy or filler.

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

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

For a calibration tool with no output schema, the description provides the algorithm, the formula, the return values, and the reason for existence. It is sufficiently complete for an agent to know what will happen and what to expect.

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

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

Schema description coverage is 100%, so baseline is 3. The description uses the parameter names in context (e.g., 'runs cycles warm-up cycles', 'factor× their median') but does not add new semantic information beyond what the schema already provides for each parameter.

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

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

The description opens with a specific action: 'Calibrate the halting threshold on the measured ΔF scale instead of a guessed constant.' This clearly states what the tool does and distinguishes it from sibling tools, which are not about threshold calibration.

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 'instead of a guessed constant' and the reference to the 'v2.9 critique' indicate when to use this tool: when a data-driven threshold is preferred over a fixed default. It does not explicitly name alternative tools, but the context is clear enough.

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. It explains the internal model (action→expected-valence map) and the two query modes, implying a read-only operation, but it does not explicitly state side-effect freeness, output format, or error behavior. For a simple query tool, this is adequate but not rich.

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, tightly written sentence that front-loads the core capability and uses no filler. Every phrase contributes meaning, from the parenthetical port reference to the two-mode usage explanation.

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 no output schema, the description adequately covers the two main use cases and the underlying semantics. It is sufficiently complete for an agent to invoke it correctly, though it does not spell out the exact return structure or edge-case handling. Given the tool's simplicity, this is a good level of 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?

The schema description coverage is 100% for the sole 'action' parameter, but the description adds key semantic value by clarifying that omitting the action lists the entire capability table. This goes beyond the schema's description of 'Action label to query expected valence for' by explaining the optionality and fallback behavior.

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 ('Query') and resource ('expected outcome of an action' or 'learned capability table'), and it is distinguishable from siblings like tcai_memory_retrieve or tcai_self_model by referencing the action→expected-valence map (EMA). The mention of 'DirectExperienceLearner port' adds specificity.

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 outlines two distinct usage modes: querying a specific action's expected valence, or listing the full capability table when no action is provided. This provides clear context for when to use the tool, though it does not explicitly name alternatives or exclusions. It is not misleading, just lacks a formal 'when not to use' statement.

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

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

With no annotations, the description carries the full burden of transparency. It discloses the dual get/set behavior, the exact multi-criteria halting condition (free energy, task quality, epistemic value, patience), and explicitly notes that stationarity alone is insufficient. This is rich behavioral context, though it omits details about persistence or effects of updates.

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

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

The description is two sentences long and front-loaded with 'Inspect or configure', immediately stating purpose. Every clause contributes meaningful information: modes, halting condition, and a qualifying note about stationarity. No wasted words or repetition of schema 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?

Given the tool has no output schema and no annotations, the description covers the query mode (returns state and thresholds) and the full halting logic, which is the tool's core complexity. It does not describe the exact return format, but that is a minor gap for a configuration tool with well-schemaed parameters.

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

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

Schema coverage is 100% with descriptive parameter names and defaults, so the baseline is 3. The description adds value by showing how the parameters interrelate in the halting condition (e.g., all conditions must be sustained over patience cycles), which goes beyond the individual parameter descriptions and clarifies their combined semantics.

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

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

The description uses a specific verb 'Inspect or configure' with a clear resource 'recursive double-loop halting criterion (v2.9)', immediately distinguishing it from sibling tools like tcai_metrics or tcai_memory_retrieve. It also clearly defines two modes of operation (no args = query, with args = update), leaving no ambiguity about what the tool does.

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

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

The description explains exactly when to call it: with no arguments to retrieve the current satisfaction state and thresholds, and with arguments to update them. It also states the full halting condition, giving context for when this tool would be relevant. However, it does not explicitly name alternative tools or provide exclusion criteria, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects and state changes. It explains the computation and the default broadcast source but does not state whether the tool is read-only, whether the predictor is updated, or what the return value is. This is a significant transparency gap for a tool that may have internal state.

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

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

The description is compact, front-loaded with the core concept, and efficiently conveys the algorithm, interpretation, and default. The use of jargon (RND, EFE, GNW) adds density but does not waste words.

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 no output schema and only one optional parameter, yet the description does not explain the return format (e.g., a scalar value). It provides good conceptual context but leaves out practical details about what the agent can expect as a result, making it adequate but 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?

The schema covers 100% of parameters, with the 'embedding' property described as 'Representation vector (defaults to current broadcast)'. The description reinforces the default behavior but adds no new semantic information beyond what the schema already provides.

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

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

The description clearly identifies the tool as an intrinsic-reward/curiosity mechanism based on prediction error, referencing RNDCuriosity and explaining the high-error-equals-novelty relationship. It distinguishes itself from sibling tcai tools by its specific algorithm and purpose, though it lacks an explicit verb like 'computes' or 'returns'.

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 exploration or novelty-seeking ('exploration drive (EFE epistemic value proxy)') but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions. The usage context is present but not fully articulated.

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

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

With no annotations, the description carries the full burden. It discloses the internal processing pipeline and the early-halting condition, which adds useful behavioral context. However, it does not explicitly state whether the cycle mutates external state (e.g., writes emotional memory or updates the self-model) or what side effects the agent should expect.

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

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

The description is two sentences, front-loaded with the core action, then provides the pipeline flow and the key stopping parameter. Every sentence earns its place 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?

The tool is complex with 17 parameters and no output schema, and the description gives a good high-level explanation but does not mention what the tool returns (e.g., metrics, satisfaction state, or status). Given the schema's strong parameter coverage, the description is minimally viable but leaves output behavior unspecified.

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 82%, so the baseline is 3. The description adds meaningful semantics for stopWhenSatisfied, explaining that it halts early on a sustained satisfactory regime. This goes beyond the schema's basic property description, earning a 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?

Description uses a specific verb ('Run') and resource ('ACM cycles') and clearly differentiates the tool by listing the full pipeline stages (SNN signals, AKOrN binding, GNW ignition, etc.), which distinguishes it from sibling tools like tcai_second_order or orch_cycle.

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 context for the operation and explains when to set stopWhenSatisfied, but it does not explicitly state when to prefer this tool over alternatives such as tcai_second_order or orch_cycle. Usage guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden. It discloses the output dimensions (stage, stability, meta-representation score) and the behavioral trait of 'second-order self-monitoring over time.' It does not explicitly state whether the operation is read-only or whether it modifies any state, but 'tracking' implies a non-mutating observation.

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, consisting of two sentences. It front-loads the core purpose and then lists specific outputs. The parenthetical 'DevelopmentTracker port' adds context but is slightly unnecessary; overall, the description is efficient and free of filler.

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

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

For a zero-parameter tool with no output schema, the description covers the essential aspects: what it does, what it produces, and its temporal nature. It does not specify return formats or units, but the low complexity makes this acceptable. The lack of sibling differentiation is a minor 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 the schema provides no parameter information. The description adds context about the data source ('running composite-proxy level') and outputs, which adequately compensates for the lack of parameters. The baseline of 4 for zero-parameter tools is appropriate.

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

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

The description clearly states the tool's function: longitudinal developmental tracking with specific stage progression (nascent→reactive→integrative→reflective) and derived scores. It distinguishes itself from sibling tools by emphasizing temporal tracking and second-order self-monitoring, though it lacks an explicit verb like 'get' or 'retrieve'.

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 through 'longitudinal' and 'over time', suggesting it is for tracking development rather than one-off queries. However, there is no explicit guidance on when to use this tool versus alternatives like tcai_second_order or tcai_meta_learning, and no exclusions or conditions are stated.

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

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

With no annotations provided, the description must disclose behavioral traits fully. It mentions 'inertia' implying statefulness or temporal dependency, but does not explain side effects, return format, or whether it modifies internal state. The absence of explicit behavioral disclosure is a significant gap.

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

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

The description is a single, tightly packed sentence with no redundant words. It front-loads the core purpose and the key behavioral nuance (inertia), making it highly efficient.

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

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

Given the absence of an output schema, annotations, and parameter descriptions, this tool description is incomplete. It does not explain return values, how parameters interact, or what 'inertia' entails operationally. The agent would struggle to correctly invoke and interpret 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%, so the description must compensate by explaining the four parameters. However, it only refers to 'raw signals' without mapping to threat, novelty, rewardSignal, or controllability. Parameter meanings are left to name inference, which is insufficient for an agent.

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 'Appraise' and clearly states the transformation into PAD emotional space (Mehrabian), which distinguishes it from sibling tcai tools focused on memory, curiosity, or meta-cognition. The inclusion of 'with inertia' further indicates a unique temporal aspect.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only states what it does, without specifying scenarios, prerequisites, or exclusions, leaving the agent to infer applicability.