MYCELIX

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

No annotations are provided, so the description carries the full burden. The verb 'List' signals a read-only operation, which is useful. However, it does not disclose ordering, response shape, recency semantics, or whether the listing reflects live state or cached data. Gaps exist but are moderate for a simple list 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, front-loaded sentence with no filler. It is appropriately concise for a simple tool, though it could use the available space to add one or two useful details about behavior.

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

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

For a one-parameter read-only list tool, the description covers the basic action. But with no annotations and no output schema, it leaves several gaps: what a 'deploy' includes, how 'recent' is determined, the meaning of 'limit', and how this differs from sibling tools. It is minimally viable but not 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%, and the description does not mention the only parameter, 'limit'. The schema provides the name and default (5), but the description does not compensate for the lack of parameter documentation. The parameter is self-evident by name, but the tool definition misses the opportunity to explain its effect.

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

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

The description clearly states a specific action and resource: 'List recent Render deploys for Jarvis.' The 'for Jarvis' scope helps distinguish it from sibling tools like neo_render_deploys. It lacks an explicit contrast with siblings or a definition of 'recent', but the core purpose is unambiguous.

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

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

There is no guidance about when to use this tool versus jarvis_render_logs, jarvis_render_status, or neo_render_deploys. The description implies a Jarvis-scoped deploy listing but does not state when to prefer it or when to use an alternative.

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 conveys that the operation is read-only and scoped to 'recent' logs, but it does not explain output format, pagination, time windows, or any access considerations. This is minimal transparency for a tool with no annotation support.

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. Every word contributes to stating the tool's core purpose, and it is appropriately sized for a simple read operation.

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 there is no output schema and no annotations, the description should explain what the agent can expect from the returned logs and how the limit parameter behaves. It does neither, and it also lacks guidance on choosing among the many sibling log/status tools. The description is too sparse to fully support 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%, so the description must compensate for the undocumented 'limit' parameter. It does not mention the limit, its default of 50, or how it affects the returned logs. The schema provides only the parameter name and default, leaving the semantics largely unexplained.

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

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

The description uses a specific verb ('Read') and a specific resource ('recent Render logs for Jarvis'), making the tool's function immediately clear. It also distinguishes itself from siblings like jarvis_render_deploys and jarvis_render_status by focusing on logs, and from neo_render_logs by scoping to Jarvis.

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

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

There is no guidance about when to use this tool versus alternatives such as neo_render_logs or jarvis_render_status. The description only implies usage when logs are needed, but it does not state exclusions, prerequisites, or when a sibling would be more appropriate.

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 indicates this is a read operation that uses shared Render API credentials, but it does not explain what the response contains, whether any side effects occur, or what errors or delays might be expected.

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 redundant wording. It includes the key credential context without adding filler.

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

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

The tool is simple with no parameters, and the description covers the core operation and credential context. However, since there is no output schema, the description does not clarify what a status result looks like or what status values the agent should expect, leaving a minor but real completeness gap.

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

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

The tool accepts zero parameters, so there are no parameter semantics to document; the baseline for zero-parameter tools is 4. The description appropriately omits parameter details because none exist.

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

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

The description states a specific verb ('Read') and resource ('Jarvis Render service status'), making the tool's purpose immediately clear. It also distinguishes this tool from siblings like jarvis_render_deploys, jarvis_render_logs, and neo_render_status by explicitly naming the Jarvis Render service and the status operation.

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 prefer this tool over alternatives such as neo_render_status or jarvis_render_deploys. The description implies its use case through the word 'status,' but it does not state when not to use it or name any sibling 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 full burden of behavioral disclosure. It says the tool 'finds' and 'asks' agents, implying network calls and aggregation, but it does not disclose whether results are aggregated, how failures are handled, whether it waits for all agents, rate limits, or what 'independently' means for the response. The word 'independently' hints at parallel execution but is not elaborated.

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

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

The description is a single, compact sentence that front-loads the core action and scope. It earns its place by adding the 'independently' qualifier, which is meaningful. It could be slightly more informative, but it is not bloated or repetitive.

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 too thin. It does not explain what the output looks like, how many agents are queried by default, whether results are deduplicated, or how errors are surfaced. An agent would need to call it to learn basic behavior, which is a significant gap.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's lack of parameter documentation. The description mentions 'find' and 'ask' but does not explain the difference between 'query' and 'question', nor what 'max_agents' controls beyond its name. An agent would have to guess whether 'query' is a search filter and 'question' is the prompt sent to each agent.

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

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

