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

With no annotations, the description carries full behavioral burden but only says it 'actually attempts' to bind. It doesn't disclose whether the port is held/released, permissions needed (e.g., privileged ports), side effects, or timeout behavior. An agent cannot infer the safety or impact profile.

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

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

Extremely short – one sentence – which is concise but under-specified rather than efficiently structured. There's no waste, but also no front-loaded value.

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

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

Even with an output schema present (which can cover return values), the description is inadequate: no usage context, no parameter semantics, no behavioral disclosure for a tool that performs a real network bind. It leaves critical gaps for correct invocation.

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

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

Schema coverage is 0% – neither host nor port has a description. The description adds no information about parameter meaning, defaults (host defaults to 127.0.0.1), or constraints like valid port ranges. With 2 undocumented parameters, the description fails to compensate.

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 '实际尝试 bind TCP 端口' (actually attempt to bind a TCP port) restates the tool name can_bind_tcp almost word-for-word, making it largely tautological. It doesn't distinguish from can_bind_udp or explain what a successful/failed bind means compared to is_port_used or get_free_port.

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

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

No guidance on when to use this vs. alternatives like can_bind_udp, is_tcp_port_used, or get_free_port. The 'actually attempt' phrasing implies a real bind test, but doesn't clarify how it differs from simpler checks or whether it has side effects.

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 behavioral burden. The phrase '实际尝试' usefully signals an actual bind attempt rather than a heuristic check, which is real behavioral information, but it omits whether the port is held/released, what permissions are needed, and what failure looks like.

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

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

A single short sentence with no filler, so nothing is wasted. However, brevity here shades into under-specification for a tool that performs a real network 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?

An output schema exists so return values need not be explained, but with zero annotations and 0% parameter coverage, the description is too thin for a tool that actually binds a socket. It should at least clarify side effects and the host default's meaning.

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% across two parameters (host, port). The description mentions only 'UDP 端口' loosely and says nothing about the host parameter or its 127.0.0.1 default, so it does not compensate for the documentation gap.

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

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

The description names a concrete verb ('实际尝试' - actually attempt) and resource ('bind UDP 端口'), making it clearly distinguishable from can_bind_tcp and from the passive list_udp/is_udp_port_used siblings. It is specific but extremely terse, so it is clear rather than richly informative.

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 statement of when to use this tool versus alternatives. An agent must infer that 'can_bind' is an active availability check distinct from is_udp_port_used or get_free_port; the description offers no routing guidance or conditions.

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 behavioral burden, yet it discloses nothing about read-only behavior, permissions, side effects, or lookup scope. The single word 查询 implies a query but does not provide enough transparency for an agent to rely on it.

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

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

The description is very short and front-loaded, but this is under-specification rather than useful conciseness. For a three-parameter lookup tool with no annotations, it omits information an agent needs instead of being 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?

Although an output schema exists and return values need not be described, the definition still lacks usage context, behavioral disclosure, and parameter semantics. Given the tool's place among many similar lookup siblings, the description is not complete enough to select or invoke it confidently.

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

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

Schema description coverage is 0% across three parameters, and the description merely repeats the names 'IP' and 'Port' without adding format, range, or meaning. The optional protocol parameter is not mentioned at all, so the description does not compensate for the 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?

The description says only 'query specified IP + Port', which restates the required parameter names rather than explaining what an endpoint lookup returns or how it differs from siblings like find_port or is_port_used. It is a fragmentary purpose statement, not a useful distinction among the many find_* tools.

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

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

No when-to-use guidance is provided. The description does not mention alternatives, preconditions, or the context in which find_endpoint should be chosen over the numerous sibling lookup tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The word '查询' implies a read-only query, but the description does not state side effects, permission requirements, or what the query actually returns or checks. It adds almost nothing beyond the tool name.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately short for a simple one-parameter tool. The extreme brevity does mean it omits necessary details, but the structure itself is clean and focused.

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

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

