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 omits whether this is a mutating/admin action, what permissions are required, what commands are valid, whether execution is reversible, and how v1 vs v2 differ in behavior. For a command-execution tool this is a major 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?

Two short sentences with no padding, and the core action is front-loaded. It is efficient, though the brevity reflects under-specification as much as tight wording.

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

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

A command-execution tool with no annotations, no output schema, and zero parameter documentation leaves the agent without enough to invoke it safely or correctly. Command format, permissions, and version behavior are all absent.

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 nothing in the schema explains the 'command' string format or valid values, and the description does not compensate with syntax or examples. It only notes the version default (v2), which the schema already states via the default field.

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

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

States a clear verb+resource: running a command against a private server. This is distinguishable in spirit from the read-oriented siblings (erlc_logs, erlc_players, erlc_bans), but the description never explicitly contrasts itself with them or explains what class of 'command' is meant.

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 or when-not-to-use guidance. The only contextual hint is 'Defaults to API v2', which hints at version selection but does not say when to choose v1 or when running a command is the right approach versus the other 16 sibling tools.

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

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

No annotations are provided, so the description must carry the behavioral burden. 'Get' implies a read operation, but it does not state what happens when no flags are set, how multiple flags combine, whether authentication or rate limits apply, or what is returned.

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

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

The description is a single front-loaded sentence with no obvious filler, which is structurally clean. However, it is too sparse for a tool with five selector parameters, so its brevity comes at the cost of usefulness.

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, five undocumented boolean parameters, and numerous sibling tools, the one-sentence description is far from complete. An agent lacks the selection rules and behavioral context needed to invoke it correctly.

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

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

Schema description coverage is 0% for five boolean parameters, and the description does not explain any of join, kills, commands, modCalls, or emergencyCalls. It fails to compensate for the undocumented 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 names a verb ('Get') and resource ('log and call collections') and scopes it to API v2, but 'selected' is vague and the exact collections are not identified. It does not explicitly distinguish this combined v2 log/call fetcher from the sibling v1 log tools or other call-related 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?

There is no guidance on when to use this tool versus the many v1 log siblings or when to select particular boolean flags. The phrase 'selected' implies parameter-based filtering but does not explain selection behavior.

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 notes that location and wanted data appear 'when supplied'. It says nothing about permissions, rate limits, whether calls are scoped to a configured server, or behavior when no players are connected.

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; the scope and return content are stated up front. It is appropriately sized for a zero-argument list tool, though 'when supplied' is slightly 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?

For a simple no-parameter read tool this is close to adequate, but with no output schema the description should say more about what the returned player records contain and whether the call is scoped to a specific server. The v1/v2 relationship with erlc_v1_players is also left implicit.

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. There is no parameter surface that needs explaining, and the description correctly avoids inventing arguments.

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 (connected players) and scopes the operation to API v2, which implicitly separates it from the sibling erlc_v1_players. It is clear what the tool returns, though it never names the v1 sibling outright.

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 only implied: mentioning 'API v2' signals this is the modern variant next to erlc_v1_players, but there is no explicit when-to-use/when-not-to-use statement or named alternative. An agent must infer the routing from the version tag alone.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing: no statement that this is a read-only operation, no rate-limit or auth notes, and no indication of what the queue payload contains. 'Current' hints at a live snapshot but that is the only behavioral signal.

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, front-loaded sentence with no filler. It is appropriately sized for a no-argument read, though the terseness borders on 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?

For a parameterless tool with no output schema, the description is minimally adequate but omits the shape of the returned queue (player count, entries, identifiers) and the v1-vs-v2 distinction. An agent could call it correctly but cannot anticipate the response.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No parameter meaning is lost.

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 ('queue'), and the 'API v2' qualifier implicitly distinguishes it from the sibling erlc_v1_queue. It is clear what the tool returns, though it doesn't explain why an agent would pick v2 over v1.

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 guidance, no mention of when not to use it, and no named alternative despite the obvious erlc_v1_queue sibling. The only implicit signal is the 'API v2' label, which a reader must interpret themselves.

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. 'Get' implies a read, but it says nothing about authentication requirements, rate limits, cost of requesting many optional fields, or what an empty/default response looks like. It discloses only that extra data can be included.

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

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