The description states a specific verb ('find' and 'ask') and a clear resource ('public A2A agents'), and it distinguishes itself from siblings like neo_discover (which likely just finds agents) by adding the 'ask several independently' behavior. It is not a tautology and gives an agent a concrete sense of what the tool does.

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

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

The description implies usage: use this when you need to query multiple public A2A agents at once. However, it does not explicitly state when to prefer alternatives like neo_discover (for discovery only) or neo_web_search (for general web queries), nor does it mention any exclusions or prerequisites. The context is clear but the routing guidance is left to inference.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It implies the tool executes a multi-step process but doesn't state whether it's read-only, mutates state, requires permissions, or has side effects. The agent receives minimal behavioral context beyond the process steps.

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 with no fluff, well-structured and front-loaded with the core action. However, it is so brief that it omits essential details, making it under-specified rather than 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 3 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain return values, parameter usage, or when to use the tool, leaving the agent unable to invoke it correctly with confidence.

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 makes no mention of any parameters. The agent has no idea what 'query', 'problem', or 'max_agents' mean, how to format them, or their constraints. The description completely fails to compensate for the missing schema 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 a specific action ('Run two collective rounds') and details the process (independent answers, then peer critique), making the tool's core function reasonably clear. However, it doesn't specify the output or the resource being acted upon, leaving some ambiguity about the tool's exact 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 provides no guidance on when to use this tool versus siblings like neo_ask_agents or neo_director. There are no conditions, exclusions, or alternative recommendations, leaving the agent to guess the appropriate 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 provided, the description carries the burden of behavioral disclosure. It does disclose a key trait: the tool is research-only and cannot spend money or take external actions. Still, it does not describe what happens to results, whether external agents are actually spawned, or any other 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?

Two sentences with no filler; the purpose is front-loaded and the constraint follows immediately. Every sentence earns its place.

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

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

For a tool with no annotations, no output schema, and four parameters, this description is too thin. It does not explain how the parameters interact, what the research output looks like, or how to retrieve the results, despite the sibling neo_director_results suggesting such a follow-up exists.

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 goal, budget_eur, max_agents, or hours_per_week. The 'no spending' clause indirectly hints that budget_eur is not an authorization to spend, but this is too weak 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 uses a specific verb ('coordinate') and resource ('external agents to research revenue opportunities'), and adds a clear scope boundary ('research-only'). It does not explicitly distinguish itself from adjacent sibling tools such as neo_ask_agents or neo_collective, so it stops short of a 5.

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

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

The phrase 'Research-only; no spending or external actions' gives a clear usage context and an exclusion. However, it does not name alternative tools or explain when to choose this over siblings like neo_ask_agents or neo_collective, leaving part of the routing decision to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Return' implies a read operation, but the description does not explicitly state that it is non-destructive, whether it requires any permissions, or what happens if no results are found. It only notes the source ('runtime log'), which is limited 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 states the core purpose without any fluff. It is front-loaded with the verb and object, making it easy to scan. No unnecessary words or repetition.

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

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

The description lacks essential context for a tool with no output schema and minimal parameters. It does not explain what 'compact Director results' means, what the return format is, how the limit affects the output, or when this tool should be used relative to neo_director. These gaps could lead to incorrect 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 lack of parameter documentation. It does not mention the 'limit' parameter at all, leaving its meaning and default behavior to inference. While 'limit' is a common term, the description adds no value beyond the schema's type and default.

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

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

The description uses a specific verb ('Return') and names a specific resource ('recent compact Director results from the runtime log'). It clearly indicates what the tool does, but does not explicitly differentiate from sibling tools like neo_director, leaving some ambiguity about when this vs. the main tool should be used.

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 neo_director or neo_collective. The description does not mention any prerequisites, exclusions, or conditions that would help an agent choose this tool over others.

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

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

No annotations are provided, so the description must disclose behavioral traits, but it only names the search targets. It omits result format, pagination behavior, rate limits, authentication needs, or any side effects, leaving the agent without critical operational 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, focused sentence with no filler or redundancy. The core scope is front-loaded, making it easy to parse quickly.

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

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