Although an output schema exists (so return values need not be described), the tool has no annotations, no parameter description, and many similar siblings. The description does not help an agent decide when to select this tool over is_tcp_port_listening, get_listening_ports, or find_tcp_port. For a simple tool it is minimally callable, but contextually it is incomplete.

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

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

There is one required parameter 'port' with 0% schema description coverage, so the description must compensate. It adds the qualifier 'TCP LISTEN' to indicate the kind of port being queried, which is useful context beyond the bare property name. However, it does not specify the parameter's expected range, format, or exact meaning (e.g., 'port number to check').

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: '查询指定 TCP LISTEN 端口' (query the specified TCP LISTEN port). It clearly conveys that the tool looks up a TCP listening port. However, it does not distinguish this tool from closely named siblings like is_tcp_port_listening or find_tcp_port.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are many sibling tools such as is_tcp_port_listening, get_listening_ports, and find_tcp_port, yet no condition or exclusion is given. Usage context is entirely 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 behavioral burden. It says only that records are queried; it does not explicitly state read-only behavior, side effects, permissions, or how the optional protocol affects results. The word '查询' suggests a read, but that is not enough detail for a no-annotation tool.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though that conciseness comes at the cost of missing necessary semantic detail.

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

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

An output schema exists, so return values need not be explained. However, for a tool with two parameters and no annotations, the description is incomplete: it omits protocol semantics and provides no routing among the numerous sibling tools.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly clarifies that 'port' means a local port, but it does not mention the optional 'protocol' parameter at all, leaving its meaning, default behavior, and null handling undocumented.

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

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

The description states a clear verb ('查询') and resource ('使用指定本地端口的所有记录'), so the basic operation is identifiable. However, it does not distinguish this tool from its many siblings such as find_tcp_port, find_udp_port, or find_endpoint, which is the main gap preventing a higher score.

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

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

The description offers no guidance on when to use find_port versus the many alternative find/list/get/is tools. It does not mention exclusions, expected context, or the optional protocol parameter as a route to narrower siblings.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read-only lookup but does not state what kind of 'records' are returned (connections? processes?), whether results are filtered, or any permission/rate-limit behavior.

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

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

One short, front-loaded sentence with no waste. It is appropriately sized, though the brevity reflects under-specification rather than disciplined editing.

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?

An output schema covers return values, but with no annotations and an undocumented parameter, the description should clarify what 'records' means and how this differs from the many TCP siblings. Given the dense sibling set, it is too sparse to select the tool confidently.

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

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

The single 'port' parameter has 0% schema description coverage, so the description must compensate. It only clarifies that the port is a local TCP port; it omits the valid range (0-65535) or any format constraint, adding little beyond the schema's bare integer type.

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

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

The description gives a specific verb+resource: querying all records that use a specified local TCP port. It is more precise than a tautology and conveys scope (local TCP port), but it does not distinguish itself from close siblings such as is_tcp_port_used or find_port, which an agent must disambiguate on its own.

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 when-to-use guidance, no prerequisites, and no mention of alternatives among the many siblings (is_tcp_port_used, find_port, get_established_connections). The agent is left to infer context entirely.

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 supplied, so the description carries the full behavioral burden. 'Query all records' implies a read-only lookup, which is the most important disclosure, but nothing is said about whether results are local-only, whether a port with no matches returns empty, or about ordering. Basic safety profile is inferable but thin.

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 compact sentence with no filler, front-loading the verb and scope. It is arguably too terse, 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?

An output schema exists, so return values need not be explained. However, for a finder tool in a crowded family of port-related siblings, the absence of any routing guidance or parameter constraints leaves it only minimally adequate.

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

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

Schema coverage is 0% and the single 'port' property has no description, so the description must compensate. It does add meaning by clarifying that the port is a *local* UDP port, but says nothing about valid ranges or whether an unbound port is acceptable.

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

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

The description gives a clear verb (查询/query) and a specific resource (records using the specified local UDP port). It implicitly distinguishes itself from find_tcp_port and the list_* siblings by scoping to UDP and to records that *use* the port rather than merely listen on it, though it never names those alternatives.

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

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

