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

With no annotations, the description must disclose behavioral traits, but it reveals none: no authentication/authorization notes, no rate-limit caveats, no mention that arbitrary mutating calls are possible, no response-shape hint. 'Request' gives no behavioral signal beyond what the name already implies.

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 compact, but it is under-specification rather than useful conciseness. No structured, front-loaded guidance exists for a tool with 6 parameters and no annotations.

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

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

For a low-level universal API caller with no annotations, no output schema, and 6 parameters, this one-line description is inadequate. It fails to explain expected output format, error behavior, URL/path construction, or when raw requests are appropriate, leaving the agent poorly equipped.

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 83%, with path, query, body, token, and base_url already documented in the schema, so the description does not need to repeat them. It adds no parameter insight, but the schema carries the burden, keeping this at the baseline 3.

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 phrase 'Universal request tool for Keys.so API' indicates this executes arbitrary Keys.so API calls, which is meaningful against the many sibling endpoint-specific tools. However, it is largely a restatement of the name and does not state its role as a fallback/raw-call tool or what operations it supports beyond the schema's method enum.

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 about when to use this generic tool versus the many sibling tools, nor any statement that it should be used only for endpoints without a dedicated tool. The agent must infer all selection logic.

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

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

With no annotations, the description carries the full burden. It discloses the HTTP method (DELETE) and path, which imply destruction, but it does not state whether deletion is permanent, whether it cascades to associated data (prompts, competitors), or what authentication is required. This leaves significant behavioral ambiguity for a destructive 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?

Three lines: a clear Russian label, method+path, and an example request. All information is relevant and front-loaded; no fluff or redundant explanation.

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

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

For a mutation tool with no annotations and no output schema, the description omits essential context: irreversibility, cascade effects, permission requirements, or what response to expect. The typical agent needs more than a path to safely invoke a delete operation.

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 100%, so the baseline is 3. The description's example URL with <id> adds minimal meaning beyond the schema, though it does reinforce that id is a path parameter. It does not explicitly explain that id is the AI tracker project ID, but the title provides that context.

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 (delete) and resource (AI tracker project) in Russian ('удаление проекта' = delete project) plus the HTTP method and path. This clearly differentiates from sibling tools like keyso_delete_ai_tracker_id_prompts or keyso_delete_ai_tracker_id_competitors, which delete sub-resources rather than the project 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?

No guidance is given on when to use this tool versus alternatives. There is no mention of alternatives or exclusions; an agent must infer from the name and sibling list that this handles project-level deletion only.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that this is a DELETE operation and implies destructive removal of competitors, which is helpful. However, it does not explain whether all competitors are removed, whether the request body selects specific competitors, whether the operation is reversible, or what happens if the id is invalid.

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

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

The description is short and front-loaded with the purpose, followed by method and path. The example URL is slightly redundant with the path, but the overall structure is clean and free of filler. It is not bloated, though it errs on the side of being too sparse.

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 required but opaque JSON body, this description is incomplete. An agent cannot reliably construct a valid request body or understand the exact scope of the deletion. The method and path alone are not enough 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 100%, so the baseline is 3 even though the description itself adds little parameter detail. The path example demonstrates how id is used, but the required 'body' parameter remains semantically empty in both schema and description, leaving the actual competitor-deletion payload unspecified.

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 the action clearly: 'Трекер ИИ - удаление конкурентов' translates to 'AI Tracker - delete competitors', which identifies the verb (delete) and resource (competitors of an AI tracker). It is distinguishable from sibling delete_ai_tracker_id and delete_ai_tracker_id_prompts, though it does not explicitly contrast itself with post_ai_tracker_id_competitors or get_ai_tracker_id_competitors.

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 about when to use this tool versus alternatives, what prerequisites exist, or what body payload is required. The Method and Path lines are useful but do not constitute usage guidance for an agent deciding between this and sibling competitor-related 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 present, so the description carries the full burden of behavioral disclosure. It identifies a DELETE operation but does not state that deletion is permanent, what scope of data is removed, whether authentication is required, or how related data is affected. This is minimal rather than misleading.

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

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

The description is short and leads with the core purpose, method, and path. The example request is useful and the text avoids unnecessary filler, though it could include a bit more explanatory context without becoming verbose.

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 tool with no annotations and no output schema, the description lacks important context such as success/error behavior, return value, whether all prompts are deleted, and any warning about irreversibility. The example URL helps, but the description is not complete enough for an agent to fully anticipate the outcome.

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 100%, so the parameters are already documented. The description adds a concrete URL example showing the id in the path, but it does not meaningfully enrich the meaning of the id, body, token, or base_url parameters beyond what the schema already provides.

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 the action ('удаление промптов' — deleting prompts) and the resource (AI tracker prompts), along with the HTTP method and path, so an agent can understand what the tool does. It does not explicitly differentiate from sibling tools like delete_ai_tracker_id_prompts_group, but the path and noun are specific enough to avoid major confusion.

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

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

There is no guidance about when to use this tool versus the POST prompts, delete prompt group, or delete tracker siblings. The description only provides method/path facts and an example URL, leaving the agent to infer the appropriate context from the tool 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, but it only repeats the HTTP method and path. It fails to mention side effects, permission requirements, irreversibility, response behavior, or whether the group itself is deleted.

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

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

The description is short and front-loaded with the purpose, followed by method, path, and an example URL. It contains no filler, though its brevity leaves important details unstated.

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 DELETE operation with an unstructured body and no output schema, the description omits critical information: how to construct the body, how groups are identified, and what response is expected. An agent would likely fail to call it correctly without additional documentation.

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 100%, so the baseline is 3. However, the 'body' parameter is described only as 'JSON body' with no structure or meaning, and the description adds no clarification about what group or prompt identifiers the body should contain.

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 ('удаление' / delete), a resource (prompts within groups of an AI tracker), and provides the endpoint path. It doesn't explicitly contrast with sibling tools like keyso_delete_ai_tracker_id_prompts, but the name and path make the targeted operation reasonably clear.

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

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

There is no guidance about when to use this tool versus deleting prompts without a group, or when a group-scoped deletion is appropriate. No prerequisites, context cues, or alternative recommendations 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. It does disclose that this is a DELETE operation and that it removes a clustering project, but it does not state whether deletion is permanent, what consequences it has, whether special permissions are needed, or what the response 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?

The description is short and front-loaded with the core intent, followed by method, path, and an example. No unnecessary filler is present, though the 'Кластеризация - удаление проекта' line is more of a title than a full explanatory sentence.

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 delete operation with one required parameter, the description gives enough to make the request. However, with no annotations and no output schema, it omits response/status information and any note about irreversibility or authorization, and it slightly conflates 'project' with 'report'.

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 100%, so the uid parameter is already documented as a path parameter. The description adds a concrete path template and example URL, which helps clarify the uid placement, but it does not add meaningful semantics for token or base_url beyond what the schema already provides.

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

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

The description clearly states the operation is deleting a clustering project and provides the HTTP method and path. It is specific enough to distinguish from the clustering creation/list/get siblings, though it does not explicitly name any sibling alternatives.

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

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

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The delete intent is implied by the wording, but the description does not explain the conditions or context for using it.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. The DELETE method and 'удаление' make the destructive nature and target clear. It does not disclose permanence, related-data effects, authentication needs, or response behavior, which would improve transparency for a delete operation.

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

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

The description is compact and front-loaded, containing only the essential operational facts: purpose, HTTP method, endpoint path, and an example request. Every line earns its place with no redundant filler.

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

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

For a simple one-required-parameter DELETE endpoint with a fully covered schema, the provided method, path, and example are enough to call it correctly. The main gaps are the lack of response/status expectations and no mention of destructive side effects, which matter given there is no output schema or annotations.

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 100%, so the input schema already documents id, body, token, and base_url. The description adds only an example URL and does not clarify the id format or semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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 'удаление проекта' (deletion of a project) under the monitoring domain and specifies the HTTP method DELETE and path /monitoring/<id>. This makes the action and resource unambiguous and distinguishes it from sibling tools that create, update, or read monitoring 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?