For a simple two-parameter tool with no nested objects, the one-liner conveys the basic action and targets adequately. However, the absence of annotations, output schema, and sibling differentiation leaves gaps around result shape and usage context that an agent would need 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?

Schema description coverage is 0%, and the description does not explain 'query' or 'limit'. While 'Search' implies that query is a search string, the description does not clarify what fields are matched, what syntax is expected, or how limit behaves beyond its default.

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

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

The description uses a specific verb ('Search') and distinct resources ('public A2A agents', 'official MCP Registry'), making the tool's purpose immediately clear. This clearly differentiates it from siblings like neo_web_search or verify_mcp_endpoint even without naming 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?

The description gives no guidance on when to use this tool versus alternatives such as neo_inspect_mcp, neo_web_search, or neo_ask_agents. It states only what it does, not when it should be preferred.

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 behavioral burden. It explicitly states the critical safety trait: 'Never invokes remote tools,' and it restricts actions to 'initialize/tools-list only.' This meaningfully informs the agent about what the tool will and will not do, though it omits details like network behavior or output format.

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

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

The description is two short sentences with no filler. It front-loads the core purpose and then adds the critical safety boundary. Every word contributes useful information.

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

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

The description adequately conveys purpose and safety, but it leaves parameter semantics entirely to inference and does not describe what a successful response looks like. Since there is no output schema and no parameter documentation, a bit more context about 'query' and 'limit' would make this fully complete.

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

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

Schema description coverage is 0% and the description does not mention 'query' or 'limit' at all. The parameter names and the default value for 'limit' offer some inference, but the description adds no semantic meaning beyond the schema, so it fails to compensate for the missing 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 names a specific verb and resource ('Discover relevant MCP servers') and scopes the action precisely to 'inspect initialize/tools-list only.' The boundary 'Never invokes remote tools' clearly differentiates it from invocation-oriented siblings like neo_ask_agents or verify_mcp_endpoint.

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 statement or named alternatives are provided, but the description's 'Never invokes remote tools' gives an implicit exclusion that guides an agent toward using this for discovery/inspection rather than invocation. The usage context is mostly inferred rather than explicitly stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the JARVIS_URL dependency but says nothing about request behavior, side effects, error handling, or return format.

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

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

The description is two short sentences with no filler and front-loads the core purpose. It is appropriately concise for the information it contains, though some terms like 'configured internal' are vague.

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

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

With no annotations, no output schema, and a second undocumented parameter, this sparse description is far from complete. It omits critical invocation context, return expectations, and parameter semantics, leaving an agent unable to confidently 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?

Schema description coverage is 0%, and the description adds no meaning to either parameter. While 'message' is loosely implied as the prompt to send, 'context_json' is completely unexplained in both the description and schema.

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

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

The description states a specific action, 'Ask', and a resource, 'the configured internal Jarvis endpoint'. This is enough to distinguish it from Render-specific siblings like jarvis_render_status, though it does not clarify what the Jarvis endpoint actually does or what kind of response to expect.

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

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

There is no guidance about when to use this tool versus siblings like neo_ask_agents or neo_web_search. The only situational detail is the JARVIS_URL prerequisite, which is an environment requirement rather than usage 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 provided, the description carries the full burden of behavioral disclosure. It only says 'check whether,' suggesting a read-only connectivity test, but it does not describe what happens during the check, what the result looks like, or whether network calls or timeouts are involved.

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 filler. Every word adds meaning, and it is appropriately sized for a zero-argument utility.

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 no-parameter tool, the description is sufficient to invoke it, but it does not explain the expected result format, how to interpret failures, or how this relates to the sibling discovery tools. Given no output schema and no annotations, a bit more context would help an agent use the result.

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

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

The tool has zero parameters, so the schema leaves no semantic gap to fill. The description clarifies what the check targets (public discovery registries), which is useful context even though no arguments are needed.

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

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

The description states a specific action ('Check whether') and a specific subject ('NEO can reach public discovery registries'). It identifies this as a connectivity readiness check, which is distinct enough from most siblings, though it does not explicitly contrast with near-neighbors like neo_discover or verify_mcp_endpoint.

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 run this tool versus alternatives such as neo_discover or verify_mcp_endpoint. The word 'preflight' implies a pre-check, but there is no explicit context, precondition, or exclusion stated.

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

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