There is no guidance on when to choose this over find_tcp_port, find_listening_port, or the list_udp* family. The agent must infer the selection criteria purely from the word 'UDP' in the name.

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 behavioral burden, yet it only restates the tool title. It does not disclose that this is a read-only, side-effect-free query, nor any scope, performance, or permission characteristics.

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 short sentence with the state and protocol front-loaded and zero filler. It is efficient, though almost too terse to be helpful.

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 (no params, output schema present, so return values need no explanation), but against a large family of overlapping TCP/UDP listing siblings, the description omits the comparative context an agent needs to select it correctly.

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

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

With zero parameters, the baseline is 4; there is nothing to document. The description correctly implies the only selection criterion (ESTABLISHED state) is fixed rather than parameterized.

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 (get) and resource (TCP ESTABLISHED connections), including the state filter that implicitly distinguishes it from list_tcp/list_all. However, it never names a sibling or explains how it differs from the broader TCP listing tools, so differentiation is left to inference.

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

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

No when-to-use guidance, no mention of when to prefer this over list_tcp, list_all, or the port-specific siblings, and no prerequisites. The agent must guess the routing condition from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says a free port is returned, but does not explain whether the port is reserved, how availability is checked, whether race conditions are possible, or how family and protocol affect the result.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though its brevity contributes to the broader completeness gaps.

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?

An output schema exists, so return values need not be explained. However, with no annotations and 0% parameter coverage, the description leaves family/protocol semantics and port-checking behavior undocumented for a four-parameter 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?

There are four parameters with 0% schema description coverage, and the description only vaguely refers to a 'specified range.' It does not mention family, protocol, start_port, end_port, defaults, or accepted values.

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: it returns an idle port within a specified range. The singular scope ('任意一个' / any one) helps distinguish it from the sibling get_free_ports, but no alternative is explicitly named.

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

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

There is no guidance on when to use this tool versus alternatives such as find_port, get_free_ports, or is_port_used. The range requirement is implied, but no conditions or exclusions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the core action. It does not disclose whether ports are probed by binding, how the scan behaves, or any cost/latency considerations.

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

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

A single, front-loaded sentence with no wasted words. It is efficient, though arguably under-specified rather than truly 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?

Output schema exists so return values need not be explained, but with no annotations and 0% parameter coverage across four params, the description is too thin for an agent to call it correctly, especially regarding family/protocol selection.

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

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

Four parameters exist with 0% schema description coverage. The phrase 'specified range' loosely implies start_port/end_port but adds no format or boundary meaning, and the family and protocol parameters are entirely undocumented in both schema and description.

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

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

The description states a clear verb+resource: return all free ports within a range. An agent can understand what it does, though it does not distinguish itself from the singular sibling get_free_port or the find_port family.

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 indication of when to use this tool versus siblings like get_free_port, find_port, or is_port_used. No prerequisites or context are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely states what is retrieved; it does not confirm read-only safety, authentication requirements, rate limits, or side effects, though the verb '获取' weakly implies a read operation.

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

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

A single short sentence, front-loaded with the action and scope, with zero wasted words. This is appropriately sized for a zero-parameter getter.

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 zero-parameter read operation with an output schema, the description states the purpose adequately. However, it omits any guidance on choosing between this and the many sibling list/find tools, and the absence of annotations leaves behavioral context thin.

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?

Zero parameters, so the baseline is 4. Schema coverage is 100% and there are no parameters to document, so the description neither helps nor hurts parameter semantics.

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

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

States a specific verb ('获取') and resource ('所有 TCP LISTEN 端口'), clearly indicating it returns all listening TCP ports rather than all TCP connections or established connections. However, it does not differentiate from siblings like list_tcp or find_listening_port, 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?

No guidance is provided on when to use this tool versus alternatives such as list_tcp, find_listening_port, or get_established_connections. Usage is only implied by the purpose statement.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that the first process is returned, but does not explain permissions, side effects, behavior when no process exists, protocol handling, or whether the operation is read-only.

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

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