The intended use is implied by the delete verb and the path, so an agent can infer this tool removes a monitoring project. However, there is no explicit when-to-use guidance, no mention of alternatives (e.g., patch to update), and no prerequisites such as the project needing to exist or deletion being permanent.

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 burden of conveying the destructive behavior, and it does by saying 'deletion of a project' and specifying Method: DELETE. It does not, however, state whether deletion is permanent, whether associated SERP data is removed, what authorization is needed, or what response 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 concise and front-loaded: it states the purpose first, then the method and path, then an example request. The example URL repeats the path, but this redundancy is minor and helps make the endpoint immediately actionable.

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 delete operation with one required parameter and no output schema, the method, path, and target resource are enough to understand the core call. It is incomplete, though, because it does not mention response/error behavior, authorization requirements, or any effect beyond deleting the project.

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 100%, so the baseline is 3. The description adds the path template /serp/<id>, confirming that the id parameter identifies the resource in the URL, but it does not add meaningful semantics beyond what the input schema already provides.

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 this tool deletes a project ('удаление проекта') and specifies the HTTP method DELETE and path /serp/<id>, so an agent can identify the target resource. It is not a 5 because it does not explicitly distinguish this SERP-project deletion from sibling delete tools such as keyso_delete_wordstat_delete_project or keyso_post_projects_delete, though the path helps disambiguate.

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 intended use is implied: call this tool when you need to delete a specific SERP/project by its id. However, there is no explicit when/when-not guidance, no mention of alternatives, and no cautionary context about destructive consequences for a tool with many sibling delete operations.

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 transparency burden. It reveals that the operation is destructive via 'DELETE' and 'удаление', but it does not disclose what exactly is removed, whether deletion cascades to related data, whether authentication is required, or whether the operation is idempotent.

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

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

The description is short and front-loaded, with no wasted words. However, the brevity is closer to under-specification than effective conciseness, because it omits the essential request-body details needed to invoke the tool correctly.

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

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

Given no annotations, no output schema, and a schema whose body has no defined properties, the description is not complete enough. The endpoint is clear, but the absence of any information about how to identify the project and what the response will be leaves a significant gap for an agent.

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

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

The schema describes token and base_url, but the critical body parameter is an empty 'additionalProperties' object with no documented project identifier. The description does not explain how or where the project to delete is specified, so an agent cannot determine the required request payload.

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 concrete action ('удаление проекта' – deleting a project) and the resource it acts on, reinforced by the explicit DELETE method and path. Among sibling Wordstat tools, this is clearly distinct from creating/updating projects and from deleting words.

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

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

The description gives no guidance on when to choose this tool instead of related tools such as keyso_post_wordstat_create_project, keyso_post_wordstat_id_update_project, or keyso_delete_wordstat_delete_words. Usage context is only implied by the DELETE verb and endpoint path.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the HTTP method DELETE and the endpoint, which indicates a destructive operation, but it does not state what is actually deleted, whether the action is irreversible, or what authentication/payload requirements exist. For a delete operation, this is insufficient.

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

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

The description is very short and front-loads the intended action before giving method, path, and an example URL. It contains no wasted words and is easy to scan. However, the brevity comes at the cost of omitting behavioral and payload details, so it is efficient rather than well-rounded.

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 the main body parameter is left unspecified, so an agent cannot know what payload to send. The example URL confirms the endpoint but not the required request body, authentication context, or response behavior. This is inadequate for a destructive operation.

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 100%, so the baseline is 3; token and base_url are adequately described as overrides in the schema. However, the main body parameter has an empty object schema with only 'JSON body', and the description does not explain what the body must contain (e.g., word IDs or project context). The description adds no parameter meaning beyond what the schema already provides.

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 contains 'удаление слов' (delete words), naming the action and the Wordstat resource, and the path makes it clear this targets /wordstat/delete-words. It does not explicitly contrast with sibling tools like keyso_delete_wordstat_delete_project or keyso_post_wordstat_id_update_words, so it stops short of full differentiation. Clear overall, but not sibling-aware.

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 the many sibling Wordstat tools, and no exclusions or prerequisites are mentioned. The example request shows how to call the endpoint, but not when it should be chosen over alternatives. This is effectively no usage guidance.

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

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

There are no annotations, so the description carries the full behavioral disclosure burden. It does state Method: GET, which implies a read-only operation, and provides a request example, but it does not disclose authentication requirements, pagination behavior, response shape, or any other behavioral traits an agent would need to anticipate.

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 brief and front-loads the core purpose before giving method, path, and an example. Every line serves a purpose with no filler, though the summary line is more of a fragment than a complete sentence.

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 and no annotations, the description is too sparse to be fully actionable. It omits return-value details, authentication context, pagination defaults, and any guidance on how the optional parameters affect the returned project list.

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 100%, so the input schema already documents all parameters including page, per_page, token, search, and base_url. The description adds no additional parameter meaning beyond the example URL, and since the schema handles semantics, a baseline score of 3 is appropriate.

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

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

The description identifies the resource ('/ai_tracker') and the result ('список проектов'), and the Method: GET line supplies the verb. It is clear enough to understand that this tool lists AI Tracker projects, and it is implicitly distinct from siblings like get_ai_tracker_state or post_ai_tracker, though it does not explicitly name any alternative.

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

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

No when-to-use guidance is provided. The description gives endpoint details and an example URL but does not explain when this tool should be selected over related tools, when not to use it, or how it fits into a workflow such as listing projects before inspecting a specific 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. The description states it is a GET request returning aggregated data for a chart, but it does not disclose pagination behavior, default date ranges, whether systems/groups filters are optional, authentication requirements, or any rate limits. For a read tool with no annotations, this is a meaningful gap even though the method is apparent.

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

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

The description is short, but its structure is awkwardly front-loaded with a Russian fragment ('Трекер ИИ - данные для графика') followed by method/path lines, then a complete sentence and a long example URL. It is not verbose, but the example URL consumes space without much incremental guidance, and the title repetition does not earn its place.

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

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

For a simple GET chart endpoint with no output schema and no annotations, the description covers the endpoint, method, and a sample request, and the schema covers all parameters with 100% description coverage. However, it does not explain the response shape, chart series semantics, how pagination works, or whether a tracker must be started/built before calling, which an agent would reasonably need for a correct call.

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

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