Two tight sentences, front-loaded with the resource and followed by the optional-field summary. Minimal waste, though the second sentence is a bare enumeration rather than information-dense phrasing.

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 9-parameter tool with no annotations and no output schema, the description is only marginally adequate. It conveys the general shape of the response but omits default semantics, parameter-to-field mapping detail, and any behavioral caveats an agent would need to invoke it correctly.

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

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

Schema coverage is 0% and none of the 9 booleans are described in the schema, so the description has to compensate. It names most categories (players, staff, logs, queue, calls, vehicles), which maps loosely onto the flags, but it never clarifies that 'logs' splits into joinLogs/killLogs/commandLogs or that 'calls' splits into modCalls/emergencyCalls, nor what the default-false behavior means.

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 ('Get ER:LC API v2 server information'), and the 'v2' qualifier distinguishes it from the erlc_v1_server sibling. It does not, however, distinguish it from the v2-family tools such as erlc_players, erlc_queue or erlc_staff, which fetch overlapping data.

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 and no mention of alternatives. An agent cannot tell from the description whether to call this consolidated endpoint or the individual erlc_players/erlc_queue/erlc_staff tools, nor whether the optional flags are needed for either case.

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. 'Get' implies a read-only operation, but nothing is said about authentication requirements, rate limits, or whether the result is paginated or cached. For a tool with zero annotation coverage this is 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 short sentence with no filler and the resource named up front. It is efficient, though the trailing 'using API v2' clause could have been spent on a routing hint instead.

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 parameterless read tool this is minimally adequate, but with no output schema the description should indicate what the staff payload contains (roles, identifiers, count) and whether it is a snapshot. That gap keeps it at minimum-viable.

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 no parameters, so the standard zero-parameter baseline applies. There is nothing for the description to disambiguate beyond the absence of filters, which is evident from the empty schema.

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

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

States a clear verb+resource: 'Get current server staff.' The 'API v2' tag implicitly separates it from the many erlc_v1_* siblings, but it never names erlc_v1_staff or explains the version distinction, so an agent still has to infer which version to call.

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 prerequisites, and no mention of the v1 alternative despite erlc_v1_staff sitting right next to it in the sibling list. The version hint is the only routing signal and it is left unexplained.

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. 'Get' implies a read operation, but the description does not state whether authentication is required, whether results are paginated, or any other operational characteristics. It offers minimal transparency 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?

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for a zero-parameter getter, though it is so terse that it borders on under-specification rather than optimal 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?

Given the tool's simplicity (no parameters, no annotations, no output schema), the description is minimally adequate: it tells the agent that it returns the ban list. However, it lacks any detail about the response shape, pagination, or rate limits, which leaves some gaps for an agent to fill.

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 per the rubric baseline is 4. The description does not need to add parameter details, and it doesn't.

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 ('API v1 ban list'), making the tool's function clear. However, it does not explicitly differentiate itself from siblings like erlc_v1_queue or erlc_v1_killlogs beyond the resource name, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no context about the scenarios in which fetching the ban list is appropriate. It simply states what it does, leaving usage entirely 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, and it discloses nothing: not what 'command logs' contain, whether results are paginated or capped, what timeframe is covered, or what permissions are needed. It is a bare restatement with zero behavioral context.

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

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

The single sentence is short but that brevity comes from under-specification rather than compression of useful content. Nothing is front-loaded because there is effectively nothing to front-load.

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

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

With no output schema, no annotations, and no parameter documentation, the description is the only source of information about what this tool returns, and it says nothing beyond the resource name. For a log-retrieval tool sitting among many similar siblings, this is inadequate.

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 per the baseline rule this scores 4. There is no parameter surface for the description to clarify, and the empty schema is self-explanatory.

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 restates the tool name ('command logs') with a generic 'Get' verb, adding essentially no information. It does not distinguish this tool from closely named siblings such as erlc_logs, erlc_command, erlc_v1_killlogs, or erlc_v1_modcalls, so an agent cannot tell which log source this returns.

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

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

There is no when-to-use guidance, no exclusions, and no mention of any alternative among the many log-related siblings. The agent is left to guess whether this or erlc_logs/erlc_command is the correct call.

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 entire behavioral burden and discloses nothing: no indication of pagination, result window, auth requirements, sorting, or retention. 'Get ... join logs' is the only behavioral signal, and it is the minimum possible.

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 padding, which is structurally clean, but it is concise to the point of vacuity — it conveys no more than the name already does, so the sentence barely 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?