The description is a single front-loaded sentence with no filler. However, it is arguably too terse to be structurally useful beyond the bare purpose.

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

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

Although an output schema exists, the description is incomplete for a two-parameter tool with no annotations and no schema descriptions. It omits protocol semantics, failure behavior, permission needs, and sibling differentiation.

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 both parameters. It mentions only the port vaguely and says nothing about the optional protocol parameter, its default, or how it affects matching.

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: get the first process for the specified port. It implies singular behavior that differs from the sibling get_port_processes, though it does not explicitly name or route away from that sibling.

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

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

There is no guidance on when to use this tool versus alternatives such as get_port_processes, get_process_ports, or find_port. The only implied condition is that a port is specified, but no exclusions or sibling routing are given.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says nothing about whether elevated privileges are needed, whether the lookup is passive, or how results are scoped. Only the bare purpose is conveyed.

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

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

A single short sentence with no filler, which is efficient, but the brevity here reflects under-specification rather than tight editing.

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?

An output schema exists, so return values need not be explained, but for a two-parameter tool with zero schema coverage and no annotations the description omits the protocol parameter and any usage context, leaving the agent under-informed.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions only the port argument and completely ignores the optional 'protocol' parameter, leaving its accepted values and default behavior undocumented anywhere.

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: retrieve all processes using a given port. It is clear what the tool does, but it gives no differentiation from the near-identical sibling get_port_process (singular) or from the reverse-direction get_process_ports.

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

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

There is no guidance on when to use this tool versus the many siblings (get_port_process, get_process_ports, is_port_used, find_port). No conditions, prerequisites, or exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. The retrieval verb implies a read operation, but the description does not state permissions, error behavior, whether the process must exist, or how local/remote process scope is handled.

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 or wasted text. For a simple one-parameter retrieval tool, this is an appropriately compact structure.

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

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

An output schema exists, so return values need not be described. Still, with no annotations and 0% parameter schema coverage, the definition is only minimally complete: it omits parameter details and any routing guidance among the many port-related siblings.

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

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

Schema description coverage is 0%, and the schema only declares a required integer 'pid'. The description says the target is '某个进程' (a process), which loosely links pid to a process, but it does not define pid format, explain what process ID means, or compensate for the absent 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 verb ('获取' / get) and resource ('某个进程正在使用的全部 TCP / UDP 端口' / all TCP and UDP ports used by a process). Its combined TCP/UDP scope distinguishes it from protocol-specific siblings such as get_process_tcp_ports and get_process_udp_ports.

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

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

Usage is implied by the stated scope: get ports for a process. However, it does not tell the agent when to prefer this over the many sibling tools, especially get_process_tcp_ports or get_process_udp_ports when only one protocol is needed.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it only restates that connections are retrieved. It does not say whether the call requires elevated permissions, what happens for a nonexistent PID, or whether the operation is read-only — all relevant for a process-introspection 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?

A single short sentence with no filler, and the resource is front-loaded. It is efficient, though the extreme brevity leaves much unsaid rather than being optimally structured.

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

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

An output schema exists, so return values need not be explained, and with one required parameter the call mechanics are simple. However, with no annotations and zero schema descriptions, the description should do more to cover permissions and failure behavior for a process-scoped query.

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

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

Schema coverage is 0% and the single parameter pid must be documented by the description. The phrase '某个进程' only loosely implies that pid identifies the target process; it adds no format, valid-range, or meaning beyond the schema field name.

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+resource: fetching the TCP connections used by a process. It implicitly differentiates from the UDP sibling (get_process_udp_ports) by naming TCP, but does not distinguish itself from get_process_ports or get_process_tree, so it misses the full sibling-differentiation credit.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as get_process_ports or list_tcp. The sentence only restates the purpose, leaving the agent to infer selection from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read/query operation but does not state read-only safety, permission requirements, failure modes, or whether the tree is exhaustive or costly.

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 sized for a one-parameter query tool.

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

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