Schema description coverage is 100%, but the description adds value by clarifying systems values with named AI models (1=GigaChat, 3=DeepSeek, 6=OpenAI, 7=Grok) and showing the systems[] array format in the example URL. However, it adds little to date_from/date_to beyond 'start/end date of period' and does not clarify the groups parameter format (e.g., the example uses '— без группы —'), so semantics are not fully fleshed out.

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 the verb (получение/retrieve), the resource (aggregated data on phrase positions for a project's AI tracker chart), and the endpoint path. It is clearly distinguishable from sibling tools like keyso_get_ai_tracker_id_report (report data) or keyso_get_monitoring_id_report_chart (monitoring chart). However, the primary phrase is repetitive with the title and the first line is fragmentary, which slightly weakens clarity.

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 indicates that it returns aggregated data for a chart and shows a sample request with date range, pagination, and system filters. It does not explicitly state when to choose this tool over sibling alternatives such as keyso_get_ai_tracker_id_report or keyso_get_ai_tracker_id_mentions, nor does it give exclusions or prerequisites (e.g., tracker must exist or be built). Usage context is implied but not explicit.

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

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

With no annotations, the description carries the behavioral burden. It does disclose the HTTP method (GET) and that the operation returns data, signaling a read-only call, but it does not mention pagination behavior, output format, auth requirements, or any response caveats.

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 compact and front-loaded: it gives the AI-tracker context, method, path, purpose, and an example URL. It contains minimal redundancy and is easy to scan, though the title line and return line are somewhat repetitive.

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

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

For a tool with seven parameters and no output schema, the description is thin. It states the high-level return value but does not explain the output structure, pagination defaults, filtering/search behavior, or how this endpoint fits into the broader AI-tracker workflow.

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 100%, so the parameter documentation already explains each field. The description adds no extra parameter semantics beyond the endpoint example, so the baseline score of 3 is appropriate.

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

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

The description clearly states the resource and purpose: it returns a list of competitors and their visibility across AI systems via GET /ai_tracker/<id>/competitors. It is specific enough to distinguish from related competitor endpoints by method and path, though it does not explicitly contrast itself with sibling tools.

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

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

No when-to-use guidance is provided. The description does not mention alternatives, prerequisites, or scenarios where another AI-tracker endpoint would be more appropriate, leaving the agent to infer usage from the tool name and path.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does say 'Method: GET' and that it returns dates with available data, but it does not describe authentication requirements, response format, pagination, error behavior, or what happens when no data matches the filters. For a simple read endpoint this is somewhat informative, but still limited.

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 compact, front-loaded with the core purpose, and includes method, path, and a working example URL. Every line contributes useful information without unnecessary elaboration.

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 GET dates endpoint with schema-complete parameters, the description plus example is nearly sufficient for invocation. However, no output schema exists and the description does not clarify response format, sort order, or how the date list should be used alongside sibling report/chart tools. This leaves some contextual gaps for an agent deciding how to use the result.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a concrete example showing groups[]=— без группы — and systems[]=6, which demonstrates query array syntax and hints at valid group values. However, it does not add substantial meaning beyond the schema's parameter descriptions.

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

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

The description identifies a clear resource ('AI Tracker') and action: retrieve all dates for which data exists under the AI/folder filter. The explicit path /ai_tracker/<id>/dates and example query help an agent understand the endpoint's scope. It does not explicitly differentiate from sibling AI Tracker endpoints like entity or chart, but the purpose is specific enough.

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 for when to use this tool versus alternatives such as keyso_get_ai_tracker_id_entity, keyso_get_ai_tracker_id_report, or keyso_get_ai_tracker_id_chart. The example implies query parameters for filtering, but there is no mention of prerequisites, expected use cases, or situations where a different tool should be chosen.

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

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

With no annotations, the description carries the behavioral burden. It explicitly states 'Method: GET', gives the full path, and says the response includes search settings, update schedules, and notifications, making clear this is a read-only entity lookup. It does not discuss auth or rate limits, but the schema already exposes token and base_url parameters for authentication.

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 compact and well structured: a resource label, method/path, one sentence about return content, and an example URL. Every element is useful, and the key facts appear early.

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 GET entity endpoint with no output schema, the description is reasonably complete: it provides method, path, example, and return-value categories. It omits response shape details, but those are not essential for correctly invoking this low-complexity read operation.

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 100% for id, token, and base_url, so the baseline of 3 applies even though the description adds no parameter-specific meaning. The path template partially reinforces the role of id.

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

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

The description clearly states the action and resource: it 'returns the full description of the project entity' and enumerates content such as search settings, update schedules, and notifications. This distinguishes it from chart/report/dates siblings in substance, though it does not explicitly name a competing tool.

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

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

The use case is implied: if the agent needs the full project-entity description, this is the endpoint. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned despite many closely related AI-tracker sibling tools.

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

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

With no annotations, the description carries the transparency burden. It discloses that this is a GET read operation returning a list with time and type fields, which is useful, but it omits pagination behavior, response shape, auth requirements, and how the `last` or `filter` parameters affect results.

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 compact and includes essential HTTP details plus an example URL. There is mild redundancy between the opening title, the path declaration, and the example request, but overall the description stays focused and readable.

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

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

The tool has eight parameters, no output schema, and no annotations, yet the description only covers the basic list-returning behavior. Missing context includes pagination semantics, filtering, auth requirements, and what the returned mention objects contain beyond time and type.

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 100%, so the schema already documents all eight parameters thoroughly. The description adds no additional parameter-level meaning beyond the schema, meeting the baseline but not exceeding it.

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 names the resource (AI tracker mentions), states the HTTP method and path, and says it returns a list of all mentions with time and mention type. This distinguishes it from sibling AI-tracker tools like `keyso_get_ai_tracker_id_entity`, `chart`, `report`, and `dates`.

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

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

The description gives no guidance on when to choose this tool over alternative AI-tracker endpoints. It does not state use cases, exclusions, or relationships to sibling tools, leaving the agent to infer appropriate usage 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?

With no annotations provided, the description carries the full burden. It does disclose the read-only GET nature and provides a concrete example URL demonstrating filtering and pagination behavior, which is genuinely useful. But it omits response format, pagination semantics of the returned data, error behavior, and auth requirements — for an unannotated tool this is a noticeable 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 purpose sentence is reasonably front-loaded and the example URL earns its place. However, «Method: GET / Path: /ai_tracker/<id>/report» largely duplicates what the tool name and the schema's 'in: path (auto-detected)' already communicate, and the raw <br> HTML tag is noise. Length is acceptable but not 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 tool with 11 parameters, no annotations, and no output schema, the description covers purpose, method, and a worked example but leaves meaningful gaps: no hint of the response shape, the filter parameter references a documentation section an agent cannot access, and there is no guidance on how this report differs from sibling report/mentions/chart endpoints. Adequate for basic invocation, incomplete for fully confident use.

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 100%, so the baseline is 3, and the description itself does not restate parameter meanings. The example adds real value beyond the schema: it shows the array query syntax (systems[]=6&systems[]=7), the special groups value «— без группы —», and how date_from, date_to, per_page, and page combine, none of which the one-line schema descriptions convey.

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: «Получение отчета по упоминаниям промптов за указанный период с фильтрацией системам ИИ и папкам» — clearly identifies this as a period-filtered report on AI prompt mentions. The header «данные для таблицы проекта» adds placement context, and the GET /ai_tracker/<id>/report path reinforces the resource. It does not explicitly distinguish itself from sibling endpoints like keyso_get_ai_tracker_id_mentions or keyso_get_ai_tracker_id_chart, 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?

Usage context is implied rather than stated: the header implies it feeds the project table, and the example query implies it is for period-based mention reporting with system/folder filters. However, there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as keyso_get_ai_tracker_id_chart or keyso_get_ai_tracker_id_mentions.

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

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

No annotations are present, so the description must disclose behavior. It indicates a GET request, implying read-only, but does not mention authentication requirements, rate limits, error handling, or the response structure. The description is confined to request details and adds little behavioral context beyond the method.

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

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

The description is concise, front-loaded with the purpose, and includes the method, path, and an example in just three lines. There is no redundant text, and it is appropriately sized for a simple GET endpoint.

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 should explain what the response contains (e.g., progress percentage, status) and when to use this endpoint relative to others. It provides none of that, leaving the agent to infer the response format and the tool's role in the AI tracker workflow.

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 100% as each parameter has a description. The tool description adds value by showing an example request with the array syntax for ids[] (ids[]=123&ids[]=456), clarifying how to pass multiple IDs. The token and base_url parameters are standard and adequately described in the schema, so the example fills a practical 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 states the tool's purpose as 'Трекер ИИ - прогресс обновления проектов' (AI tracker - progress of project updates) and provides the HTTP method and path. This is a clear verb-resource pairing, but it does not explicitly differentiate it from sibling tools like keyso_get_ai_tracker_id_entity or keyso_get_ai_tracker_id_report, so it lacks sibling distinction.

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. It only shows an example request and does not mention conditions like 'after starting an update' or which other endpoints to consider for different data. This is a significant gap for an agent deciding between many AI tracker endpoints.

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

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

With no annotations, the description carries the behavioral burden. It does disclose 'Method: GET' and provides an example request, implying a read-only list operation. However, it does not mention response shape, pagination behavior, authentication expectations, or rate-limit 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?

The description is compact and front-loaded: a one-line purpose statement, method/path, and a concrete request example. There is no filler or redundant repetition of the schema.

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

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

For a simple GET-list endpoint with complete schema documentation, this is minimally adequate for constructing a request. However, there is no output schema or annotations, and the description does not describe the returned project objects or related clustering workflow steps, leaving some context gaps.

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?

All 6 parameters are fully described in the schema (100% coverage), so the baseline applies. The example URL demonstrates usage of sort, page, and per_page, adding minor concrete value, but it does not add meaning beyond what the schema descriptions already provide for token, base_url, or isMain.

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 opening phrase 'Список проектов кластеризатора' identifies the action (list) and resource (clustering projects), and the explicit 'Method: GET /clustering/list' makes the operation unmistakable. It does not directly contrast with sibling tools like keyso_get_projects or keyso_get_clustering_state_uid, but the endpoint path and resource scope are specific enough to distinguish.

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 about when to use this tool versus related tools such as keyso_get_projects, keyso_get_clustering_state_uid, or keyso_post_clustering. The description states the endpoint but never explains when to prefer it or when to use a sibling instead.

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

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

There are no annotations, so the description carries the behavioral burden. It explicitly declares 'Method: GET' and uses 'Получение' (retrieval), which signals a read-only operation, and gives an example request. However, it does not mention auth requirements, response format, error behavior, or rate limits.

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

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

The description is short and well-structured: purpose comes first, followed by method, path, and example. Every line earns its place, with no unnecessary filler.

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

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

For a simple GET with one required parameter, the description gives the essential endpoint mechanics: method, path, and example. However, there is no output schema and no description of what the returned 'folders' data looks like, nor any guidance on when this endpoint should be preferred over related clustering 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 100%, and the schema already explains uid, token, and base_url. The description adds a URL template and a concrete example for uid, which helps confirm how the path parameter is used, but it does not add significant meaning beyond the schema.

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

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

The description states a specific action ('Получение' — retrieving) and resource ('папок кластеризации' — clustering folders), and gives the API path. It is clear, but it does not explicitly differentiate this from the very similar sibling keyso_get_clustering_node_uid_id_keywords.

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

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

No usage guidance is provided: there is no statement of when to use this tool versus alternatives, no exclusions, and no context about which workflow requires it. The sibling list contains many similar clustering endpoints, so an agent gets no selection criteria from 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 burden of behavioral disclosure. It does not mention pagination, sorting behavior, filtering capabilities, response structure, or what 'keys' means. The example URL hints at query parameters but does not explain expected behavior or outcomes.

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

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

The description is extremely short but under-specified rather than concise. It consists of a vague phrase and a raw API path/example, lacking structure and front-loaded key information. It does not effectively communicate the tool's purpose or usage.

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 8 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the response contains, how filters work, or how to construct a valid request beyond the example. An agent would have to infer most behavior from the schema and example, which is insufficient.

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 100%, so the baseline is 3. The description does not add any semantic meaning beyond the schema; it only shows an example URL with sort and pagination parameters, which is not an explanation. The parameter descriptions in the schema are self-explanatory, so the description adds minimal value.

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 'clustering result, keys in the folder' which is vague and lacks a clear verb or resource description. It does not explicitly say it retrieves keywords for a specific node; the name implies it, but the text is ambiguous and could be interpreted as a label rather than an action. It does not distinguish this from sibling tools like keyso_get_clustering_node_uid.

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. No mention of prerequisites, when it is appropriate, or which sibling tools to choose instead. The description provides only a path and example URL, with no usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It correctly indicates a GET request (read-only) and shows an example URL, but does not describe the response format (e.g., status codes, fields like 'processing', 'completed', 'error'), whether it requires authentication beyond the token parameter, or any polling semantics. The method and path are disclosed, but critical behavior such as expected response structure is missing.

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

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

The description is very short and front-loads the purpose ('Статус обработки отчета'), followed by method, path, and an example. It avoids unnecessary words and is efficiently structured, though it could add a sentence on usage without becoming verbose.

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 status-checking tool, the description is incomplete. It lacks information about what the response contains (no output schema), how the UID is obtained (e.g., from a prior clustering creation), and when to use it relative to other clustering operations. The agent may not know if the response is a JSON object with status fields or how to interpret it. More context is needed for reliable 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 100%, so all parameters (uid, token, base_url) are documented in the schema. The description adds an example URL that illustrates the UID format (hex string), which is mildly helpful, but does not enrich the parameter semantics beyond what the schema already provides. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the tool's purpose as 'report processing status' and provides the HTTP method and path. The name and context make it distinct from sibling clustering tools (e.g., post_clustering, delete_clustering_uid, get_clustering_list), and it correctly identifies the resource (clustering state) and the required UID parameter.

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 other clustering endpoints. It does not mention that it should be used after submitting a clustering job, nor does it reference any alternatives like keyso_post_clustering or keyso_get_clustering_list. 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 burden of behavioral disclosure. It states the HTTP method, path, and an example request, which conveys this is a read-style call, but it does not mention authentication implications, rate-limit behavior, or what the response contains.

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

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

The description is compact and front-loaded with the essential resource, method, path, and example request. It avoids filler, though the Russian noun phrase rather than a proper sentence slightly reduces clarity for non-Russian agents.

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-required-parameter GET tool, the description is minimally sufficient: it provides the endpoint and example URL. However, with no output schema and no usage guidance, it leaves the agent to infer what the returned limits represent and when to prefer this over sibling limit-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 100%, so token and base_url are already documented in the input schema. The description adds no additional meaning about these parameters, which is acceptable given full schema coverage.

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

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

The description identifies the resource as tool limits ('Лимиты по инструментам') and gives the exact endpoint path /limits/all with GET method, so an agent can infer this retrieves all tool limits. It doesn't explicitly use an imperative verb or contrast with sibling tools, but the endpoint and example URL make the purpose 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?

There is no guidance on when to use this tool versus alternatives such as keyso_get_monitoring_id_limits, and no mention of prerequisites or context. The intended use is only implied by the endpoint name and 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?

There are no annotations, so the description carries the full burden. It discloses that this is a GET request and gives an example URL, implying a read-only list operation. However, it does not describe the response shape, whether pagination behavior is relevant, authentication requirements, or any other behavioral characteristics beyond the route.

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 includes only the endpoint summary, HTTP method, path, and an example request. There is no fluff, and the key intent is front-loaded, though the brevity leaves behavioral 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?

With no output schema and no annotations, the description should explain what the list contains, how results are returned, and how pagination works. It only gives a minimal phrase and an example URL, which is insufficient for a 6-parameter tool with many sibling endpoints.

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 100%, so all six parameters are already documented in the input schema. The description itself adds no parameter-level meaning, which is acceptable at baseline level, but it does not go beyond the schema.

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

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

The description states a clear resource: 'Мониторинг позиций - список проектов' (position monitoring - list of projects), with GET /monitoring, so an agent can tell it is a list operation. It does not explicitly differentiate it from sibling tools like keyso_get_projects or other monitoring endpoints, so it is clear but not fully distinguishing.

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 about when to use this tool versus alternatives such as keyso_get_projects, keyso_get_monitoring_state, or keyso_get_monitoring_id_* endpoints. The HTTP path is provided but not framed as usage guidance.

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

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

No annotations are provided, so the description carries the full burden. It does disclose useful behavioral traits: the HTTP method (GET), the path template `/monitoring/<id>/dates`, and the core trait that only dates with existing data are returned. However, it omits response format, error behavior, and auth prerequisites, which matters more given there is no output schema.

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

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

The description is compact and front-loaded: one purpose sentence, then method/path, then a single example. Every element earns its place and there is no redundancy. The dash-constructed first sentence is slightly telegraphic but 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?

For a simple read endpoint with 1 required parameter and full schema coverage, the description covers purpose, path, and example invocation. The main gap is the exact response shape, which is not described and there is no output schema, though 'all dates' gives a reasonable hint. The endpoint's simplicity limits the impact of this omission.

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 100%, and the schema's searchSettings[] description is already detailed (regionId, engine ID mapping, optional language). The description adds concrete value with a real request example, `searchSettings[]={"regionId":38,"engine":0}`, which clarifies the exact JSON string format for the query parameter beyond what the schema states.

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

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

The description identifies a specific resource (dates for position monitoring) and scope (filtered by region): 'все даты, по которым есть данные по фильтру регионов'. It distinguishes itself from the many monitoring_id_* siblings by being clearly about date availability rather than reports, limits, or entities. However, the verb is only implied, and it doesn't explicitly contrast with a sibling like keyso_get_monitoring_id_report.

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 use case is implied: call this to discover which dates have position data under a given region filter. The Method/Path block and the example request show how to invoke it. But there is no explicit statement of when to prefer it over alternatives or when not to use it, and no relation to sibling report endpoints is explained.

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 discloses the HTTP method (GET), the path, and the kind of content returned, which implies a read-only operation. However, it does not go deeper into response format, authentication requirements, pagination, or error behavior, leaving some behavioral gaps.

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

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

The description is compact and front-loaded with the tool's purpose, followed by method, path, return summary, and an example URL. There is minimal redundancy, though the opening 'Мониторинг позиций - сущность проекта' is somewhat label-like and could be merged more elegantly.

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 GET with one required parameter and no output schema, the description gives enough to attempt a call: path, example, and return content categories. However, it lacks response format details and any mention of authentication requirements or error cases, which would make it fully self-sufficient for an agent.

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 100%, so the baseline is 3. The description does not add semantic meaning for `id`, `token`, or `base_url` beyond what the schema states; the path example hints at how `id` is used, but the parameter descriptions themselves remain thin.

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

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

The description clearly states the tool returns a full entity description for a monitoring project, naming the resource (`/monitoring/<id>/entity`) and the verb (GET). It lists what the response includes (search settings, update schedules, alerts, child projects), which is specific enough to distinguish it from report/date/limit siblings, though it never names a sibling 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?

There is no explicit guidance about when to use this tool versus alternatives such as `keyso_get_monitoring`, `keyso_get_monitoring_id_limits`, or `keyso_get_monitoring_id_report`. The phrase 'full description of the project entity' implies usage for retrieving entity configuration, but no when-to-use or when-not-to-use conditions 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?

With no annotations, the description must carry behavioral context. It states it is a GET request (implying read-only) and mentions the default behavior of returning limits for the whole project when no data is provided. However, it does not disclose authentication requirements, rate limits, error conditions, or the exact response format beyond a count. This is minimal disclosure.

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

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

The description is compact, containing a brief purpose statement, the method and path, a clarification about default behavior, and an example. The information is front-loaded with the main purpose first. It is well-structured and avoids redundancy.

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

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

For a simple GET endpoint with five parameters (all documented in schema) and no output schema, the description provides the essential context: the endpoint, method, and an example. However, it does not specify the response format beyond 'number of limits' or address authentication requirements. While adequate for a basic read operation, it leaves some gaps.

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 100%, so the schema already documents all parameters. The description adds a practical example with searchSettings and aids, and clarifies the default behavior when these are omitted. This adds a small amount of value beyond the schema, but does not deeply explain each parameter's meaning or constraints.

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 limits') and resource ('monitoring positions'), and provides the exact endpoint path and HTTP method. It distinguishes itself from other monitoring tools by focusing on 'necessary limits for updating' but does not explicitly contrast with sibling tools. It is clear enough, though the term 'limits' could be more precise.

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 does not specify when to use this tool versus other monitoring tools. It only notes that if no data is provided, limits for the entire project are returned, which is more about parameter behavior than usage guidance. There is no mention of prerequisites, exclusions, or alternative 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. It discloses the HTTP method (GET) and shows an example request, implying a read operation. However, it does not explain response format, pagination behavior, sorting details, authentication requirements, or rate limits. The example shows per_page and page, but without explanation, which is a 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 brief and front-loads the purpose, then includes method, path, and an example. It avoids fluff and is efficiently written, though it could be slightly better structured with explicit sections. The length is appropriate.

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

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

Given the tool's complexity (12 params) and absence of an output schema, the description is minimal. It provides a basic idea of what the report contains (positions for a project) but does not explain the returned fields, sorting, pagination, or how to interpret the data. It also lacks guidance on selecting this tool over siblings. Schema covers parameters, but the description leaves out important usage context.

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

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

Schema description coverage is 100%, so all 12 parameters are documented in the schema. The description adds marginal value by showing a real usage example, particularly for the searchSettings[] parameter with JSON syntax. But it does not compensate for any missing schema details; the schema is the primary source of parameter meaning.

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

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

The description states a specific action (получение отчета по позициям проекта) and resource (monitoring/<id>/report). It differentiates from the broader monitoring endpoints by specifying 'данные для таблицы проекта' and includes a concrete example. However, it does not explicitly name sibling tools like keyso_get_monitoring_id_report_chart or report_compare, leaving some ambiguity.

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 context (period, filters) and an example, but does not explicitly state when to use this tool over alternatives such as the chart or compare reports. There is no guidance on when not to use it or prerequisites. The phrase 'данные для таблицы проекта' hints at the table view, but it's implicit.

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

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

With no annotations, the description must carry the full behavioral burden, but it only states GET, the path, and that data is aggregated. It omits response shape, pagination behavior, required dates, auth/token handling, and the endpoint is internally inconsistent because the example calls report-compare rather than report-chart.

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 compact and front-loaded, but the opening line and the subsequent purpose sentence largely repeat the same chart-data idea. The example is useful yet introduces a mismatched endpoint, so the structure is acceptable but not 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 12-parameter tool with no output schema and no annotations, the description is too thin: it does not explain what the returned chart data looks like, how parameters interact, or what prerequisites exist. An agent would need to infer most call details from the schema and the partially inconsistent example.

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 100%, so the schema already documents all parameters; the description adds little beyond an example query showing dateFrom, dateTo, per_page, page, sort, and searchSettings. This is useful context, but it does not materially improve on the schema descriptions.

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 purpose: Получение агрегированных данных по позициям фраз проекта для графика, so an agent can understand it returns chart data for monitoring positions. It does not explicitly differentiate from sibling monitoring report endpoints, and the example path uses report-compare instead of the declared report-chart, which slightly weakens precision.

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

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

There is no guidance about when to prefer this tool over siblings such as keyso_get_monitoring_id_report or keyso_get_monitoring_id_report_compare. The only implicit hint is данные для графика, but no exclusions, alternatives, or preconditions 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 burden. It discloses that this is a GET request returning aggregated comparative data, but it doesn't mention pagination behavior, sorting defaults, required date range semantics, or what happens if no previous snapshot exists. The example request is helpful but doesn't cover edge cases or response format.

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

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

The description is compact: one sentence of purpose plus an example request. The example is valuable and front-loaded. It could be slightly more structured, but it earns its place and doesn't waste words.

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 GET endpoint with 12 parameters and no output schema, the description provides the core purpose and a working example, which is adequate for basic invocation. However, it lacks guidance on response structure, error cases, and how this compare report differs from other monitoring reports. Given the tool's complexity and the absence of annotations, a bit more context would be needed for full completeness.

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 100%, so the schema already documents all 12 parameters. The description adds a concrete example URL showing how dateFrom, dateTo, per_page, page, sort, and searchSettings[] are used together, which adds some value beyond the schema. However, it doesn't explain the meaning of the response or how parameters interact beyond the example.

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: 'Получение агрегированных сравнительных данных по фразам между текущим и предыдущим съёмом' (getting aggregated comparative data on phrases between current and previous snapshot). It also includes the HTTP method and path, which helps identify the endpoint. However, it doesn't explicitly distinguish itself from sibling tools like keyso_get_monitoring_id_report or keyso_get_report_compare_view_organic, so it's clear but not fully differentiated.

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

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

The description implies usage context: it's for comparing current vs previous monitoring snapshot data, and the example request shows how to call it. But it doesn't explicitly state when to use this tool versus alternatives like keyso_get_monitoring_id_report or the report_compare_view tools. No exclusions or alternative routing are provided.

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

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

With no annotations, the description carries the full burden, but it only provides the HTTP method, path, and an example query. It does not disclose whether the operation is read-only beyond the implied GET method, what the response shape contains, whether an API token is required, or any rate-limit/error behavior.

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

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

The description is compact and front-loaded with the purpose, followed by method, path, and a concrete example. Every line earns its place, though the dash-fragment phrasing is telegraphic rather than a complete sentence.

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 and no output schema, the description omits crucial context about what the 'state' response looks like and what fields an agent should expect. It is sufficient to construct the GET request but not to interpret the result or handle failure cases.

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 100%, so the schema already documents ids[], token, and base_url. The example request adds a concrete encoding detail (repeated ids[]= query parameters) that is not explicit in the schema, but it does not materially extend the meaning of the parameters.

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

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

The description identifies the resource as monitoring state and the concept as 'progress of updating projects' ('Мониторинг позиций - прогресс обновления проектов'), which is enough to infer it returns update progress. It does not use an explicit verb like 'retrieves' and does not name a sibling, but the state/progress framing differentiates it from the broader get_monitoring/list tools.

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

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

No guidance is given on when to prefer this over sibling tools such as keyso_get_monitoring or other state endpoints. The 'progress update' phrase implies a status-check use case, but there are no prerequisites, exclusions, or alternative routes.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does include 'Method: GET', which implies a read-only operation and suggests no side effects, but it does not state this explicitly nor mention authentication requirements, rate limits, or whether the endpoint returns sensitive data. The minimal information is insufficient for an agent to fully assess 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 extremely concise with three short lines: a purpose statement, the HTTP method, and the path. It front-loads the purpose and avoids superfluous text. The example request is redundant with the path but not harmful. Slightly less polished than the ideal because of that redundancy, but still well-structured.

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

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

For a simple list endpoint with no required parameters and no output schema, the description gives enough to make the call (method and path), but it omits any indication of the response shape, such as whether it returns project IDs, names, or other fields. Given the large set of sibling tools that likely consume project IDs, this missing context makes it harder for an agent to chain calls effectively.

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

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

The input schema fully describes the two parameters (token and base_url) with 100% coverage. The description adds no additional parameter meaning, but since the schema already handles semantics, the baseline of 3 is appropriate.

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

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

The description explicitly states 'Список проектов' (List of projects) and provides the HTTP method GET and path /projects, which clearly identifies the operation as retrieving a list of projects. It does not explicitly contrast with sibling tools like keyso_post_projects or keyso_get_projects_competitors, but the name and path make the resource and action unambiguous.

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

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

The description offers no guidance on when to use this tool versus alternatives. It merely lists the endpoint and method without any context such as 'use this to enumerate all projects' or 'compare with keyso_post_projects for creation'. There is no mention of prerequisites, typical workflows, or exclusions, leaving the agent to 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 must disclose behavior. It states method and path but does not mention read-only semantics, authentication requirements, rate limits, pagination, or what happens on failure. It gives a sample URL but nothing about the actual behavior beyond that it is a GET request.

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 free of fluff, presenting the essential endpoint information. It is front-loaded with the purpose phrase. However, it lacks crucial details, so while concise, it is under-specified. Still, for what it includes, it is efficient.

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

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

Given there is no output schema, the description should explain the return format, but it does not. It also does not differentiate among the numerous sibling tools. For a tool with a clear API endpoint, an agent would need more context to know if this is the right call and what to expect 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?

Schema coverage is 100%, so the baseline is 3. The description shows an example using projectId, which adds a concrete context, but it doesn't clarify semantics beyond what the schema already provides. The token and base_url parameters are standard and not elaborated.

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 Russian phrase 'Сравнение с конкурентами' (comparison with competitors) plus method, path, and example. It indicates the tool retrieves competitor comparison data for a project, but doesn't specify what the response contains or how it differs from other competitor-related tools. The verb 'get' is implied by method, but the purpose is not sharply defined.

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 tool versus the many sibling tools that also deal with competitors (e.g., keyso_get_projects_recommended_competitors, keyso_get_report_simple_organic_concurents, keyso_get_ai_tracker_id_competitors). There is no mention of alternatives or conditions for selection.

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

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

No annotations are provided, so the description must carry the full burden. It reveals the HTTP method (GET) and an example, implying a read operation, but it does not state whether the operation is safe, any side effects, authentication requirements, or response format. The agent cannot know what happens beyond the call.

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 concise, front-loading the purpose and immediate technical details (method, path, example) without fluff. It is easily scannable, though the example could be seen as redundant given the schema, but overall it is appropriately compact.

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 absence of an output schema and annotations, the description is incomplete. It does not describe the response structure, expected data shape, or any post-processing steps. For a tool that returns recommended competitors, the agent lacks information to interpret results, making the definition insufficient for effective use.

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 100%, so all three parameters (token, domain, base_url) already have descriptive documentation. The description adds minimal value by showing an example with the required 'domain' parameter, but it does not elaborate on parameter behavior or constraints beyond the schema. This matches the baseline for high schema coverage.

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

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

The description states the exact purpose (recommended competitors) and gives the HTTP method, path, and example. It clearly identifies a read operation for a specific resource (competitors for a domain), but does not explicitly differentiate from sibling tools like keyso_get_projects_competitors, which may have similar scope. Still, the naming and example make the purpose 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 guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, scenarios, or differentiators from similar competitor-endpoint tools. The description only supplies the endpoint and example, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the HTTP method (GET) and path, implying a read operation, but says nothing about response format, pagination behavior, constraints (e.g., groupingBy requires filter), authentication, or side effects. This is a major gap for a tool with no structured metadata.

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

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

The description is short and front-loads the resource name, but it lacks structure and completeness. The example URL is a long, dense string that is hard to parse, and the overall content is under-specified for an agent. It is concise but not effectively organized for decision-making.

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 7 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the tool returns, how results are structured, or any important constraints (e.g., groupingBy only works with filter). The minimal text leaves the agent with insufficient information to call the tool correctly and interpret results.

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

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

Schema coverage is 100%, giving a baseline of 3. The description adds a concrete example URL that demonstrates the syntax for filter (using LIKE and OR operators) and shows how to combine sort, page, per_page, groupingBy, and filter. This goes beyond the schema, which only links to a documentation section for filtering, and clarifies parameter usage in practice.

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 a Russian noun phrase 'Объявления в РСЯ' ('Ads in RSYA') that restates the tool name without any verb or explicit action. It does provide the HTTP method and path, but fails to state what the tool does (e.g., retrieve, list, filter) or how it differs from sibling tools like keyso_get_report_ads_rsya_domains_domain.

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. No mention of prerequisites, typical scenarios, or exclusions. The description simply gives a label and technical details, leaving the agent without any decision support.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure, but it only states the purpose and shows a request example. It omits auth requirements (the token parameter appears only in the schema), rate limits, pagination semantics, and response 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?

Four short lines with the purpose front-loaded, followed by method, path, and a concrete example. The example is slightly verbose with URL-encoded values, but there is no wasted prose.

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

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

With seven parameters, no output schema, and no annotations, the burden falls entirely on the description, which omits the response format, accepted filter values (it only references a docs section), and authentication details. This is inadequate for an agent to call the tool correctly and safely.

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 100%, so the baseline is 3. The example URL demonstrates `sort=found_at%7Casc`, `page=1`, and `per_page=25` in real usage, adding slight value beyond the terse schema descriptions, but the description itself adds no new 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?

Объявления в РСЯ сайта names a specific resource (ads in the Yandex Advertising Network) scoped to a domain, and the path template `/report/ads/rsya/domains/<domain>` confirms the intent. However, the description does not differentiate it from the sibling `keyso_get_report_ads_rsya`; the agent must infer the per-domain scope from the name and path 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?

No guidance on when to use this tool versus alternatives such as `keyso_get_report_ads_rsya` or other report siblings. There are no exclusions, prerequisites, or selection criteria stated anywhere 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?

With no annotations, the description carries the behavioral disclosure burden. It does reveal the HTTP method (GET) and path, which implies a read operation, but it does not state what the comparison output looks like, whether authentication or a token is required, how pagination works, or any limits. This is minimal beyond the name and schema.

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

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

The description is compact: a one-line purpose, the method and path, and a single concrete example. There is no fluff, and the example earns its place by demonstrating the required `incl`/`excl` and the fixed `view=backlinks` parameter.

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 10 parameters, no output schema, and no annotations, the description is too thin. It omits the response format, token/auth expectations, when to set `view` versus relying on the path, and does not orient the agent among the large sibling toolset. The example shows usage but leaves critical operational context 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?

Schema coverage is 100%, so the baseline is 3. The example URL does add practical meaning by showing concrete values for `base`, `incl`, `excl`, `view`, `sort`, `page`, and `per_page`. However, the description does not explain the meaning of the parameters themselves; that burden remains on the schema.

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

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

The description states a specific verb and resource: 'Сравнение сайтов по ссылкам' ('Compare sites by links'), and the path `/report/compare?view=backlinks` clarifies the exact scope. It distinguishes from the organic and context compare siblings through the 'backlinks' focus, though it does not explicitly name or contrast 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 tool over the sibling compare tools (`view_organic`, `view_context`) or any other report tool. The example request is helpful but does not explain prerequisites, ideal use cases, 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 supplied, so the description carries the full burden of behavioral disclosure. It does disclose the HTTP method GET and the endpoint path, which indicates a read-only report call, and provides an example query. However, it does not describe the response format, pagination behavior, authentication requirements, or any limitations.

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

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

The description is short and front-loaded with the purpose statement, and the method/path information is useful. The example is somewhat redundant and contains a mismatched view value, making the overall structure less clean and trustworthy than it could be.

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

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

For a 10-parameter report endpoint with no output schema and no annotations, this description is incomplete. It does not explain what the returned comparison contains, how to authenticate, or when to use this tool instead of the sibling compare views. The schema covers parameters, but tool-level context is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The example query adds concrete formats for sort (`numwords|desc`), page, per_page, and the required incl/excl parameters. However, the example uses `view=organic` for a tool named and described as `context`, which undermines its usefulness and could mislead an agent.

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

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

The description opens with 'Сравнение сайтов в контекстной рекламе' (compare sites in contextual advertising), giving a specific verb and resource. This clearly identifies the context-advertising variant of the compare report, matching the tool name and the view enum. It does not explicitly contrast with the organic/backlinks sibling views, but the domain term is specific enough.

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 keyso_get_report_compare_view_organic or keyso_get_report_compare_view_backlinks. The description states only what the tool does, with no selection criteria, exclusions, or alternative routing.

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. It reveals the HTTP method and path, but does not describe the response format, pagination behavior, authentication needs, rate limits, or any other runtime behavior. The GET method implies a read operation, but that is not explicitly stated.

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 compact and front-loaded with the purpose, followed by method, path, and a single useful example. Every part earns its place, though a slightly more structured layout would improve scannability.

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 10 parameters, no output schema, and no annotations, the description is too thin. It does not explain what the response contains, how pagination defaults work, what `base` means, what filtering is possible, or what authentication is required. An agent can copy the example but cannot fully reason about edge cases.

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 100%, but the example URL adds practical meaning beyond the bare 'in: query' descriptions: it shows comma-separated domains for `incl`/`excl`, the pipe-separated `sort` format, and the use of `page`/`per_page`. It also gives context to the otherwise undocumented `base` parameter via `base=msk`.

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 'Сравнение сайтов в органическом поиске' and includes the exact path `/report/compare?view=organic`, identifying both the resource and the specific organic view. This differentiates it from the sibling context and backlinks compare tools.

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

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

The description gives a concrete example query and states this is for organic search comparison, so the intended context is clear. However, it does not explicitly say when to use this tool instead of `keyso_get_report_compare_view_context` or `keyso_get_report_compare_view_backlinks`, leaving the choice implied rather than 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention return format, side effects, authentication, rate limits, pagination behavior, or any operational details beyond an example URL. The method and path are given, but these are structural rather than behavioral. The lack of any behavioral context is a significant 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 brief, which is concise, but it is not well-structured: it starts with a fragment, then gives method/path, then an example. The key purpose is not front-loaded clearly. It lacks a proper sentence structure and mixes unrelated elements. It is under-specified rather than efficiently concise.

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

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

Given the tool has 7 parameters, 1 required, and no output schema, the description should explain what the response contains and how it fits into the broader report group workflow. With many sibling tools, it does not help the agent understand when to choose this endpoint. The example query hints at pagination and sorting but does not describe the result structure or use case. It is incomplete for effective use.

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

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

The input schema has 100% coverage with descriptions for all 7 parameters, including format details for 'sort' and pagination parameters. The description adds no additional parameter semantics beyond what the schema already provides, so a baseline score of 3 is appropriate.

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 'Contextual advertising - ads, unique facts of the group' which identifies the resource type but does not use a clear verb or fully describe the action. It relies on the tool name for the 'get' intent. It distinguishes from sibling tools like context_ads and context_ads_links by specifying 'unique facts', but the phrasing is fragmentary and lacks explicit action.

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 sibling tools (e.g., keyso_get_report_group_context_ads_rid, keyso_get_report_simple_context_ads_facts). The only differentiator is the name and the fragment, which implies it retrieves unique facts for a group. No exclusions or alternative suggestions 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. It states the HTTP method and path plus an example URL, but discloses nothing about response shape, pagination semantics, sorting behavior, or what data fields are returned for these 'unique links'.

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 text is compact and the example URL is useful, but it reads as a sparse noun-phrase header plus boilerplate method/path lines. It earns its brevity but sacrifices explanatory 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?

For a moderately complex report tool, the schema covers all parameters and the example shows realistic usage. However, without an output schema and without any behavioral description of what the 'unique links' payload contains, an agent 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?

Schema coverage is 100%, so all seven parameters are documented in the schema. The example request adds a little value by demonstrating sort (`cnt|asc`), page, and per_page usage, but the description itself adds no parameter meaning beyond that.

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 the resource ('Contextual advertising - ads, unique links of the group') and the path/method make the GET action clear. However, it's a noun phrase rather than an action statement, and it does not differentiate this tool from close siblings like keyso_get_report_group_context_ads_rid or keyso_get_report_group_context_ads_facts_rid.

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. With roughly twenty report-group siblings (context_ads, context_ads_facts, context_keywords, context_concurents, etc.), the absence of any selection criteria is a significant gap.

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 burden of behavioral disclosure. It only gives the HTTP method and path, plus an example URL. It does not describe pagination behavior, default sort, response format, or whether filters apply to ads in any particular way.

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

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

The description is short and includes the method, path, and an example request. The example is useful and front-loaded. It could be slightly more structured, but overall it is concise and informative without unnecessary filler.

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

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

Given the tool has no output schema and no annotations, the description provides only the HTTP endpoint and a sample call. It lacks information about return shape, error cases, or how ads differ from related context group endpoints. It is minimally adequate for a simple retrieval endpoint but leaves operational gaps.

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 100%, so the schema already documents all parameters. The description adds minimal value beyond the example URL, which demonstrates rid, sort, page, and per_page usage. It does not explain the rid semantics beyond 'Идентификатор отчёта' or clarify filter syntax, but the schema already covers the basics.

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

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

The description 'Контекстная реклама - объявления группы' identifies the resource as context ads group records, and the path clarifies it fetches ads for a specific report group. It is clear enough to distinguish from siblings like group context keywords or concurents, though it does not explicitly name a sibling or state the action verb (e.g., 'get').

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

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

The description implies this tool is for retrieving context ads data within a report group, which is suggested by the path and sibling names. However, it does not explicitly state when to use this versus alternatives like context_ads_links or context_ads_facts, nor does it mention prerequisites such as having a valid report rid.

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. It does reveal that this is a GET request with the path and example query parameters, but it does not disclose response shape, pagination behavior, authorization needs, rate limits, or how the 'competitors' data is derived. This is minimal coverage for a tool with no annotations.

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 compact and follows a logical structure: domain label, method/path, and a real example URL. There is no filler or redundant prose. Although the opening label is vague, the technical details are efficiently presented.

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 report endpoint with no output schema, no annotations, and seven parameters, yet the description provides no information about the returned competitor data, how it relates to the parent group report, or what distinguishes it from similar context/organic competitor endpoints. The example query is helpful but insufficient for confident tool selection and 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 100%, so the schema already documents all parameters. The example URL adds a concrete illustration of sort, page, and per_page usage, but it does not add significant meaning beyond the schema. Baseline 3 is appropriate.

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 a noun phrase: 'Контекстная реклама - конкуренты группы' ('Contextual advertising - group competitors'). It restates what the tool name already conveys without using a verb or stating what data is returned. The method/path/example provide technical routing but do not clarify the tool's purpose beyond 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 about when to use this tool versus its many siblings, such as the organic competitors endpoint or the context keywords/ads endpoints. The example request implies usage but never states a selection condition, prerequisites, or alternatives.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose that this is an HTTP GET with an example request, signaling a read-only operation. However, it says nothing about authentication requirements, pagination behavior, error cases, or what response the caller should expect, leaving key behavioral details undisclosed.

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 compact and front-loaded, with a resource label, method, path, and a concrete example request. Every element is relevant, though the brevity leaves behavioral and usage 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?

Given the large set of similar sibling tools, no output schema, and no annotations, the description is too sparse. It does not explain what the report contains, how rid relates to other report endpoints, or how this endpoint differs from the simple/group context keyword alternatives.

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 100%, so the schema already documents every parameter. The description only adds an example URL illustrating sort, page, and per_page usage, which is mildly helpful but does not add new meaning beyond the schema.

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

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

The description identifies the resource as context-advertising group keywords and provides the HTTP method and path, so an agent can infer it retrieves keywords for a group report. It lacks an explicit verb such as 'list' or 'retrieve', but the resource label is specific enough to distinguish it from sibling ad/domain endpoints.

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 exclusions, and no mention of alternative tools such as keyso_get_report_simple_context_keywords or the organic group keyword endpoint. The label only implies the general resource type without explaining when this endpoint should be selected over its many 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It adds only 'Method: GET', which implies a read-only operation, and an example URL showing pagination params. It says nothing about authentication requirements, rate limits, pagination behavior, or response shape — all unstated for a tool with no annotation support.

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

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

The description is short and front-loaded: a one-line purpose, the HTTP method, the path template, and a concrete example URL. There is no filler or redundancy, though the example overlaps somewhat with the path template.

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 and no annotations, this description should compensate by explaining what the response contains and when to call the tool. It does neither. For a seven-parameter endpoint in a large family of near-identical report endpoints, 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?

Schema description coverage is 100%, so the baseline of 3 applies. The description's example query (sort=it50%7Cdesc&page=1&per_page=25) adds modest value by demonstrating the sort format and query parameter usage in context, but it does not explain any parameter beyond what the schema already documents.

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 'Домены в отчете' (domains in the report) and gives an explicit HTTP method and path template (/report/group/domains/<rid>), so an agent can tell it fetches the domain list for a report group. However, it does not explicitly differentiate itself from the many similar report_group_*_rid siblings (organic_keywords, context_ads, etc.), leaving that to 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?

No guidance is given on when to use this tool versus the numerous sibling tools. With over a hundred siblings including many report_group_*_rid endpoints, the absence of any stated use case, precondition, or alternative routing is a significant gap. Usage is only implied by the resource path and 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?

Method GET and the full path /report/group/list are disclosed, which signals a read-only collection operation, and the example URL demonstrates query usage. However, with no annotations and no output schema, the description does not cover auth requirements, response format, pagination defaults, or error behavior.

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

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

The description is compact and front-loaded: a short label, method/path, and one illustrative example. There is no filler, though the first line largely restates the tool name and the example is the only material addition.

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

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

With no annotations and no output schema, the description should explain what the response contains, default pagination, auth expectations, and how this endpoint relates to the many sibling report tools. The current description is too sparse for an agent navigating a large tool set.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the schema. The description adds a concrete example URL showing sort, page, and per_page usage, which is helpful but does not substantially expand parameter semantics beyond the schema.

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

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

The description states 'Список групповых отчетов' (list of group reports), giving a clear verb and resource, and it is reinforced by the HTTP method and path. It is distinguishable from the numerous report_* siblings by its list scope, though it does not explicitly name a sibling or exclusion.

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 keyso_post_report_group or the various keyso_get_report_group_* endpoints. The description only provides the endpoint and an example request, leaving usage conditions and exclusions 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the HTTP method (GET) and a sample request URL with sort, page, and per_page parameters, but does not describe the response shape, pagination behavior, the meaning of the 'concurents' output, or any rate/auth constraints. For a data-retrieval tool this is minimal disclosure.

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

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

The description is extremely short and front-loads the purpose in one line, followed by method/path/example. It is concise but under-specifies; brevity here reflects omission rather than efficient density, so it does not earn a higher score.

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 7-parameter tool with no annotations and no output schema, so the description must compensate. It does not explain what data the response contains, how filtering works, what 'concurents' refers to in organic context, or how this differs from the many similar sibling reports. Incomplete for an agent to call it correctly with confidence.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters. The example URL does demonstrate the sort format (cnt|desc) and query construction, adding marginal value, but the description itself contributes no parameter meaning beyond what the schema provides. Baseline 3 is appropriate.

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 'Органическая выдача - конкуренты группы' (Organic results - group competitors) largely restates the tool name. It adds the HTTP method and path, but provides no substantive statement of what the tool actually does beyond what the name already conveys. Among ~30 report-group siblings, nothing distinguishes this from keyso_get_report_group_organic_keywords_rid or the simple variants.

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 tool versus alternatives. It does not explain the difference between group-level and simple-level reports, nor between organic and context competitors, despite many sibling tools covering these exact distinctions. The only hint is the embedded path, which the agent must interpret itself.

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 discloses only the HTTP method and path, which are already implicit in the tool's purpose. It does not mention authentication, rate limits, pagination behavior, or the nature of the response. An agent has no idea what data is returned or if there are any side effects.

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

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

The description is very short, with a title-like line, method/path, and an example. It is front-loaded and has no filler. The example is valuable for illustrating query parameters. It is concise but could be better structured as a complete sentence.

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 7 parameters, no output schema, and a large set of similar siblings, the description is far too sparse. It lacks any explanation of the report group concept, the expected response structure, or when this endpoint is relevant. An agent would struggle to call it correctly without additional context.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds only a concrete example URL that illustrates sort, page, and per_page usage, which is mildly helpful but does not go beyond what the schema provides. Baseline 3 is appropriate.

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 the resource ('organic keywords of the group') and implies the action via the GET method, but it reads more like a title than an explanatory sentence. It does not explicitly say 'get' or 'fetch', and it does not differentiate from sibling tools like keyso_get_report_group_organic_concurents_rid or keyso_get_report_group_organic_sitepages_rid, which share the same group/organic scope.

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

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

There is no guidance on when to use this tool versus the many alternatives. No mention of group vs. simple reports, no conditions for selection, no exclusions. The example URL is the only extra info, but it does not help an agent decide between this and a sibling.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that the operation is a GET and provides the exact path and a concrete example URL, signaling a read operation, but it omits authentication needs, rate limits, error behavior, response shape, 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 compact and logically ordered: human-readable title, method, path, then example. It contains no filler, though its brevity limits the depth of the guidance it provides.

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 GET endpoint with seven parameters and no output schema, this description is thin. It does not explain the report-group concept, how to obtain or validate rid, what fields the response contains, or how this endpoint differs from the simple organic sitepages variant.

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 100%, so the baseline is 3. The description's example URL reinforces how sort, page, and per_page are used, but it does not add meaning beyond the schema descriptions for rid, filter, token, or base_url.

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 the resource ('Органическая выдача - страницы группы') and gives the HTTP method and full path, which together identify this as a GET for organic site pages inside a report group. It is clear but does not distinguish the tool from siblings like keyso_get_report_group_organic_keywords_rid or keyso_get_report_simple_organic_sitepages.

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

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

No guidance is provided about when to use this tool versus the many related report-group or simple-report endpoints. There is no mention of prerequisites, such as having created a report group, or of alternatives for simple organic sitepages.

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 burden of behavioral disclosure. It reveals only that this is a GET request for status, but does not mention that it is a polling endpoint, what status values may be returned, whether it is safe to call repeatedly, or any rate limits. The lack of output schema makes this gap more significant.

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 compact and front-loaded: the purpose statement, HTTP method, path, and a concrete example are all included with no redundancy. Every sentence contributes practical calling information.

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

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

For a simple status endpoint, the description provides enough to make the call successfully (method, path, example). However, it omits what the response contains or how to interpret statuses, which is important since there is no output schema. It also lacks guidance on when to poll or how long to wait, so an agent is left partially unguided.

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

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

The input schema covers 100% of parameters, so the baseline is 3. The description adds an example URL showing a concrete rid value, but does not explain what rid refers to (e.g., a report group ID) or add semantics for token/base_url beyond the schema descriptions.

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 the tool's purpose as 'Статус обработки отчета' (report processing status) and specifies the HTTP GET method and path, making the resource clear. It is distinguishable from sibling data-retrieval tools by the 'state' path component, though it does not explicitly contrast with other status tools like keyso_get_clustering_state_uid.

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 after creating a report group via keyso_post_report_group or as a polling mechanism. The path implies a follow-up status check, but this is not stated explicitly, leaving the agent to infer the usage context.

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