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

With no annotations, the description carries the burden. It clearly indicates the action is owner-governed (authorization) and that the grant is issued, implying a state change and potentially side effects. It mentions optional narrowing of rights, persistence, and world-mutation, which are useful behavioral traits. It lacks detail on reversibility or audit trails, but the core behavior is disclosed.

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

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

The description is a single succinct sentence that front-loads the purpose and then adds optional capabilities. No wasted words; every clause adds meaning.

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 this is a mutating tool with zero annotations and no output schema, the description should explain authorization requirements, expected parameters, and potentially the effect of each option. It only covers high-level behavior and leaves key parameters unexplained. An agent would struggle to call it correctly.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It only hints at 'optionally narrowing rights / persistence / world-mutation', which vaguely corresponds to rights, persistenceMode, and worldMutation. It completely omits requestId and sessionId, which are likely critical for identifying the request and session. This is a significant gap.

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 ('Approve') with a clear resource ('pending access request on a space you own') and adds the outcome 'issuing the grant'. It distinguishes from siblings like noetic.deny_request and noetic.grant by focusing on approving a request, though it could be clearer about the distinction from noetic.grant.

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

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

It states the tool is for approving pending access requests, implying it is used after review. It mentions 'a space you own', indicating the ownership requirement. However, it doesn't explicitly compare to deny_request or grant, so an agent might confuse it with grant. The context is present but exclusions are missing.

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. 'Dry-run' usefully signals that no permission change is made, and 'probe' suggests a read-only check. However, it does not explain failure modes, return behavior, or whether an existing session is required, leaving gaps.

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 single sentence is front-loaded and contains no filler, so it is concise. It is, however, under-specified for a tool with three undocumented parameters, making it concise but not fully appropriately sized.

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 0% schema description coverage, the description is far too thin. It omits parameter meanings, return format, prerequisites, and selection criteria, so an agent cannot reliably invoke it.

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

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

Schema description coverage is 0%, and the description does not compensate. It does not define 'target,' 'operation,' or 'sessionId,' nor does it explain how they relate to the permission probe. An agent cannot derive parameter semantics from either source.

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 function: 'Dry-run permission probe for an in-scope target.' This is more than a tautology and conveys the tool's core purpose. However, it does not distinguish itself from sibling tools like noetic.check_rights, so it misses the top score.

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 when-to-use guidance is provided. There is no mention of when to choose this over noetic.check_rights, noetic.request_access, or noetic.grant, and no exclusion criteria. The only hint is the phrase 'dry-run,' which implies it is for non-mutating checks.

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. 'Discover' implies a non-mutating operation, but the description does not state what happens if scope is absent, whether a session is required, whether results are filtered by permissions, or what kind of output is returned.

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 worded sentence with no filler or repetition. However, its brevity is more under-specification than effective conciseness, since important usage and parameter context are 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?

The tool is simple in structure, but the description leaves key context undefined: what 'scope' means, how sessionId factors in, and what the returned capability vocabulary looks like. With no output schema and no annotations, the description does not give an agent enough to invoke it confidently.

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

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

The schema describes a single optional sessionId with no description, and schema description coverage is 0%. The tool description never mentions sessionId or explains how it affects the discovery, so the agent receives no semantic help beyond the bare parameter name and type.

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 and resource: 'Discover' the 'grantable capability vocabulary within scope.' This conveys a clear read-like exploration action and distinguishes it from sibling tools such as grant, revoke, or check_rights, though it does not explicitly 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?

There is no guidance about when to call this tool versus alternatives like noetic.discover, noetic.territory, or noetic.check_rights. The phrase 'within scope' hints at a dependency on context but does not explain how to establish or interpret that scope.

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 carries the full burden of behavioral disclosure. It does not state whether this operation reads, writes, mutates, or persists state, nor does it mention side effects, permissions, or reversibility. 'Reference' is too vague to inform the agent of any behavioral traits.

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 genuinely concise. It does not use the limited space to convey any useful information, so the sentence does not earn its place with actionable 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?

The tool has no output schema, no annotations, and only bare parameter names, so the description is the sole source of context. It fails to explain what a 'checkpoint' is, what operation occurs, how sessionId relates, or what the result looks like, making it completely inadequate for correct invocation.

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

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

Schema description coverage is 0%, and the description gives no explanation of what 'label' or 'sessionId' mean or how they should be used. The bare string types provide no semantic information, and the description fails to compensate for the complete lack 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 states 'Reference a checkpoint at the current state,' but the verb 'reference' and noun 'checkpoint' are ambiguous—it is unclear whether this creates, retrieves, or marks a checkpoint. It does not distinguish the tool from siblings like noetic.commit, noetic.persist, or noetic.store, which also suggest state-related operations.

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

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

No guidance is provided about when to use this tool versus the many sibling tools. The description does not mention prerequisites, typical workflows, or any conditions that would lead an agent to select this tool over 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 behavioral burden. It does so by explicitly stating the call is a dry-run and 'not metered', signaling no side effects and no charge. It does not describe error behavior or permission-denial responses, but the core behavioral traits are disclosed.

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

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

The description is a single front-loaded sentence with no wasted words. It could be improved by starting with a verb, 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?

With six schema-undocumented parameters, no output schema, and no annotations, the description leaves major gaps: required inputs, response format, and when to use this tool versus its many siblings. It is too sparse to be fully 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 any of the six parameters. The agent must guess the roles of resource, estTokens, operation, sessionId, requestedRights, and subjectPrincipal from names alone, which is insufficient.

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 purpose: preflight-checking whether an operation would be allowed and at what price. The 'dry-run' framing distinguishes it from mutation tools, though it does not explicitly name or contrast siblings like noetic.authority or noetic.simulate.

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?

'Preflight dry-run' implies the tool should be used before a real operation, which gives some usage context. However, there is no explicit guidance on when not to use it or which sibling tools might be 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?

No annotations are present, so the description carries the full burden. It discloses that the tool validates ownership, state, and non-stale base before persisting, which is useful. However, it omits side effects, failure behavior, permissions, or what happens when validations fail, all of which an agent needs for a committing action.

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

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