An output schema exists, so the description need not explain return values. However, with no annotations and no parameter description, it omits usage routing and pid semantics, leaving meaningful gaps for an agent comparing sibling tools.

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

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

Schema description coverage is 0% and the only parameter is pid. The description mentions '指定进程' (specified process), minimally mapping pid to a process identifier, but adds no format, source, or OS-specific semantics; it does not 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 verb (返回) and resource (完整进程树) scoped to a specified process, so an agent can understand that this tool retrieves process ancestry. It does not, however, differentiate itself from siblings such as kill_process_tree or get_process_ports.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative guidance. The agent must infer from the name and sibling list that this is for inspecting process ancestry rather than killing processes or listing ports.

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 implies a read via '获取' but does not state permissions, error behavior for invalid or non-existent PIDs, or whether the process must be running.

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 short, front-loaded sentence with no wasted words. It is appropriately terse for a simple getter, though it errs toward under-specification.

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 low complexity, a single required parameter, and an existing output schema, the description is minimally adequate. However, it lacks pid semantics and sibling differentiation, which matters with so many closely related tools.

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

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

Schema description coverage is 0% for the single required parameter pid. The description says '某个进程' but does not explain that pid is the process ID, its format, or any constraints, adding little beyond the parameter name.

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 ('UDP 连接') scoped to a process. It distinguishes UDP from TCP by name, but does not explicitly distinguish itself from siblings like get_process_ports or get_process_tcp_ports.

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?

Provides no when-to-use guidance, no alternatives, and no conditions for selection. The agent must infer from the name and sibling list whether to use this over get_process_ports or list_udp.

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. It states that the tool checks whether a local port appears in the system network connection table, which implies a read-only query, but it does not clarify whether 'used' means listening, established, or bound, nor does it mention protocol handling or any auth/side-effect profile.

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

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

The description is a single, front-loaded sentence with no wasted wording. For a simple boolean port check, the size is appropriate and 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?

An output schema exists, so return values need not be explained. However, the input schema has no descriptions, the protocol parameter is critical for distinguishing TCP/UDP behavior, and the description does not clarify it or differentiate from sibling tools, making the definition incomplete for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It only vaguely implies the port is local, and it never explains the optional protocol parameter or valid values, leaving the input semantics largely undocumented.

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

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

The description states a clear verb (判断/determine) and resource (本地端口/local port) with the condition that it appears in the system network connection table. However, it does not distinguish this general tool from siblings like is_tcp_port_used or is_udp_port_used, so sibling differentiation is absent.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as is_tcp_port_used, is_udp_port_used, or can_bind_udp. The operation itself implies a use case, but no alternatives, prerequisites, or exclusions are mentioned.

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

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

No annotations are provided, so the description bears the full behavioral burden. It states that it checks LISTEN state but does not disclose whether the operation is read-only, requires special privileges, or how errors are handled. For an 'is_' check, read-only is implied but not explicitly confirmed.

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

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

A single sentence, front-loaded with the verb and target. There is no filler or redundancy; the description is perfectly economical for a simple boolean check.

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 an output schema present, return values need not be explained. However, given no annotations and 0% parameter schema coverage, the description does not explain the port parameter's expected semantics or the tool's safety profile. The core purpose is stated, making it minimally viable for a low-complexity tool.

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

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

The schema has one required integer parameter 'port' with 0% description coverage. The description only refers to 'TCP 端口', which restates the tool name rather than adding parameter meaning such as valid range, format, or constraints. It does not compensate for the missing schema description.

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 (判断/determine), resource (TCP 端口), and state (LISTEN), which distinguishes it from UDP and listing siblings. However, it does not differentiate from closely related tools like is_tcp_port_used or find_listening_port.

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 indication of when to use this tool versus alternatives such as is_tcp_port_used, find_listening_port, or get_listening_ports. Prerequisites and exclusions are absent; usage is only implied by the name.

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, yet it only restates the core purpose. It does not say whether 'used' means bound, listening, or connected, whether the check is local or remote, whether privileges are required, or whether the operation is read-only.

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

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