No annotations are provided, so the description must bear the burden of behavioral disclosure. It only says 'List', which implies a read operation, but it does not explain ordering, what 'recent' means, whether filtering or pagination applies, or what the response contains.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word adds meaning, and the action and scope appear first.

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

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

For a simple, one-optional-parameter listing tool, this description is minimally functional. However, with no annotations and no output schema, it leaves the agent to infer response format, 'recent' semantics, and the exact meaning of NEO in this context.

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

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

The schema has one parameter, limit, with a default of 5, but the description does not mention it. Schema description coverage is 0%, so the description should compensate, but it adds no parameter-level meaning beyond the parameter name itself.

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 clear resource ('Render deploys') and a scope ('for NEO'), making the tool's function immediately obvious. It also distinguishes itself from sibling tools like neo_render_logs and neo_render_status (different resources) and jarvis_render_deploys (different scope).

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

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

There is no guidance about when to use this tool over alternatives such as jarvis_render_deploys, neo_render_logs, or neo_render_status. The description implies a simple listing use case but provides no conditions, exclusions, or routing advice.

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?

Since no annotations are supplied, the description must carry the burden of behavioral disclosure. It explicitly says 'read', implying a non-mutating operation, but it does not disclose any further behaviors such as pagination, error handling, or constraints on the 'recent' window. The basic read semantics are clear, but additional context is missing.

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

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

The description is a single, short sentence that is extremely concise and front-loaded. It states the action and resource immediately, with no filler or redundant information. Every word earns its place.

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

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

For a simple read tool with one parameter and no output schema, the description covers the basic purpose but is incomplete. It lacks usage guidance and parameter semantics, and the presence of sibling tools (like jarvis_render_logs and neo_render_deploys) creates ambiguity that this description does not resolve.

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

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

The schema defines a single parameter 'limit' with a default of 50, but schema description coverage is 0% (no description in the schema). The description does not mention the limit parameter or explain its purpose, leaving the agent to infer from the name alone. With such low schema coverage, the description must compensate and fails to do so.

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

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

The description explicitly states the action (read), the resource (Render logs), and the scope (recent, for NEO). It is clear and specific, though it does not differentiate from sibling tools like jarvis_render_logs, which might offer similar functionality.

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

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

No guidance is provided on when to use this tool, when not to use it, or what alternatives exist. The description offers no contextual clues about prerequisites, eligibility, or related tools, 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 present, the description must fully disclose behavior. It only implies a read-only operation via 'Read', but does not mention what the status result looks like, whether it reflects real-time state or cached data, potential latency, or any side effects. Critical behavioral details are omitted.

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. It is concise and free of fluff, although it might be considered overly terse given the lack of behavioral context. Still, it earns points for directness.

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

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

For a simple read-only status tool with no parameters and no output schema, the description is minimal. It fails to explain what 'status' means, what return format to expect, or how it differs from the many sibling tools. An agent would need external knowledge to use this effectively, especially given the crowded sibling set.

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

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

The tool has zero parameters, so there is nothing to document. The 100% schema coverage is trivial, and the description adds no parameter details. According to the baseline for 0 parameters, a score of 4 is appropriate since there is nothing to compensate for.

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

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