The description is a single, tight sentence. It front-loads the action and resource, and the parenthetical packs useful validation context without padding.

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 commit-like session operation needs more guidance: what 'non-stale base' means, what the validation failures imply, or what the return result looks like. There is no output schema and no parameter descriptions, so the description leaves too many practical details 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 coverage is 0% and the description does not explain the parameters beyond implicit hints: 'session' likely maps to sessionId, 'produced records' to changeRefs. It does not define what changeRefs should contain, whether it is optional, or what shape the data should take, leaving an agent to guess.

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 and resource: 'Persist a session's produced records', which clearly names the action. It also scopes the operation to a session and cites validations, which helps distinguish it from generic persistence siblings like noetic.persist, though it does not explicitly name a sibling.

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

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

The description gives implied usage: it is for session-scoped production records at commit time, and mentions validation conditions. However, it does not explicitly state when to use it in preference to alternatives, nor does it give exclusion criteria or name any 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 provided, the description must carry the full behavioral burden, but it discloses nothing about side effects, permissions, confirmation semantics, or return behavior. The word 'confirm' in the name suggests an approval action, yet the description does not state whether it is idempotent, reversible, or requires special auth.

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 brevity is not conciseness when it sacrifices meaning. The sentence is syntactically broken and jargon-laden, making it less clear than a simple restatement would be. It earns a 2 because at least it is not bloated or redundant, but it is severely under-specified.

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

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

Given the tool's complexity (a confirmation/approval action with three parameters), the description provides no context about prerequisites, consequences, or relationship to the governance workflow. It does not mention whether a prior proposal or request must exist, what a successful confirmation returns, or how it differs from noetic.approve_request and noetic.commit.

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 three parameters (decision, changeRef, sessionId) with no descriptions, and the description adds zero semantic value. It does not clarify what 'decision' should contain, what changeRef refers to, or how sessionId is used. Since schema description coverage is 0%, the description was responsible for explaining all three parameters and completely failed.

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 'The sole requires-governance→authoritative path (governance capability only)' is nearly incomprehensible and fails to state a clear verb and resource. It does not say what the tool does with a concrete action like confirm, approve, or validate. It provides no differentiation from siblings such as noetic.propose, noetic.approve_request, or noetic.grant.

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 for when to use this tool versus alternatives. The phrase 'governance capability only' hints at a scope restriction, but it does not explain what that means or which sibling tools handle non-governance flows. It never mentions 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 provided, the description carries the behavioral burden. It discloses that the actor field is ignored, that authentication uses a bearer token, and that scope/rights are resolved server-side. It does not discuss session lifecycle or repeated-call behavior, but the disclosed auth semantics go well beyond a minimal connect description.

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

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

The description is a single efficient sentence that front-loads the purpose and packs in token source, parameter caveat, and server-side authorization behavior. Every phrase 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?

The description covers the essential auth flow and parameter caveats, but with no output schema and no annotations, it omits what the tool returns (e.g., a session handle) and the meaning of maxResponseTokens. These are meaningful gaps for an agent invoking 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. It does clarify token (bearer token from noetic.register) and actor (ignored), but maxResponseTokens is left unexplained. The compensation is partial rather than complete.

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 the specific verb+resource pair 'Open a session' and immediately scopes it to the online multi-agent ACN. It also references noetic.register as the token source, which distinguishes it from the registration and other sibling tools.

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

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

The description gives clear usage context: it is the session-opening step on the online ACN and requires a bearer token from noetic.register. It does not explicitly list exclusions or when-not-to-use scenarios, but the context is clear enough for an agent to select it appropriately.

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

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

No annotations are provided, so the description must fully communicate behavior. It discloses 'fails closed at the space cap' and 'owner-governed,' which is useful for denied expectations, but it does not mention side effects on existing spaces, need for authentication beyond ownership, whether the operation is reversible, or how failures are surfaced. A creation tool with no mutations context is underspecified.

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 redundant fluff; the qualifiers about owner control and failing closed add content. It is concise and front-loaded, though so concise that it omits critical information. Length is appropriate for what is included, but not for the tool's overall needs.

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 creates a core resource and has 6 undocumented parameters, no output schema, and no annotations, one sentence cannot be complete. The agent will not know how to fill parameters, what values are valid, what the result contains, or which side effects to expect. The description provides only a narrow hint.

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 description ignores all six parameters. It adds no meaning to sessionId, visibility, displayName, defaultRights, persistenceMode, or protectionLevel. Since the description does not compensate for the empty schema, the agent has no clue what the parameters mean or how they affect the created space.

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 clear action ('Create') and a specific resource ('geometric space (partition) in the account dump') and adds governance context. It distinguishes the tool from siblings like noetic.query or noetic.observe, though terms is vague without additional details about what makes a space 'geometric' and how it differs from other persistence 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?

No guidance on when to choose this tool over alternatives or any prerequisites (e.g., owner role, existing session, cap limits). The phrase owner-governed hints at permissions, but no 'use X instead' or 'call after Y' appears. Agents must infer under which conditions creation succeeds or which sibling is better suited.

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 mentions owner-governed but does not state whether the request is permanently deleted, whether it can be reversed, or whether an admin can act on behalf of the owner. Lacks authorization failure handling and side-effect details. This is a significant gap for a denial action.

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 and to the point, with the action and ownership condition front-loaded. It is not wasteful, though it could be more complete without becoming lengthy. Slightly more detail on behaviors or parameters would not hurt.

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 stub and no output schema, the description is too sparse. It omits key context: how to obtain requestId (likely from list_requests), what sessionId is used for, and post-denial effects. The sibling list provides some context but not enough for correct usage.

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

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

With 0% schema description coverage and no parameter descriptions, the agent is left without any explanation of what requestId and sessionId represent or where to find them. The description does not compensate, despite the schema providing only bare type declarations. This forces agents to guess or make errors.

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 (deny), the resource (pending access request), and the ownership condition (space you own). It is distinct from its siblings approve_request, list_requests, and request_access, and the one-line summary is sufficient to understand its role.

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

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

The description implies it should be used for pending requests, but it does not explicitly state when to use it versus approve_request or list_requests. It also omits prerequisites like the need for an active session or ownership verification, which is moderately important given transactional 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?

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read/compute operation but does not state whether it is read-only, whether it requires authentication, what side effects exist, or what 'scope-projected' actually means in terms of 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 very short and front-loaded with no wasted words. However, it is under-specified: 'scope-projected' is opaque, and the description would need more detail to be appropriately sized for a tool with three parameters and no annotations.

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 annotations, no output schema, and minimal description coverage. It omits return format, checkpoint resolution semantics, scope behavior, and any relationship to sibling tools, leaving an agent with insufficient context to invoke it reliably.

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

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