The description is a single short sentence with no wasted words, and the core action is front-loaded. However, it is under-specified for a tool whose behavior is not obvious from the title alone, so its brevity comes at the cost of completeness.

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-parameter query with an output schema, the return value can be omitted, but the description still fails to explain what 'used' means, how the check is scoped, or how it differs from sibling tools. Given the lack of annotations, it leaves important behavioral context missing.

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

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

Schema description coverage is 0% and the single 'port' parameter is undocumented in both the schema and the description. The description implies checking a port but adds no format, range, or protocol-specific details beyond what the name already suggests.

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

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

The description clearly states a specific verb ('判断' / determine) and resource ('TCP 端口' / TCP port) with the condition of being used. However, it does not differentiate this tool from close siblings such as is_tcp_port_listening, is_port_used, or can_bind_tcp, so an agent must still infer the exact scope of 'used' without help.

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

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

There is no explicit guidance on when to use this tool versus alternatives like is_tcp_port_listening or can_bind_tcp. The name implies a usage context, but the description provides no conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the bare purpose. It does not define what 'used' means (listening, bound, reserved), whether it requires privileges, or how the result is determined. The output schema presumably returns a boolean, but the semantics of that boolean are left ambiguous.

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

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

A single short sentence with the key resource front-loaded and zero filler. It is efficient, though its brevity is partly a symptom of under-specification rather than disciplined conciseness.

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

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

With an output schema present, return-format explanation is unnecessary, but the description still omits critical context for a query tool with no annotations: the definition of 'used', privilege or platform assumptions, and how it differs from the many sibling port tools. It is not adequate for correct tool selection.

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

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

There is only one parameter (port) with 0% schema description coverage, so the description is the only place semantics could be explained. It adds nothing about valid ranges, whether service names are accepted, or protocol assumptions, leaving the parameter under-specified.

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+resource: checking whether a UDP port is in use. Combined with the name, an agent can distinguish it from the sibling is_tcp_port_used without opening the schema. It does not, however, explicitly contrast itself with related siblings like can_bind_udp or find_udp_port.

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

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

There is no guidance on when to use this check versus can_bind_udp, find_udp_port, or list_udp, all of which touch UDP port state. The agent must infer the intended context from the name alone.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does not disclose that this is a destructive, likely irreversible operation, whether termination is graceful or forceful, what permissions are required, or how the timeout parameter affects behavior.

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

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

The description is a single short sentence with no filler, and the core action is front-loaded. However, its brevity reflects under-specification more than effective concision.

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

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

For a destructive process-control tool with no annotations and 0% schema description coverage, the description is too sparse. It omits timeout semantics, safety warnings, usage distinctions from kill_process_tree, and behavioral context, though the existing output schema relieves it of return-value explanation.

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

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

Schema description coverage is 0%, so the description should compensate. It only clarifies that pid identifies the target process, while the timeout parameter (with a default of 3) is not described at all, leaving its units and effect 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 states a specific verb (结束/terminate) and resource (指定 PID 的进程), making the core action clear. It does not explicitly distinguish this tool from the sibling kill_process_tree, but the reference to a specified PID implies a single process rather than a tree.

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

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

There is no guidance on when to use this tool instead of alternatives such as kill_process_tree, nor any mention of prerequisite permissions, safety conditions, or side effects. The agent receives only the bare action statement.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the scope of termination (PID plus descendants), but omits permissions, irreversibility, force/graceful semantics, timeout behavior, and whether the parent is affected.

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

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

A single front-loaded sentence with no wasted words. The target and action are immediately clear.

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

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

This is a destructive process-tree operation with no annotations and three parameters, two of which are undocumented. Although an output schema exists, the description still lacks safety, permission, and parameter-behavior detail needed to invoke the tool confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It only clarifies the pid scope and says nothing about the timeout parameter or the include_parent parameter, which remain undocumented in both schema and description.

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

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

