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 provided, the description carries the full burden. It explicitly states 'Read-only', 'Never invokes remote tools or forwards credentials', and lists the checks performed. This is strong transparency for safety, though it omits potential rate limits or auth requirements, which are minor for a read-only verifier.

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

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

The description is two sentences with the key safety trait ('Read-only') front-loaded. It packs many relevant details (checks, safety promises) without redundancy. Every word adds value, making it highly efficient.

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

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

Given the tool's simplicity (2 params, no output schema), the description covers the core purpose, safety, and checks. It is missing explicit parameter relationship (url vs registry_name) and potential error conditions, but these are reasonable omissions for a read-only verification tool.

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

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

Schema coverage is 0%, so the description must clarify parameters. It does partly, indicating 'url' is for a public HTTPS endpoint and 'registry_name' for an official server name. However, it does not specify if they are mutually exclusive, required vs optional, or format expectations, leaving ambiguity.

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 verifies public MCP endpoints or Registry servers, with a specific list of checks (DNS/SSRF, TLS, initialize, tools/list schema). It uses the verb 'verify' with a clear resource, but it does not explicitly distinguish from sibling tools like neo_inspect_mcp, so it lacks direct 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?

The description implies when to use it (for verification of endpoints or Registry names) but provides no explicit guidance on when not to use it or which sibling tool to prefer. There is no mention of alternatives or exclusions, leaving the agent to infer usage context.

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