The description states a specific verb ('Read') and a clear resource ('NEO's Render service status'), distinguishing it from the sibling 'jarvis_render_status' via the NEO prefix. However, it does not explicitly contrast with other status-like siblings (e.g., neo_render_deploys) or elaborate on what 'status' encompasses.

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

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

No guidance is given on when to use this tool versus alternatives like jarvis_render_status, neo_render_deploys, or neo_render_logs. The agent receives no context about typical use cases, prerequisites, or scenarios where this tool is preferred.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does add some useful traits—public web scope, RSS-based search surface, and no API-key requirement—but it omits any mention of return format, pagination, rate limits, or limitations. This is a minimal but non-empty 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 a single, front-loaded sentence with no filler. Every word serves a purpose, though the 'No paid API key' clause is a peripheral benefit statement rather than core behavior.

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

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

The tool has no output schema and no annotations, so the description must carry more explanatory weight. It fails to mention what results look like, how the limit affects output, or any operational caveats, making it incomplete for confidently 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%, and the description provides no meaning for the 'query' or 'limit' parameters beyond what the property names imply. For two parameters that are entirely undocumented, this is a significant gap that the description should have compensated for.

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

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

The description clearly states the action ('Search the public web') and the mechanism ('free RSS search surface'), which is specific enough to convey the tool's core purpose. It does not explicitly differentiate from sibling tools like neo_discover, but the RSS and free-web framing makes the resource and scope reasonably clear.

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

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

The description offers no guidance on when to choose this tool over alternatives or when not to use it. The phrase 'No paid API key' hints at a cost advantage but does not explain context, prerequisites, or boundaries such as preferring neo_discover for other search needs.

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 and does so credibly: it declares read-only behavior and three explicit negative guarantees ('never invokes remote tools, never forwards credentials, never affects commercial gates'), plus 'Free, no API key.' It omits rate limits, auth expectations, and failure/error behavior, so it stops short of a 5.

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

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

Three dense sentences, front-loaded with the most decision-relevant facts (free, no API key, read-only). Little waste, though undefined jargon ('MYCELIX', 'commercial gates') costs some 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?

A diagnostic tool with three undocumented parameters, no annotations, and no output schema needs the description to explain inputs and what 'classifies technical failures' actually returns. The description covers behavior and safety well but leaves parameter semantics and result shape entirely unaddressed.

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% for three parameters, so the description must compensate. It alludes to expected_capability ('compares the requested capability with declared tool metadata') and obliquely to registry_name, but says nothing about url, format expectations, or how the two endpoint-identifying params differ. Partial at best given the near-total schema 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?

States a specific verb+resource: a read-only MCP diagnostic that verifies endpoints, classifies technical failures, and optionally compares capability against tool metadata. An agent can understand the function without opening the schema. It does not, however, explicitly differentiate itself from the closely related sibling verify_mcp_endpoint (it only says it 'reuses' that verification), so it falls short of a 5.

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

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

The description implies its use case (diagnosing MCP endpoint/registry failures, free with no API key), which lets an agent infer when it applies. But it never states when to prefer it over siblings like verify_mcp_endpoint, neo_preflight, or neo_inspect_mcp, nor any exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden and does: cost (0.05 USDC on Base), payment protocol via x402, the exact error contract (isError result with a 402 object in structuredContent), the _meta['x402/payment'] retry key, signing/logging of the result, and a free sample endpoint. This is precisely the behavioral context an agent cannot get from schema.

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

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

Front-loaded with the value proposition, then cost, then the call protocol; no filler sentences. It is dense — several clauses about payment mechanics are packed into one paragraph — but each clause is operationally necessary.

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?

No output schema exists, and the description still conveys the shape of the result: one signed, logged report with per-citation grades from a four-value taxonomy. Minor gaps remain, such as whether the report includes the fetched page text or partial-batch failure behavior.

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

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

Schema coverage is 0%, so the description must compensate, and it mostly does: it explains that the tool accepts up to 8 quote-and-link pairs, or that citations can be extracted from the answer text, which disambiguates the citations-vs-answer split. It does not spell out the expected keys inside each citation object (quote, url) or what an empty answer implies.

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 concrete verb and resource (check citations in an answer) plus the output taxonomy — verbatim, paraphrase, stitched, not found — and a hard limit of 8 pairs. It is unmistakably distinct in substance from siblings like verify_quote, though it never names an alternative explicitly.

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?

Gives a clear trigger ('before an answer ships') and, unusually, a full invocation protocol: call without payment first to get the 402 requirements, then retry with the signed payment. It stops short of contrasting this with verify_quote or paid_proof_of_publication, so selection among overlapping siblings is left to inference.

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

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

No annotations are provided, so the description carries the full burden, and it does: rule-based methodology, evidence returned as what matched and where, explicit 'what was not checked' disclosure, signing and logging, and — critically — the exact payment negotiation protocol (call without payment yields an isError result with a 402 object in structuredContent; retry with the signed payment in _meta['x402/payment']). That is unusually rich behavioral disclosure for a paid tool with zero annotation coverage.

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?

Front-loaded with the value proposition and detection categories, then the evidence/trust properties, then the payment mechanics — a sensible ordering with no filler sentences. It is dense to the point of being a single wall of clauses, and the free-sample URL interrupts the flow, but every element carries information an agent 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 two-parameter tool with no annotations and no output schema, the description covers the payment handshake, the signing guarantee, and the limits of its own analysis — the hard parts. The remaining gap is input contract detail (empty defaults, mutual exclusivity of url/text), which is the one thing an agent could get wrong on a first call.

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% — url and text have no descriptions at all — so the description must compensate. It does partially, mapping 'a text or public page' onto the two parameters, but it never states that both are optional with empty-string defaults, whether they are mutually exclusive, or which wins when both are supplied. An agent can guess the mapping but not the selection rule.

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

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

States a specific verb and resource — determine whether text or a public page is attempting to steer the agent — and enumerates the concrete signal classes it detects (overrides, fake roles, exfiltration, tool abuse, payment requests, invisible Unicode, base64). This is clearly distinguishable from siblings like paid_citation_check, paid_mcp_audit, or verify_quote, which cover different verification domains.

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?

Gives a clear operational context ('before the agent reads it'), which tells an agent exactly where in a pipeline to place the call, plus a free sample endpoint to validate the shape first. It stops short of naming alternatives or stating exclusions (e.g., when a plain text heuristic is unnecessary), so it is clear context without explicit when-not 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 full load and does so well: read-only scope limited to initialize and tools/list, cost and payment mechanism (x402, USDC on Base), the failure shape (isError with a 402 object in structuredContent), signing and public witnessing of the result, and an explicit statement of what was and was not checked.

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?

Front-loads the value proposition, then the mechanics, with no filler sentences. Minor redundancy between 'Signed report, logged in a public witnessed log' and the closing 'Result is signed by neo and logged.'

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

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

Covers the essentials an agent needs for a paid, no-annotation, no-output-schema tool: scope, cost, payment handshake, and provenance of the result. The main gap is parameter meaning, which leaves the caller guessing what to put in previous_fingerprint.

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 neither parameter is named or explained. The mention of fingerprinting implicitly hints at previous_fingerprint for change detection, but the link is never made, and 'url' (the target MCP server endpoint) is left entirely 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?

States a concrete verb and resource plus the specific checks performed (hidden instructions, tool shadowing, annotation mismatches, transport faults, per-tool fingerprint). It does not, however, distinguish itself from plausible siblings like neo_inspect_mcp, verify_mcp_endpoint, or paid_injection_scan, which an agent would need to choose between.

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?

'Know what an MCP server can do to your agent before connecting it' gives a clear usage moment (pre-connection vetting), and the payment instructions tell the agent exactly how to proceed (call without payment, read the 402, retry with _meta['x402/payment']). No explicit when-not or sibling routing is given.

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

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

With no annotations, the description carries the full burden and does it well: it discloses the paid x402/USDC-on-Base requirement, the exact 402 failure shape (isError result, 402 object in structuredContent), the payment metadata key, and the irreversible public nature of the append-only log anchored on Bitcoin and Software Heritage. It omits rate limits, fetch-failure behavior, and whether the target page must be publicly reachable.

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 dense but well-ordered paragraph: purpose first, then use cases, then the free sample pointer, then payment mechanics, then the signing/log statement. Every sentence carries information, though the payment flow sentence is packed and slightly harder to parse than it needs to be.

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 paid tool with no annotations and no output schema, the description supplies the return contents (text hash, final URL, status, signature), the payment handshake, and the failure mode, which is nearly everything an agent needs before calling. The remaining gap is what happens when the fetch fails or the page blocks automated access.

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% for the single required `url` parameter, so the description must compensate. It implies the argument is the public page to fetch ("the fetched text, its sha256, final URL and status"), but never states format constraints, redirect handling, or whether a specific URL rather than a site is required. Partial compensation only.

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 and resource: capturing dated, third-party-signed evidence that a public page contained given text, with sha256, final URL and status written to an append-only log. That is distinguishable in substance from siblings like verify_quote or paid_timestamp, but no sibling is named and the boundary is left for the agent to infer.

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 concrete when-to-use situations: "disputes, deleted pages and changed terms," plus an explicit two-step invocation path (call without payment to receive the 402 requirements, then retry with the signed payment in _meta['x402/payment']). It never states when not to use it or which sibling to prefer instead, so it falls short of a 5.

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

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

With no annotations present, the description carries the full burden and does so: it discloses cost (0.01 USDC on Base), the x402 handshake including the isError/402 structuredContent shape on the unpaid call, that results are signed by neo and logged, and that anchoring is daily on Bitcoin. These are exactly the non-obvious traits an agent needs before invoking a paid mutation.

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?

Front-loads the value proposition in the first clause and then packs payment mechanics into compact sentences with no filler. Dense but every sentence carries information; slightly overloaded with endpoint URLs and metadata syntax in one block.

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?

No output schema and no annotations mean the description has to cover both behavior and returns, and it covers the payment round-trip well. However it omits any description of the receipt contents/return shape beyond 'signed receipt with a position in a public log', and leaves the note parameter entirely unaddressed.

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 implies sha256 is the digest being timestamped but never gives format expectations (hex, length, prefix), and the 'note' parameter is never mentioned at all despite being one of only two params.

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 concrete verb and resource — timestamp a sha256 to prove existence at a point in time — plus the mechanism (OpenTimestamps, Software Heritage, Bitcoin anchoring). It's not explicitly differentiated from the neighbouring paid_proof_of_publication sibling, which is the only thing keeping it from a 5.

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

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

Gives a clear operational path: call without payment to receive the 402 requirements, then retry with the signed payment in _meta['x402/payment'], and points to a free sample endpoint as an alternative for testing. It doesn't say when to prefer this over paid_proof_of_publication, but the payment mechanics are laid out step by step.

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 disclosure burden and does it well: it enumerates the verification pipeline and explicitly states the safety boundary ('Never invokes remote tools or forwards credentials'). It omits failure behavior, rate limits, or what a failed check produces, which keeps it short of a 5.

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

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

Three tight sentences with the cost/prerequisite fact front-loaded, followed by scope and then the safety boundary. Every clause carries information; nothing is restated from the name or title.

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

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

Given zero annotation coverage, no output schema, and two undocumented parameters, the description needs to do more than describe the check pipeline. It never explains mutual exclusivity of the inputs, what the verification response contains (pass/fail signals, latency reporting), or behavior on unreachable endpoints, leaving real gaps for an 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 neither parameter is described in the schema, so the description must compensate. It does so only indirectly, mapping 'public MCP HTTPS endpoint' to url and 'official Registry server name' to registry_name, but never states that the two are mutually exclusive alternatives, that both default to empty strings, or what a valid registry name looks like.

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

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

States a specific verb and resource: read-only verification of a public MCP HTTPS endpoint or official Registry server name, and enumerates the exact checks performed (DNS/SSRF, TLS/HTTP, initialize, tools/list, latency, discovery metadata). This is far more concrete than a sibling like neo_inspect_mcp, though the description never explicitly distinguishes itself from that similarly named tool.

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

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

The phrasing 'public MCP HTTPS endpoint or official Registry server name' implies the applicable input types, and 'Free, no API key' sets a practical precondition. However, there is no explicit when-to-use/when-not-to-use statement, no guidance on choosing between the url and registry_name inputs, and no routing advice relative to the overlapping neo_inspect_mcp 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 and does so richly: free/no API key, read-only single GET, no login, no JavaScript, SSRF-checked, and a precise interpretation of the not_found result. It even sets expectations ('who wrote the page is still yours to judge'), which is genuinely useful 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?

Front-loaded with the key fact ('Free, no API key'), and every sentence carries distinct value (outcomes, not_found semantics, usage, mechanics). It is dense with parentheticals and somewhat packed, but nothing is wasted.

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-param tool with no output schema and no annotations, the description covers purpose, inputs, the full result taxonomy, and operational constraints. An agent has everything needed to call it correctly and interpret the response.

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 neither parameter has a description, but the text maps url→'one link' and quote→'the exact sentence' and specifies the quote's format (verbatim, '...' cuts allowed if pieces are in order and close). This adds meaningful semantics, though it doesn't cover edge cases like missing/empty 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?

States a specific verb (checks/verifies) and resource (an exact sentence on a public HTTPS page) and enumerates the distinct outcomes (verbatim, stitched, paraphrase, not_found, unreachable). No sibling tool does this — verify_mcp_endpoint targets endpoints, not quotes — so an agent can differentiate it without opening the schema.

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

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

'Use it before acting on another agent's quote: one link + the exact sentence' gives an explicit when-to-use and the required inputs. It also clarifies the negative case (not_found ≠ false claim). No competing alternative is named, but none exists among the siblings, so this is clear context without explicit alternatives.

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