States a specific action ('结束'/terminate) and resource scope (specified PID and its descendant processes). The scope word '子孙进程' distinguishes it from a single-process kill, but the sibling kill_process is not explicitly named or contrasted.

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 only says what the tool does; it does not explain when to use it instead of kill_process or get_process_tree. No prerequisites or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden. The verb 'list' strongly implies a read-only, side-effect-free inspection, but the description does not explicitly confirm read-only behavior, permissions, or constraints. It is adequate for a simple enumeration but adds little beyond the verb.

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 that states the full scope with no wasted words. Ideal for a zero-parameter tool.

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

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

With zero parameters, an output schema handling return values, and no annotations, the description states scope clearly enough to call the tool correctly. It omits sibling routing and explicit read-only disclosure, but neither is critical at this complexity level.

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 takes zero parameters, so the baseline is 4. Schema coverage is moot, and the description adds nothing about parameters because there are none to explain.

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

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

The description gives a specific verb (列出/list) and resource (IPv4/IPv6 TCP + UDP 网络连接), and the scope enumerates all protocol and IP-version combinations. This implicitly distinguishes it from the many subset siblings (list_tcp, list_udp, list_tcp4, etc.), though it does not name them 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?

The scope ('all') implies this is the comprehensive option to use when no protocol or IP-version filter is desired, but the description never states when to prefer it over list_tcp, list_udp, or similar siblings, nor any exclusions.

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

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

No annotations are provided, so the description carries the full burden. It never states that this is a read-only, side-effect-free listing, nor does it mention ordering, filters, or volume of results. It discloses almost nothing beyond the resource being read.

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 short sentence with the resource and scope front-loaded and no filler. It is efficient, though bordering on under-specification rather than concise richness.

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?

An output schema exists, so return values need not be described, and there are no parameters to document. However, for a tool embedded in a dense family of list/find/is_* siblings, the description leaves the agent without the when-to-use context needed to route correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies for a parameterless tool.

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

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

The description gives a clear verb ('列出'/list) and resource (TCP) and adds the address-family scope (IPv4 + IPv6). This implicitly distinguishes it from list_tcp4 and list_tcp6, though it never names those siblings as alternatives.

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

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

There is no explicit guidance on when to use this tool versus list_tcp4, list_tcp6, or list_all. The combined v4+v6 scope is the only hint at usage, and it must be inferred from the sibling names.

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 supplied, so the description carries the full behavioral burden, yet it only states that the tool lists IPv4 TCP. It does not disclose read-only nature (though 'list' implies it), ordering, permissions, or pagination behavior.

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

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

The description is a single short sentence and is front-loaded, but it is so terse that it lacks the context needed to use the tool among siblings. It is concise without being adequately informative.

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

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

With no annotations and many similar sibling tools, the description does not explain the scope difference from list_tcp or list_tcp6. Although the output schema exists and there are no parameters, the lack of routing guidance leaves an agent under-informed.

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

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

The tool takes zero parameters, so the baseline is 4. The description adds no parameter details, which is appropriate given there are none.

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 '列出 IPv4 TCP' restates the tool name/title (List Tcp4) as an expanded translation, giving the verb and resource but adding no sibling differentiation. It does not explain how it relates to list_tcp, list_tcp6, or list_udp.

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

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

No when-to-use guidance or alternatives are provided. With many sibling listing tools (list_tcp, list_tcp6, list_all), the agent gets no criteria for choosing this one.

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, and it says nothing: not whether the operation is read-only, what it returns, whether it requires elevation, or how results are scoped or ordered. For a tool with zero annotation coverage this is a complete behavioral gap.

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

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

The single short sentence is front-loaded but not concise in a useful sense; it is under-specified rather than tight. There is no structure beyond a bare noun phrase and no qualifier that 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?