Schema description coverage is 0%, so the description must compensate. It loosely maps 'two checkpoints' to fromCheckpoint/toCheckpoint and 'scope' to sessionId, but it does not explain the direction of the diff, defaults, or behavior when parameters are omitted.

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 the tool computes a delta (difference) between two checkpoints, which is a specific and identifiable purpose. It does not explicitly use a verb like 'compute' or 'return', and it does not distinguish itself from siblings such as noetic.checkpoint or noetic.recall, but the core action is understandable.

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 noetic.checkpoint, noetic.recall, or noetic.locate. The phrase 'scope-projected' hints at a particular use case, but no explicit context or exclusions 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?

No annotations are present, so the description must carry behavioral disclosure. It does disclose one meaningful persistence guarantee ('durable facts are not revoked'), which helps an agent avoid assuming disconnect revokes facts. However, it omits other relevant behavior such as idempotency, whether ephemeral session state is cleared, and what happens on repeated disconnect calls.

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 entire description is one short sentence with a valuable parenthetical, and it front-loads the action. There is no fluff or repetition of the tool name, so it is appropriately concise.

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 0%-covered parameter, the description is too thin to fully guide invocation. It does not state what the tool returns or whether it is safe to call without sessionId, and it does not describe errors or lifecycle side effects. The persistence caveat is useful, but completeness for a state-changing tool remains limited.

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 sessionId property has no description, so the description needed to explain the parameter. 'End a session' only vaguely maps to sessionId and does not clarify format, optionality, or what omitted values mean. The property name is self-evident, but the description adds essentially no semantic 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 'End' with the resource 'a session,' which is clearer than a bare 'disconnect' and adds a relevant caveat about durable facts. It stops short of explicitly contrasting with sibling tools like noetic.connect or noetic.revoke, so it earns a 4 rather than a 5.

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

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

There is no guidance on when to call this tool rather than another: no mention of finishing a session, freeing resources, or choosing noetic.revoke/deny for revoking durable facts. The only hint is the parenthetical about durable facts, which is a behavioral caveat, not a usage rule. This is essentially no when-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation is read-only, public, across all accounts, and returns only metadata, not object content. This is solid for a simple list operation, though it omits details like pagination and 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?

The description is a single, well-structured sentence that front-loads the action and resource, then adds essential scope and safety information. Every word contributes value without redundancy.

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

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

The description covers purpose, scope, returned fields, and read-only behavior, which is strong for a simple list tool. However, with no output schema and zero parameter documentation, the lack of explanation for 'limit' and 'query' leaves meaningful gaps for an agent trying to 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?

The input schema provides no descriptions for 'limit' and 'query', and schema description coverage is 0%, so the description must compensate. It does not mention either parameter at all, leaving an agent without any guidance on query syntax, limit effects, or defaults.

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

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

The description uses a specific verb 'List' with a specific resource 'publicly available spaces across all accounts' and enumerates the returned fields (name, owner, offered rights, size, pricing). It also states its purpose, helping an agent decide what to request access to, which distinguishes it from siblings like request_access or query.

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

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

The description clearly implies when to use this tool: before requesting access, to see what spaces are available. It also notes 'read-only' and 'no object content', which indicates it is not for content-level inspection. It does not explicitly name alternatives or list exclusion conditions, but the context is clear.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It reveals access requirements ('owner, or a grant carrying read'), the case-insensitive substring behavior, the limit option, and the metering cost ('Metered as one query'). This is substantial context beyond a bare verb, though it does not describe output shape 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 entire description is one dense sentence with no wasted words. The core action and target resource are front-loaded, and all additional clauses add meaningful detail: access control, case-insensitivity, limit, and metering.

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 covers several important contextual aspects: authorization, read semantics, query behavior, and cost. Still, with no output schema, it omits what the response contains, and it leaves sessionId unspecified. It is sufficient for a simple fetch but not fully complete for confident 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 input schema has 0% description coverage, so the description must compensate. It does add semantics for query (case-insensitive substring) and limit, and 'space's stored objects' implies the space parameter. However, sessionId is never explained, and no parameter constraints or default behaviors are given.

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

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