No annotations and no output schema exist, so the description must carry the load; it identifies the log type but omits any description of what a join log record contains, the return shape, or constraints, leaving the agent under-informed for a zero-param retrieval call.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4; the schema is trivially complete and there is nothing parameter-related for the description 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 is essentially the tool name restated: the name 'erlc_v1_joinlogs' becomes 'Get API v1 join logs.' It does identify the resource as join logs (distinct from sibling killlogs/commandlogs), but contributes no verb nuance, format, or clarification beyond the identifier itself.

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 the sibling log tools (killlogs, commandlogs, modcalls) or the aggregated 'erlc_logs'. An agent is left to infer selection purely from 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 burden, and it discloses nothing: not whether this is a read-only operation, whether it needs authentication, whether results are paginated, 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?

A single short sentence, so it is not bloated, but 'API v1' is dead weight that conveys no information to an agent and the sentence is under-specified rather than tight.

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

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

With no output schema, no annotations, and no parameters, the description is the only source of information and it omits return shape, pagination, filtering, and scope. Inadequate for an agent to call it confidently.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to document. Baseline 4 applies since no parameter semantics are required.

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

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

Names a verb ('Get') and a resource ('kill logs'), which does distinguish it from siblings like commandlogs, joinlogs, and modcalls. However, 'API v1' is filler that restates the tool name, and no scope (per-server, time range, pagination) is given, so the purpose is only minimally 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?

No when-to-use guidance, no exclusions, and no mention of the closely related erlc_logs or erlc_v1_commandlogs/joinlogs siblings that an agent must choose between.

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 discloses essentially nothing beyond the implied read nature of 'Get'. Return format, pagination, auth requirements, and log scope are all unstated.

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 sentence is front-loaded, but it is under-specified rather than genuinely concise — the phrase 'API v1' consumes space without adding meaning.

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

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

With no annotations, no output schema, and no parameters, the description is the only source of behavioral information and it provides almost none. For a parameterless log-fetch endpoint the definition is minimally adequate at best.

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 clarify; schema coverage is 100% and the empty object schema is self-explanatory. Baseline 4 applies.

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

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

States a verb ('Get') and a resource ('moderator call logs'), which loosely distinguishes it from log siblings like killlogs and commandlogs. However, 'API v1' is noise and there is no scope (server, time range, pagination) to tell an agent precisely what surface this covers.

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 condition, no prerequisites, and no routing to alternatives, despite 16 sibling tools including several other log endpoints. The agent must infer usage 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 disclosure burden, yet it says nothing beyond 'Get ... list'. It does not state whether results are paginated, scoped to a server, rate limited, or what happens with large player counts.

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 action and resource front-loaded. It is not padded, though 'API v1' is redundant filler that occupies space without adding meaning.

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

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

With no parameters, no output schema, and no annotations, the surface area is small, so the terse description is minimally adequate. Still, it omits the scope and shape of the returned player list, which an agent would need to use the result 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 per the rubric the baseline is 4. There is nothing for the description to clarify beyond the fact that this is an unfiltered list fetch.

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 verb (Get) and resource (player list), so the basic purpose is inferable. However, 'API v1' is versioning noise rather than a distinguishing trait, and with siblings like erlc_players and erlc_v1_staff present, the description gives no basis for choosing this tool over its near-identical counterpart.

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 mention of alternatives such as erlc_players, and no stated context (server scope, pagination, filtering). The agent must infer everything 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, and it does not. It doesn't state whether the call is read-only, what it returns, whether pagination or rate limits apply, or what permissions are needed. For a tool with zero annotation coverage, this is a critical gap.

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

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

The description is extremely short and front-loaded, which is good for conciseness, but it is under-specified rather than concise. Three words restate the name without adding information. There's no waste, but there's also no substance.

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

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

For a tool with no annotations, no output schema, and a vague name, the description should explain what the queue is, what the response contains, and when to call it. None of that is present. An agent cannot safely select or interpret this call from the definition alone.

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

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

With 0 parameters, the baseline is 4. There is nothing to misdocument and the description cannot add parameter semantics that don't exist. The score reflects that the schema itself is trivially complete for a no-arg 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 "Get API v1 queue" is essentially a tautology that restates the tool name and title. It identifies a resource (queue) but the verb "Get" is generic and adds no distinguishing detail versus siblings like erlc_queue or erlc_players. There is no explanation of what the queue represents (in-game join queue, moderation queue, etc.).

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. A sibling named erlc_queue exists, but the description does neither differentiate nor reference it. The agent is left to infer all usage context on its own.

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. "Get" implies a read and suggests no mutation, but nothing is said about auth requirements, rate limits, or what the returned status entails, which is a notable gap for a zero-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?