Because an output schema exists, return values need not be explained, and there are no parameters. The remaining gap is the total absence of selection guidance against the many sibling list/find/get tools, which an agent needs in order to choose this one correctly.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the schema is trivially complete. The baseline of 4 applies with no compensating detail needed in the description.

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 verb ('列出' / list) and a resource (IPv6 TCP), so the basic purpose is conveyed. However, it does not clarify what aspect of IPv6 TCP is listed (connections, ports, listeners) nor explicitly contrast itself with list_tcp, list_tcp4, or list_udp6, leaving the scope somewhat vague.

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

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

The description gives no indication of when to use this tool versus list_tcp, list_tcp4, or the get_* / find_* siblings. There is only an implied IPv6/TCP filter from the name, with no conditions, prerequisites, or alternatives 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 behavioral burden, yet it says nothing about being a read-only listing, whether it returns all sockets or only bound/listening ones, or any filtering/ordering behavior. Only the address-family scope is disclosed.

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

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

A single short phrase with no wasted words and the resource front-loaded, but it is so terse that it reads as under-specification rather than disciplined conciseness.

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

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

The tool is a zero-parameter read operation and an output schema exists, so return values need not be explained. However, with no annotations, the missing read-only/behavioral statement and the absence of any sibling routing leave the definition merely adequate.

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 takes zero parameters, so there is nothing for the description to document and the baseline is 4. The 'IPv4 + IPv6' phrase is scope information rather than a parameter description.

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 (list) and resource (UDP), plus the scope 'IPv4 + IPv6', which implicitly distinguishes it from list_udp4 and list_udp6. It does not explicitly name or contrast with siblings like list_tcp or list_all, so sibling differentiation is only implied.

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 when-to-use guidance, no prerequisites, and no indication of when a sibling (list_udp4, list_udp6, list_all, get_listening_ports) would be preferable. The agent must infer everything from the name and sibling set.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'List' weakly implies a read operation, but the description says nothing about cost, rate limits, whether it returns a snapshot or live data, or any ordering/pagination behavior.

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

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

It is a single short sentence, which is front-loaded, but at this length it is under-specified rather than concise. Brevity here comes at the cost of any useful content.

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

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

An output schema exists, so return values need not be explained, but for a listing tool with many overlapping siblings the description should do more to position this tool. As written, an agent gets almost nothing beyond the name and cannot confidently choose it over list_udp or list_udp6.

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 takes zero parameters, so the schema fully covers the input contract and there is nothing for the description to clarify. Baseline 4 applies when there are no parameters to document.

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

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

The description '列出 IPv4 UDP' is essentially a restatement of the tool name list_udp4, adding only the IPv4 qualifier. It does technically distinguish the scope (IPv4 vs IPv6 vs TCP siblings), but it conveys no verb nuance beyond 'list' and reads as a tautology of the name.

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

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

There is no guidance on when to use this versus list_udp, list_udp6, list_all, or get_listening_ports. The agent must infer selection purely from the name, with no exclusions or alternatives named in the description.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about whether this is a read-only snapshot, live polling, what happens on a system with no IPv6 stack, or the safety profile. Only the two-word title restated in Chinese is offered.

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?

It is a single front-loaded sentence with no wasted words, but brevity here reflects under-specification rather than economy — the same length could have said what is being listed.

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?

An output schema exists, so return values need not be documented, and a zero-param list tool needs little context. Still, the absence of annotations plus the ambiguous noun ('IPv6 UDP' what?) leaves the agent guessing about the result set's meaning.

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 takes zero parameters, so there is nothing for the description to disambiguate. A baseline of 4 is appropriate for a no-argument tool.

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 verb (list) and a partial resource (IPv6 UDP), and the sibling set (list_udp4, list_tcp6) makes the protocol/version scope inferable. However, it never says what the listed items actually are — sockets, connections, ports, or endpoints — so the resource is under-specified.

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

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

There is no guidance on when to use this versus list_udp, list_udp4, or get_listening_ports. The protocol/version distinction is left entirely to inference from the name.

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