The description clearly identifies a specific action (read), a resource (a space's stored objects), and qualifying details (owner or grant carrying read, optional case-insensitive substring query, limit). It is not a tautology and gives enough to distinguish it from siblings like noetic.query or noetic.observe, though it does not explicitly name an alternative.

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

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

The description implies when to use it (to read raw stored object content) and even notes the authorization requirement and metering cost. However, it provides no explicit guidance about when not to use it or which sibling tool to prefer, especially given nearby tools like noetic.query and noetic.observe.

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. The phrase 'drill into' suggests a read or retrieval operation, but it does not state whether the tool is read-only, what it returns (format, structure), or any side effects. There is no mention of authentication, rate limits, or state changes. This is the only source of behavioral info and it is inadequate.

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, non-redundant sentence with no fluff. It front-loads the core action and object. While it is terse, it doesn't waste words, so it earns a high score for conciseness, even though it sacrifices detail.

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 2 parameters, no annotations, no output schema, and no schema descriptions. The description only hints at the purpose of focusRef. It omits what the output looks like, any prerequisites (e.g., how to obtain a focusRef), the role of sessionId, and any behavioral constraints. For a tool with this complexity and no supporting metadata, the description is clearly incomplete.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It clarifies that focusRef is a reference from a summary, which adds some meaning, but sessionId is entirely unexplained. The description does not compensate for the lack of schema descriptions for both parameters, leaving an agent uncertain about the purpose and format of sessionId.

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

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

The description states a clear action ('drill into') and a specific resource ('a summary's focusRef') with an expected outcome ('full per-entity detail'). It is specific and not a tautology, but it does not explicitly differentiate from any sibling tools, so it earns a 4 rather than 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 gives no guidance on when to use this tool versus alternatives. It implies the tool should be used when you have a summary's focusRef, but there is no mention of conditions, prerequisites, or why noetic.focus should be chosen over related tools like noetic.recall or noetic.query. This is a minimal clue, not real 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 disclosure burden and does reveal two behavioral constraints: owner governance and narrowing-only grants. However, it does not state whether the grant is additive, reversible, or how persistenceMode affects existing state, leaving key side effects implicit.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. It communicates the core action and constraints economically.

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 six-parameter tool with no annotations, no output schema, and no per-field descriptions, one sentence is not enough to fully specify correct invocation. The description gives the gist but leaves worldMutation, sessionId, persistenceMode semantics, and return/error behavior unstated.

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

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

The description adds some meaning by mapping 'principal' to subjectPrincipal, 'space' to resource, and mentioning rights and persistence mode. It does not explain sessionId, worldMutation, or the exact shape of the rights array, so agents must infer much of the parameter contract.

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 (Grant) with a recipient (principal), object (scoped rights + persistence mode), and target (a space), and the parenthetical constraints distinguish it from siblings like noetic.revoke and noetic.check_rights.

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

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

It gives clear context by stating that grants are owner-governed and narrowing-only, so an agent knows who may invoke it and what constraints apply. It does not explicitly name alternatives or state when not to use it, so it stops short of full 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?

There are no annotations, so the description carries the full burden of disclosing behavior. It does not state whether the operation is read-only, whether it has side effects, what it returns, what scope or authorization is needed, or any other behavioral trait. The phrase 'scope-projected' is too ambiguous to count as 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 short and front-loaded, but it is under-specified rather than appropriately concise. Every word is wasted on vague metaphor instead of concrete operational meaning.

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, no parameter documentation, and a large set of ambiguous siblings, the description is far from complete. An agent cannot determine the expected inputs, outputs, or side effects well enough to invoke this tool reliably.

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

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

Schema description coverage is 0%, so the description must compensate. It gives a loose semantic hint for phenomenonRef ('phenomenon') but does not explain sessionId, the relationship between the two parameters, formats, or defaults. This is insufficient for two undocumented 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 uses the metaphorical verb 'Drill' and the jargon phrase 'scope-projected' instead of stating a concrete operation. It mentions a phenomenon and measurement evidence, but does not make clear what the tool actually does or how it differs from similarly-named siblings like noetic.observe, noetic.recall, or noetic.query.

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 any of the many sibling tools. The description contains no context about applicable scenarios, exclusions, or alternatives, leaving the agent to guess.

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 visibility scope and the two types of requests included, which is useful. However, it does not mention response format, ordering, or whether both categories are returned as a single merged list.

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, information-dense sentence with no filler. The action and scope are front-loaded, and the parenthetical purposes are concise and meaningful.

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 should provide more context about the response shape and the sessionId parameter. It explains the purpose well, but an agent cannot confidently parse result contents or correctly handle the one available 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 has one parameter, sessionId, with no description and 0% schema coverage. The description never mentions sessionId, leaving an agent to guess whether it is required, what it does, and how it affects the returned requests.

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 action (list), a specific resource (access requests), and a clear scope ('visible to you'). It further distinguishes two meaningful categories—requests on spaces you own and requests you have made—which clearly separates this from sibling tools like request_access, approve_request, and deny_request.

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

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

The description explains when to use the tool: to decide on incoming requests and to track your own requests. It implies this is the read-side counterpart to approval/denial tools, but it does not explicitly name alternatives or say when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Where an in-scope entity sits' weakly implies a read-only lookup operation, but side effects, permission requirements, and state changes are never addressed. It doesn't contradict read-only behavior, but it doesn't confirm it either — the tool could plausibly trigger traversal side effects. Like the update_drive calibration case, this is an implied-only behavioral profile.

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, so it is brief, but that brevity is achieved through cryptic phrasing ('metric-version-bound') rather than structured clarity. The core action is buried in a passive construction, and no key information is front-loaded. The 'metric-version-bound' suffix reads as an unexplained qualifier rather than a useful constraint, making the sentence compact but not concise in the communicative sense.

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 minimal-definition tool: 2 undocumented string params, no output schema, no annotations, no examples, and a 39-tool sibling list demanding differentiation. The description carries the full explanatory burden and delivers a cryptic riddle instead. An agent cannot learn what 'in-scope entity' means, what the tool returns, whether it mutates state, or how it differs from noetic.query, noetic.observe, noetic.fetch, or noetic.orient. Completely inadequate for the 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 exposes 2 parameters (entity: string, sessionId: string) with zero description coverage. The description's phrase 'in-scope entity' loosely maps to the 'entity' parameter, giving a weak hint that it is the lookup subject. However, 'sessionId' is entirely unexplained, and 'metric-version-bound' gives no clue about valid parameter values, formats, or how the two parameters interact. With schema coverage at 0%, the description was expected to compensate but barely does.

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 'Where an in-scope entity sits, metric-version-bound' uses a location-finding phrase ('where... sits') that loosely matches the 'locate' verb and names a resource ('in-scope entity'), which weakly distinguishes it from siblings like noetic.query or noetic.observe. However, 'metric-version-bound' is unexplained jargon, the passive construction obscures the action, and it fails to state what input is expected or what output is produced. This is marginally better than a tautology but far from a clear verb+resource statement.

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 exists anywhere in the definition. The description never states when to prefer noetic.locate over its 39 siblings, mentions no preconditions (e.g., a session established via noetic.connect), and gives no when-not-to-use guidance. The schema offers no help either: both parameters are optional and lack descriptions. An agent has zero signal 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 must disclose behavioral traits itself. It communicates a transformation and a rejection rule, but does not explain side effects, persistence, whether the simulation is mutated or consumed, required context, or failure 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 single sentence is short and free of fluff, but it is under-specified rather than concise. For a tool with five undocumented parameters and no annotations, this brevity is a deficiency, not a strength.

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?

There is no output schema, no annotations, no parameter guidance, and no usage context. The description is far too incomplete for an agent to reliably select and invoke this tool among 39 siblings.

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 all five parameters are bare strings. The description mentions no parameter names or meanings, so it does nothing to help an agent populate content, subject, sessionId, simulationRef, or targetEpistemicKind correctly.

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: turning a simulation into an inference or hypothesis, and adds a constraint that reserved kinds are rejected. This distinguishes it from siblings like simulate or propose, though 'inference|hypothesis' remains somewhat domain-specific and underspecified.

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 is given about when to use materialize versus siblings such as propose, confirm, commit, or simulate. The reserved-kinds rejection hints at a boundary, but no alternatives or selection conditions are described.

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. It does disclose that the tool is not metered, which is valuable, and indicates it returns counters and metrics. However, it doesn't clarify whether this is a read-only operation, whether it requires authentication, or what exactly the output structure is. Some effort is made, but gaps remain.

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

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

The description is a single, well-structured sentence that front-loads the main categories and lists concrete metrics. There is no fluff; every clause adds information. The 'Not metered' note is a valuable addition.

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 divine, so the description does well to enumerate the data types (counters, latency percentiles). But for a metrics tool with a complex return structure, it could specify more about how to interpret the values, units, or time ranges. Still, given the single optional parameter, the description is adequate for basic 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 only parameter, sessionId, has no schema description (0% coverage). The description does not explain the role of sessionId, but since it's optional and the tool can operate without it, the description's lack of detail is less critical. The low coverage raises the burden, but with a single optional string parameter, a 4 is appropriate because the schema is so simple that the description doesn't need to add much.

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 metrics tool covering two categories: developer metrics (role-scoped account + per-space counters) and server runtime metrics (calls, errors, latency). The scope is specific enough to distinguish it from siblings like noetic.usage and noetic.receipt, though it doesn't explicitly name those 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?

The description mentions the tool is 'Not metered,' which is useful for cost-aware decisions, but provides no guidance on when to use this versus alternatives like noetic.usage or noetic.receipt. No exclusions or conditions are given.

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

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

With no annotations provided, the description carries the disclosure burden and does contribute that the operation is governed and requires specific authorization context. It still leaves unspecified what happens on success or failure, whether the request is asynchronous, and what side effects occur to the target.

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

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

The description is a single front-loaded sentence with no filler, and the parenthetical adds useful prerequisite information. It is concise, but it is under-specified for a 4-parameter tool with no schema descriptions, so it is not fully 'appropriately sized'.

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 four undocumented parameters, zero required fields, no annotations, no output schema, and a large sibling set, the description provides only governance prerequisites. It is not complete enough for an agent to invoke the tool correctly, though it at least frames the authorization context.

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

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

Schema description coverage is 0% and the description does not explain target, newLabels, sessionId, or contribution. Even the vague mention of 'intent' and 'authority policy' does not map clearly to any parameter, so an agent cannot infer meaning, format, or relationships among the four 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 identifies a concrete action (requesting a governed change) and adds useful qualifiers: it needs mutate right, intent, and authority policy. This moves beyond the bare name 'mutate' and hints at why it differs from read-only or ungoverned tools. However, it does not specify the domain/resource being changed or explicitly contrast it with similar sibling tools like noetic.propose or noetic.commit.

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

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

The description states prerequisites for invocation (mutate right, intent, authority policy), which tells an agent when it is permitted to call this tool. It does not provide when-not-to-use guidance or point to alternative tools when those prerequisites are absent, so the usage guidance is implicit 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?

No annotations are provided, so the description carries the full burden of behavioral transparency. It discloses that behavior differs based on the presence of a subject, but it does not mention side effects, whether the tool is read-only, session-related behavior, output format, permissions, costs, or error cases.

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

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

The description is very short and front-loads its main action, but the brevity comes at the expense of clarity because key terms like 'Grounded Γ' and 'budgeted cluster narration' are unexplained. The sentence earns some place but does not communicate effectively enough to call it 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?

There is no output schema and no annotation coverage, so the description must explain both the operation and the expected return/behavior; it does neither concretely. Given the large sibling set and the mention of a no-subject mode, important context about what one actually gets back and when this tool is relevant is missing.

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

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

Schema description coverage is 0%, and the description adds only minimal meaning to `subject` by implying that omitting it leads to cluster narration. The `sessionId` parameter is never mentioned, so a caller cannot determine its role, whether it is required for a subject, or how it affects the operation.

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

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

The description identifies the tool as performing an 'observation' for a subject, or a 'cluster narration' when no subject is given, which gives a general sense of the action. However, 'Grounded Γ observation' and 'budgeted cluster narration' are unexplained and do not clearly distinguish this from siblings such as noetic.ground, noetic.focus, or noetic.query.

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 over its many sibling tools. The only conditional behavior mentioned is the subject/no-subject split, but there is no instruction about when an agent should choose observe over alternatives or what prerequisites or exclusions apply.

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 bears the full burden of disclosing behavior. It only vaguely hints at output ('narrated state', 'delta') and says nothing about mutations, authorization, side effects, checkpoint semantics, or scope 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 single noun-phrase line is short but at the expense of clarity, using a cryptic '+'-joined construction rather than an explanatory sentence. This is under-specification rather than effective 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?

Without annotations or an output schema, the description needed to explain what the tool returns, what the parameters mean, and what side effects may occur. It leaves all of these to inference, making the definition incomplete for reliable agent 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 0%, and the description does not explain 'sessionId' at all. 'From a checkpoint' merely echoes the parameter name 'fromCheckpoint' without adding format, default behavior, or meaning, so the description fails to 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 'Narrated state + scope-projected delta from a checkpoint' gives a vague sense of the tool's output but has no verb and does not state an explicit operation. It hints at change-from-checkpoint but does not distinguish orient from siblings like noetic.diff or noetic.observe, and it relies on specialized 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?

There is no guidance about when to use orient instead of diff, observe, focus, query, or checkpoint. No conditions, prerequisites, or alternative-routing cues are present, so an agent has no basis 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 behavioral disclosure. It reveals a write operation and mentions propose->commit, but does not clarify whether the tool commits, proposes, or returns intermediate state. Side effects and lifecycle behavior remain ambiguous.

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 front-loaded sentence with no wasted words. The core action and a key behavioral constraint are stated efficiently.

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 mutation tool with five undocumented parameters, no output schema, and no annotations, the description provides only a high-level action and a vague persistence-mode note. Essential information about parameters, return behavior, and lifecycle is missing.

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

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

Schema description coverage is 0% and the description does not explain the five parameters. Only 'target space' is referenced; content, sessionId, sourceSpace, and sourceRetrievalIds are left entirely undefined.

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 clear verb ('Write') and resource ('derivative into a target space'), and adds a specific behavioral qualifier about honoring source persistence mode. It is distinguishable from siblings like noetic.propose/noetic.commit, though it does not explicitly name them.

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 siblings such as noetic.store, noetic.commit, or noetic.propose. The persistence-mode hint implies some usage context, but no alternatives or exclusions 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, the description carries full responsibility for disclosing behavior. It does convey that this creates a private, non-authoritative assertion and restricts acceptable epistemic kinds alerten. However, it does not explain side effects, visibility, permissions, reversibility, or return behavior, which is a meaningful gap for a creation 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, compact sentence with no filler. However, the parenthetical is cryptic and could have been replaced with a clear statement about constraints. It is concise, but concision comes at the cost of 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?

With zero required parameters, six undocumented parameters, no annotations, no output schema, and many related sibling tools, this description is far too thin. It gives no usage context, no parameter guidance, no return value information, and no differentiation from similar tools like noetic.store or noetic.reason.

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 0% of the six parameters. The description only hints at the epistemicKind parameter via the parenthetical 'hypothesis|inference|intent only' and says nothing about content, subject, sessionId, confidence, or justification. The agent is left to guess the meaning of most fields.

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

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

The description uses a clear verb+resource pattern ('Create ... assertion') and adds meaningful qualifiers ('private', 'non-authoritative') that differentiate it from siblings like noetic.authority or noetic.publish. The parenthetical 'hypothesis|inference|intent only' narrows the intended content, though its exact meaning is somewhat ambiguous.

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 alternatives such as noetic.authority, noetic.commit, or noetic.persist. The 'non-authoritative' qualifier implies it is not for authoritative assertions, but this is not explicit enough and no alternatives are named.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the three visibility states, the owner-governed permission model, and the default behavior, which goes beyond what the bare schema offers. It does not mention side effects on existing grants or return behavior, but for a simple visibility-setting operation this is reasonably transparent.

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

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

The description is a single efficient sentence that front-loads the action and resource, then packs the essential details into a compact list. Every clause earns its place, and there is no redundant or filler 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 low-complexity visibility-setting tool with no output schema and no annotations, the description covers the core semantics, authorization context, and defaults. The main missing piece is a clear account of the sessionId parameter and what happens after the operation, but the tool is simple enough that the current description is nearly 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?

Schema description coverage is 0%, so the description must compensate. It does explain the 'visibility' parameter by enumerating public, unlisted, and private with their behavioral meanings, and 'space' is inferable from context. However, 'sessionId' is completely unexplained, and no required/optional relationship is specified, so the compensation is partial.

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 verb and resource: 'Set a space's discovery visibility,' then defines exactly what each visibility value means. It also distinguishes itself from related concepts like noetic.discover by clarifying what 'public' means in that registry, and from access-control tools by explaining 'private (owner + grantees only).'

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 clear context for when the tool is appropriate: it controls discovery visibility, is owner-governed, and defaults to public. It does not explicitly mention alternatives or when not to use it, but the owner-governed constraint and the visibility semantics provide enough situational guidance for an agent.

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

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

With no annotations at all, the description must carry behavioral disclosure; it conveys that this is a read-style query, but omits side effects, permissions/auth requirements, return shape, pagination, and failure behavior. 'Query' implies non-mutating, but this is not stated explicitly.

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?

One compact sentence with the operation front-loaded; no filler or redundancy. It earns its place, though it is terse to the point of being cryptic.

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 2-parameter tool with no annotations and no output schema, the definition is minimally viable at best. It fails to explain return format, session behavior, divergence units, or what 'scope-projected' concretely means, so an agent cannot invoke it confidently.

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

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

Schema coverage is 0%, so the description must compensate. It relates minDivergence to the threshold ('at/above a divergence') and 'scope-projected' likely maps to sessionId, but it never names parameters or explains what sessionId is, units, or optionality.

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 concrete operation ('query') and a specific result set ('entities at/above a divergence, scope-projected'), so an agent can grasp the tool's basic function. It is not fully self-explanatory because 'divergence' and 'scope-projected' rely on domain knowledge, and it does not name how it differs from siblings like noetic.observe or noetic.recall.

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

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

No explicit when-to-use or when-not-to-use guidance is provided; the word 'raw' hints at a low-level geometric alternative to higher-level noetic tools, but no sibling is referenced. The agent is left to infer selection from a list of 38 vaguely named siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses no side effects, no read-only vs mutating nature, no auth requirements, no return format, and no error behavior. The jargon 'typed inference' speculatively suggests analysis, but the description never states what happens when the tool is invoked.

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 brevity here is under-specification, not conciseness — the one sentence is 10 jargon-heavy words that fail to inform. Every word should earn its place, and none of these words clarifies purpose, behavior, or parameters for an agent.

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, 0% schema coverage, no annotations, no output schema, and a large sibling set requiring differentiation, this description is critically incomplete. An agent has no basis to invoke the tool correctly, interpret arguments, or understand results.

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 three undocumented parameters (districts, sessionId, namespaces). The only possible hint, 'narrowing scope optional,' does not map to any specific parameter or explain what these values mean. An agent cannot infer what 'districts' or 'namespaces' contain or how sessionId is used.

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

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

The description uses opaque jargon — 'AGORA exegesis', 'divergent cluster', 'typed inference' — with no clear verb or resource. 'Exegesis' is a noun, not an action, so an agent cannot determine what operation this tool performs. It is not a bare tautology, but the added words convey no concrete meaning to an agent that must select among 38 sibling tools.

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

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

No guidance is given on when to use this tool vs alternatives. With siblings like noetic.query, noetic.diff, noetic.observe, and noetic.ground, there is no indication of what distinguishes 'reason' from them or what condition should trigger its use. 'Narrowing scope optional' hints at parameter usage but says nothing about 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 provided, the description carries the full burden of behavioral disclosure. It states it 'reads' committed assertions, implying a non-destructive operation, but it does not disclose potential side effects, permission requirements, behavior on missing data, or any session-related constraints. The description provides only minimal behavioral context.

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

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

The description is a single, concise sentence that front-loads the core action and context. There is no redundant phrasing or filler; every word contributes to conveying 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 tool has two optional parameters and no output schema, the description is too sparse to enable correct invocation. It does not explain the intended usage of subject and sessionId, the format of returned assertions, or any edge cases. The description is incomplete for an agent to safely and correctly use 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?

The input schema has two optional parameters (subject and sessionId) with no description coverage, and the tool description does not explain their meaning or how they affect behavior. A 0% schema description coverage places the burden on the description, which fails to compensate. An agent would have no idea what to pass for these 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 committed assertions left by another session about a subject, with a parenthetical 'shared-context recall' that hints at its purpose. It is specific about the verb and resource, and the context implies it differs from general query or fetch operations among the siblings, though it doesn't explicitly 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?

The description implies usage for recalling shared context from another session, but it does not explicitly state when to use this tool over alternatives like noetic.query or noetic.fetch, nor does it mention exclusions or preconditions. Some guidance is implicit in the wording, but it falls short of clear decision support.

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 disclosure burden. It does add meaningful context by noting receipts are 'unsigned in MVP, integrity-checked,' which tells the caller something about trust guarantees. However, it does not clarify what 'verify' means behaviorally (e.g., does it throw, return a status, or just fetch), and it doesn't mention read-only semantics 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?

The description is short and front-loaded, stating the operation and a key limitation in one sentence. The abbreviation 'MVP' may be slightly unclear to an agent, and no structural organization is needed for such a brief description. It 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?

Given no output schema, no parameter descriptions, and no annotations, the description leaves important context unaddressed: the meaning of a 'usage receipt,' the distinction between receiptId and sessionId, whether the operation is a fetch or a verify (or both), and what the response looks like. The integrity-check note helps, but the tool still cannot be reliably invoked without guessing parameter semantics.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'by id' but doesn't map this to receiptId or explain the relationship between receiptId and sessionId. With two string parameters and no additional documentation, the agent cannot reliably know which parameter to populate or whether one 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 gives a specific verb+resource pairing: 'Fetch or verify a usage receipt by id.' It clearly identifies what the tool acts on (usage receipts) and the action (fetch/verify). It doesn't explicitly differentiate from sibling tools like noetic.fetch or noetic.usage, but the object is specific enough that an agent can infer its role.

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 'by id' offers a clear entry point: the caller should supply an identifier. However, it does not state when to prefer this tool over noetic.fetch, noetic.usage, or noetic.query, nor does it describe any prerequisites or exclusion conditions. It implies a use case rather than fully guiding selection among siblings.

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

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

No annotations exist to cover safety or side effects, so the description carries the burden. It clearly discloses that registration is not free of effects — it mints a principal and an account — and flags a non-obvious behavior: the returned token is shown only once. It does not mention idempotency, cost, or token expiry, but the essentials are covered.

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

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

Two tight sentences cover the action, the created resources, the returned credential, and the next step. No filler, no repetition. The one-time-token warning is compact but prominent.

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 gives the operational flow (register → get token → pass token to noetic.connect) and the key security-critical detail (token is shown once). It lacks details about the response shape beyond the token, the role of displayName, and what a duplicate registration would do, leaving some ambiguity for an agent operating autonomously.

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 single parameter, displayName, has 0% schema documentation and is never mentioned in the description. Nothing explains whether it is required, how it will be used, what happens if omitted, or any uniqueness/format constraints. Since the description must compensate for the empty schema, this is a notable gap.

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 and resource ('Register a new agent on the online ACN'), spells out the concrete effects ('mints a per-agent principal + its own account'), and names the output ('bearer token, shown once'). It is immediately distinguishable from siblings like noetic.connect or rotate_token without needing additional context.

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

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

Explicit next-step guidance is provided: 'Present the token to noetic.connect.' This tells the agent what to do after calling the tool and implies this is the entry point for a new agent. It lacks an explicit negative condition (e.g., 'do not call if agent already exists'), but the flow 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?

With no annotations, the description carries the full burden. It discloses that it records a pending request the owner can approve or deny, which is a core behavioral outcome. However, it does not mention side effects like duplicate requests, permission requirements, or edge cases (e.g., already having access). This is minimal but not misleading.

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 exactly two sentences, front-loaded with the primary action and scope. There is no redundancy or irrelevant content, making it highly concise and readable.

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

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

For a tool with 5 undocumented parameters, no output schema, and no annotations, this description is insufficient. It omits parameter meanings, return values, error scenarios, and behavioral edge cases. An agent would likely need external context to call it correctly, especially for the optional 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?

The schema lists 5 parameters (space, reason, rights, sessionId, persistenceMode) with no descriptions and 0% schema coverage, and the description explains none of them. It doesn't clarify what 'space' refers to, what 'rights' expects, or how 'reason' is used. The description does not compensate for the schema gap at all.

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

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

The description clearly states the action ('request a grant') and the resource ('a space you do not own'), and distinguishes it from ownership-based tools like grant or approve_request by specifying 'public or unlisted' spaces. This is specific and unambiguous.

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

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

It gives a clear precondition ('you do not own', 'public or unlisted') that indicates when to use the tool, but it does not explicitly mention alternatives or when not to use it. The context is useful but lacks explicit routing to sibling tools like grant or check_rights.

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 supplies meaningful behavioral constraints: ownership requirements, future-only effect, and immutability of receipts. It does not mention idempotency, error behavior, or whether revocation can be undone, but the stated invariants are valuable and non-obvious.

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 entire description is a single front-loaded sentence with no filler; every clause adds operational meaning.

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 covers the essential context: purpose, authorization scope, and side-effect boundaries. Some invocation details (parameter formats, failure cases) are absent, but they are not critical for basic agent understanding.

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

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

Schema description coverage is 0% and the description does not define 'sessionId' or 'capabilityRef'. The names are somewhat self-explanatory, but the description fails to clarify the relationship between the two parameters or what format/scope is expected for capabilityRef.

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 ('revoke'), a specific resource ('prior grant'), and clear qualifiers ('owner-governed', 'future authorization only', 'never rewrites receipts') that distinguish it from sibling tools like noetic.grant and noetic.receipt.

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

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

It communicates when the tool is appropriate (revoking a prior grant), who may invoke it (owner-governed), and what it will not do (no retroactive effect, no receipt rewriting). It does not explicitly name alternatives, but the contextual constraints provide clear usage boundaries.

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 for behavioral transparency, and it does well: it discloses that the tool mints a new token, retires the old one, requires a live session, and that the new token is shown only once. However, it does not mention whether the operation is reversible, potential side effects on other sessions, or authentication requirements beyond a live session. For a security-sensitive operation, more detail could be expected, but the disclosed behaviors are meaningful.

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

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

The description is concise, at two sentences, and front-loads the core action and benefit immediately. The second sentence adds the prerequisite and outcome, all in a clear flow. It loses a point because it could be slightly more structured (e.g., bullet points) but is still highly efficient for an agent.

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 simple parameter and no output schema, the description is quite complete. It explains the action, the trigger, the prerequisite, and the key outcome (new token shown once). The only slight gap is that it does not clarify what happens to the returned token (e.g., where it is returned or if there is any response schema), but given the 'shown once' note, an agent can infer the new token is returned. This is appropriate for the tool's simplicity.

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 only one parameter, `sessionId`, and schema description coverage is 0%, meaning the description provides no additional detail about the parameter beyond its existence. The description mentions 'requires a live session' but does not explicitly link that to the `sessionId` parameter, so the agent might infer that `sessionId` refers to the session. However, the parameter is self-explanatory, and the description's mention of 'live session' adds some context Morgensch. With a single obvious parameter)Skip

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 ('rotate' the bearer token), the resource ('this agent's bearer token'), and the outcomes (mint fresh token, retire old one). It is distinct from all sibling tools, as none other mentions token rotation. It also gives context for when to use it ('leak recovery or periodic rotation').

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

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

The description explains when to use the tool—'leak recovery or periodic rotation'—providing clear context. However, it does not explicitly mention scenarios where this tool should NOT be used or alternatives, though the nature of the tool makes those less relevant. It also implies a prerequisite ('Requires a live session'), which is useful.

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 constraints. It reveals that pricing is owner-governed but does not state whether the call overwrites the existing schedule, requires authentication, or has persistence or validation 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?

Single sentence, front-loaded, and without fluff. The parenthetical 'owner-governed' is somewhat redundant with 'owner-defined' but is not harmful.

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 4-parameter mutation with no annotations, no output schema, and an undocumented nested tiers object, this description is far too thin. An agent cannot know required fields, tier shape, currency expectations, or what happens to existing pricing.

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 defines no parameters. 'tiers' is an opaque nested object, and 'currency' and 'sessionId' have no format, role, or example explained.

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

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

States a specific action ('Set') and resource ('owner-defined pricing schedule for a space'), and the parenthetical adds an ownership constraint. However, it does not explicitly differentiate from general mutation tools like noetic.mutate or permission tools like noetic.authority.

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

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

No guidance on when to call set_pricing instead of related tools such as noetic.mutate or noetic.authority. The owner-governed hint implies a prerequisite but does not explain when this tool is appropriate or when an alternative should be used.

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 the behavioral burden. It adds meaningful context by disclosing the operation is private and non-persisted, but it stops short of explaining authentication needs, side effects, or what the agent receives back. More is expected for a tool name like simulate.

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 definition is a single concise sentence with the key differentiators 'private' and 'non-persisted' front-loaded. It has no padding or redundancy. Brevity is fine here; the real issue is under-specification, which is a separate dimension.

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, no enumerated defaults, and completely undocumented parameters, the description is too thin. It does not tell the agent how the simulation result is expressed, what formulate the what-if takes, how sessionId matters, or which parameters are required, leaving the caller to guess.

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 both subject and sessionId are bare strings with no descriptions. The phrase 'over an entity' loosely associates 'subject' with something being simulated, but sessionId remains completely unexplained. The description does not compensate for the missing schema-level 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 conveys a hypothetical, non-persisted action over an entity, so an agent can tell it is simulation-oriented rather than a persist or commit tool. However, it never states a concrete verb or what exactly is being simulated, and the phrase 'what-if over an entity' remains vague compared to siblings like noetic.propose or noetic.reason.

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 mention of 'private, non-persisted' hints at a safe, temporary experiment, but the description never says 'use this instead of X when...' or gives any exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses a meaningful behavioral trait: 'fails closed at the object cap,' which tells the agent the tool will reject writes when a limit is reached. However, it does not disclose whether ingestion is idempotent, whether it overwrites existing objects, or what happens on partial failure, leaving notable behavioral gaps.

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 core purpose and ends with the key failure behavior. It is concise and every phrase earns its place, though the parenthetical object-type list could arguably be moved to the schema.

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

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

For a 3-parameter tool with no annotations, no output schema, and 0% schema coverage, the description is too thin. An agent cannot tell what 'space' and 'sessionId' mean, what a successful response looks like, or how this ingestion relates to the many sibling tools. The 'fails closed' note is useful but insufficient for safe 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 0%, so the description must compensate for the three undocumented parameters. It explains that 'objects' are context objects of types observation|declaration|measurement, but it does not explain the 'space' or 'sessionId' parameters, nor their formats or requirements. The description adds some meaning for 'objects' but leaves most parameter semantics to inference.

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

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

The description states a specific verb ('ingestion') and resource ('context objects ... into a space'), and distinguishes itself from siblings by naming the object types it ingests. It is clear but does not explicitly contrast with sibling tools like noetic.observe or noetic.mutate, so it loses a point for lack of explicit differentiation.

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 alternatives such as noetic.observe, noetic.mutate, or noetic.persist. The description implies a write/ingest operation but does not state prerequisites, exclusions, or conditions that would route an agent to this tool over a 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 full burden of disclosing behavior. 'Typed inference' hints at some inference behavior, but the description does not explain what is inferred, whether this is read-only, what side effects exist, or what the output represents. This is too thin for an agent to predict the tool's 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 short but not effectively concise; it substitutes jargon ('declared-vs-lived gap', 'typed inference') for plain explanation. It is under-specification rather than tight, valuable prose.

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?

There is no output schema, no annotations, one unexplained parameter, and no usage context. The description is not nearly sufficient for an agent to select, invoke, or interpret the result of 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 description coverage is 0%, so the description must compensate for the undocumented sessionId parameter. It does not mention sessionId at all or explain how it relates to territory organization or declared-vs-lived gaps. The agent is left with only a bare 'string' type and no semantic guidance.

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 cryptic noun phrase: 'District organization + declared-vs-lived gap (typed inference).' It gestures at territory/district organization and a comparison between declared and lived states, but no clear verb or operation is stated. It does not distinguish this tool from the many other noetic.* 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?

No guidance is provided about when to use this tool or when to prefer an alternative. There is no mention of context, prerequisites, or relationships to sibling tools such as noetic.observe, noetic.query, or noetic.ground.

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 mentions 'authorized principal' and 'account-bounded', which hints at access scoping, but it does not describe what the response contains, what happens if the principal is unauthorized, or whether this is a read-only operation.

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

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

The description is a single compact sentence with no redundant phrasing, making it easy to parse. However, it is under-specified for a tool with three undocumented parameters and no output schema, so the brevity comes at the cost of useful detail.

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, no annotations, no parameter descriptions, and a large sibling set, the description is too incomplete for an agent to invoke the tool confidently. It defines the general purpose but omits input semantics, return shape, and usage boundaries relative to sibling tools.

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

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

Schema description coverage is 0% and the description does not explain any of the three parameters (space, consumer, sessionId). Since none of the parameters are described in the schema and the description offers no mapping, the agent has no semantic guidance for filling them.

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 ('Report') and the resource ('usage, cost and revenue'), and it adds scope ('for an authorized principal, account-bounded'). It is specific enough to distinguish the tool from many siblings, though it does not explicitly contrast it with noetic.metrics or noetic.receipt.

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 reporting context but gives no explicit guidance on when to use this tool versus alternatives like noetic.metrics or noetic.query. There are no exclusions, prerequisites, or conditions stated, leaving the agent to infer the appropriate use.

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