A single short sentence with no filler, and the action is front-loaded. It is efficient, though perhaps too terse for a tool with unresolved sibling ambiguity.

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

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

With no output schema, the description is the only place to explain what "status" returns, and it does not. For a trivial parameterless read tool this is a modest gap rather than a fatal one.

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 baseline is 4. The description correctly implies a parameterless call.

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 verb and resource ("Get ... server status") and reads as a read operation, but it is thin on what "status" actually covers. Crucially, it does not differentiate itself from the near-identical sibling `erlc_server`, leaving the agent unable to tell the v1 variant apart from the other one by description alone.

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, no prerequisites, and no guidance versus `erlc_server` or any of the other 15 siblings. The agent must infer usage entirely from 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 burden. It does disclose one genuine behavioral trait beyond the name — that the endpoint is deprecated — which is valuable operational context. It says nothing about auth requirements, response shape, or whether the data is still live, leaving real gaps.

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

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

Two short sentences with no filler, and the operational warning follows the purpose statement in a sensible order. Nothing is wasted, though the content is thin rather than deliberately tight.

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

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

For a zero-parameter, no-output-schema endpoint the required surface is small, and the deprecation warning covers the most important decision an agent faces. Still, it omits any indication of what the returned staff data looks like or whether the endpoint still responds, which a fully complete definition would address.

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; the description is neither misleading nor required to compensate for a schema gap.

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

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

States the verb and resource ("Get API v1 staff data") but the scope is vague — it doesn't say what 'staff data' contains or how it differs from the sibling erlc_staff beyond the v1/deprecated signal. The deprecation note does help separate it from the non-v1 sibling, but that is a status flag rather than a purpose statement.

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

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

The deprecation notice is a usable when-not signal — an agent can infer it should prefer erlc_staff. However, the alternative is never named and no condition or migration path is given, so routing is left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' weakly implies a read-only list, but nothing is said about pagination, empty results, auth requirements, or whether it returns all vehicles or only currently spawned ones.

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 one short sentence with no wasted clauses, but the 'Get API v1' prefix is redundant with the tool name and consumes most of the sentence's length. Front-loading is acceptable, but the content-to-length ratio is mediocre.

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

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

For a zero-param list tool with no annotations and no output schema, the description should at least define what a 'spawned vehicle' is and what the response contains. As written, an agent has no idea what records or fields come back.

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 are no parameter semantics to document; the baseline for a parameterless tool applies. Nothing in the description contradicts or confuses the empty 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 names a verb and resource ('Get ... spawned vehicles'), so an agent can infer it reads the list of spawned vehicles. However, 'API v1' is internal noise rather than purpose, and it makes no attempt to distinguish itself from the sibling erlc_vehicles or from erlc_v1_server/erlc_v1_players, which likely cover similar surface.

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 or when-not-to-use guidance, and no mention of the near-identical erlc_vehicles sibling. The agent must guess whether this is the v1-specific variant or a duplicate.

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

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

No annotations are provided, so the description carries full behavioral burden, and it delivers almost nothing: no auth requirements, no rate limits, no pagination or result-limit behavior, and no explanation of what "extended vehicle data" includes. "When supplied" is opaque given the tool takes no parameters at all.

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, which is appropriately sized. It is efficient but arguably too sparse for the behavioral questions it leaves open.

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

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

There is no output schema and no annotations, and no parameters to lean on, so the description is the only source of information — yet it omits return shape, pagination, and any hint of what extended data means. For a listing endpoint with zero structured support elsewhere, this is under-specified.

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 no parameter semantics to document; the baseline of 4 applies. Nothing in the description conflicts with the empty schema.

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

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

States a specific verb and resource ("List spawned vehicles") and names the API version (v2), which implicitly distinguishes it from the sibling erlc_v1_vehicles. It is clear what the tool does, though the v2-vs-v1 distinction is left for the agent to infer from naming rather than stated 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?

No when-to-use or when-not-to-use guidance is given, and no alternatives are named despite a near-identical sibling (erlc_v1_vehicles). The phrase "when supplied" implies a conditional but never explains the condition or how to trigger it.

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