Mercado Livre Vendedor

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

Annotations include readOnlyHint=false, idempotentHint=true, destructiveHint=false. The description adds context about the login mechanism: it's a session-only login if token is pasted, or it returns a link for browser login. It also mentions the token is a JWT and how to make it permanent. It does not contradict annotations. It adds useful behavioral context beyond 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 two sentences but quite dense with information. It front-loads the purpose and then gives instructions. It could be more structured, but every sentence provides value. No fluff.

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 simplicity (1 optional param, no output schema), the description covers the essential context: how to authenticate, where to place the token, and the two modes. It lacks a bit on error handling or what happens after authentication, but for this tool it's adequate. Siblings like 'connect' might have overlap, but the description is clear enough.

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 has one optional parameter 'token' with no description. The description explains that 'token' is a JWT pasted by the user. It says 'call with { token: "<jwt>" } after the user pastes'. This adds meaning to the parameter beyond the schema. However, since there is only one parameter and the description covers it well, but schema description coverage is 0%, yet the description compensates. Baseline is 3 with high coverage, but here coverage is 0% and description compensates, so a 3 is fair.

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: to authenticate the IDE agent with the Mercado Livre API. It explains two methods: browser login (link generation) and pasting a token. However, it doesn't explicitly name the resource 'Mercado Livre' but it is implied by the token and context. It distinguishes from siblings like 'connect' but not explicitly.

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

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

The description provides explicit usage guidance: it explains when to use the tool (after user pastes token, or to get a link), and recommends the best practice (adding token to config for permanent connection). It also clarifies session-only login vs. permanent connection. This is clear when-to-use and when-not.

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 already declare readOnlyHint:true, idempotentHint:true, and destructiveHint:false, so the agent knows it is a safe, non-changing read operation. The description adds valuable context about the response structure (authenticated flag, pending array, connect_url) and what triggers different outputs, which goes beyond annotation information.

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 states the main purpose and then explains the two possible outcomes. Every sentence adds informative value, with no redundancy. It is appropriately sized for a zero-parameter tool.

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

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

For a status-checking tool with no parameters and no output schema, the description covers the key behavioral aspects: what it returns and the conditions for different results. It does not explain whether URL differences might exist for different providers, but this is minor given the simple nature of the tool. The description is complete enough for an agent to understand the tool's purpose and output.

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

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

The tool has zero parameters and the schema coverage is 100% (automatically, since no properties). With no parameters, the description does not need to explain parameters, but it does explain the output meaning based on connection state, which indirectly informs what the tool returns without input. This is sufficient.

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 connection status and URLs, specifically indicating the conditions for authenticated:true and empty pending[], and mentions connect_url for missing credentials. It distinguishes itself from authentication by focusing on status rather than the action of authenticating, though it does not explicitly name the alternative 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 description implies usage context: check connection status before using other tools, especially when credentials may be missing. It explains what happens in different states (all connected vs. missing credentials), which helps the agent decide when to use it. However, it does not explicitly compare to authenticate or other 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?

The description discloses important behavioral traits beyond annotations: writes require workspace owner/admin, invoke returns connect or checkout links, and it explains the one-off vs permanent installation difference. Since readOnlyHint=false is consistent with the described write operations, there's no contradiction. It adds auth, payment, and permission context that annotations lack.

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 long but every sentence adds value, covering flow, auth, payment, and prompt library. It is front-loaded with the core purpose ('The official mcp.ai marketplace'). While it could be better organized with bullet points, the length is justified given the tool's complexity and multiple actions.

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

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

The description covers the full lifecycle: discovery (search), inspection (describe), execution (invoke), persistence (install), billing (subscribe/cancel), and the prompt library. It also includes edge cases like auth connect links, payment top-up links, and retry instructions. For a tool of this complexity with no output schema, this is highly complete.

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

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

Although schema description coverage is 0%, the description compensates by explaining the action enum values and the core flow involving mcp_id, tool_id, and arguments. It also covers the prompt-related parameters via the prompt library. However, not every parameter (e.g., limit, immediate, cancel_reason) is explicitly explained, leaving some gaps for a tool with 23 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 clearly defines the tool as the official mcp.ai marketplace and execution layer, with specific verb+resource pairs ('search', 'describe', 'invoke', 'install'). It distinguishes from sibling tools like mercadolivre_* by stating it's an in-platform catalog and run mechanism, leaving no ambiguity about its core function.

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 explicit guidance on when to use which action: 'prefer invoke for a single/occasional use' vs 'use install only to make an MCP PERMANENT', and mentions 'request_mcp asks us to build a NEW MCP when nothing fits'. It also states that list_tools lists what is callable right now, providing clear alternatives for each scenario.

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 already declare readOnly, non-destructive, and idempotent. The description adds minimal behavioral context—only that it 'details' a category, which is consistent with annotations. It does not discuss error handling, response format, or side effects, but given the annotations cover safety, the bar is lower.

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—two short sentences. It front-loads the main purpose and then adds bulk support as a secondary note. No redundant or irrelevant information is present.

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-by-id tool, the description provides the endpoint, mentions bulk behavior, and includes the main parameter. However, it omits the account parameter, does not describe the output, and does not address edge cases. It is adequate but not fully comprehensive for all context.

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

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

The schema provides no descriptions for id, ids, or account. The description explains id (by id) and ids (bulk support), but leaves account unexplained. It does not clarify types, constraints, or relationships between parameters, so parameter semantics are only partially covered.

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: 'Detalha uma categoria por id' (Details a category by id) and specifies the HTTP method and endpoint (GET /categories/{id}). This distinguishes it from sibling tools like mercadolivre_list_categories, which likely fetch multiple categories.

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 mentions bulk support ('accepts ids for batched execution'), hinting at usage for multiple IDs, but it does not explicitly state when to use this tool over alternatives, nor does it give prerequisites or exclusions. The 'when-to-use' is only implicit from the tool name and purpose.

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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral detail beyond that, including the HTTP GET endpoint, the 20-item cap, and the optional response-field filter. It does not describe error cases or response shape, but it is reasonably transparent for a read-only lookup tool.

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

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

The description is two concise sentences, front-loaded with the core purpose and followed by the key parameter guidance. Every clause adds value without 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 read-only detail-by-ID tool, the description covers the endpoint, required parameter, limit, and optional field filter. It omits the `account` parameter and does not describe return structure, but the output schema is absent and the annotations cover the safety profile, so the description is adequate with minor 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 0%, so the description must compensate. It explains `ids` (list, max 20) and `attributes` (comma-separated fields), but it does not explain the optional `account` parameter, leaving one property undocumented and potentially confusing.

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 what the tool does: it details one or more listings/ads by ID via GET /items?ids=. It explicitly uses 'por id' and names the resource, distinguishing it from sibling tools like mercadolivre_search_items or mercadolivre_list_items.

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 clear usage context: invoke when you have anúncio IDs, provide `ids` as a list with a max of 20, and optionally use `attributes` to filter fields. It does not explicitly name alternatives or say when not to use it, but the ID-based scope makes the use case evident.

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 already cover read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond that by specifying the GET endpoint, the returned data areas, and the bulk execution behavior. It stops short of mentioning auth requirements or rate limits, but this is acceptable given the strong annotation coverage.

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

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

The description is two concise sentences with the main purpose and endpoint front-loaded, followed by the batch capability. There is no redundant wording or filler; every phrase earns its place.

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

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

For a simple read-only getter with no output schema, the description covers the core needs: endpoint, returned components, and batch support. The main gaps are the undefined 'account' parameter and lack of explicit sibling differentiation, but overall it is sufficiently complete for the tool's complexity.

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

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

With 0% schema description coverage, the description carries the parameter documentation burden. It explains 'id' ('por id') and 'ids' (bulk support), but it does not explain the optional 'account' parameter, which is left ambiguous. This partial compensation is helpful but incomplete.

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 details an order by ID, includes the exact endpoint (GET /orders/{id}), and enumerates what is returned (itens, comprador, pagamento, envio). This distinguishes it from sibling tools like mercadolivre_list_orders (listing) and mercadolivre_get_shipment (shipment-specific).

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 practical guidance for batch execution ('Bulk support: accepts ids for batched execution'), which helps with the ids parameter. However, it does not explicitly state when to prefer this tool over siblings or when not to use it, leaving usage context implied rather than 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?

Annotations already establish readOnly/idempotent/non-destructive behavior; the description adds the HTTP GET method and the important bulk execution trait. It does not describe errors or response shape, but this is acceptable for a simple read tool with these 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?

Two short sentences, front-loaded with the main purpose and followed by a useful bulk note. There is no filler or repetition of 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 simple read-only get-by-id tool with strong annotations, the endpoint and batch behavior are sufficient context. It is slightly incomplete in not addressing the account parameter or return values, but complexity is low.

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

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

With 0% schema description coverage, the description helps by tying 'id' to the path parameter and explaining 'ids' for batched execution. However, 'account' is left completely unexplained, so it only partially compensates for the schema's lack of parameter documentation.

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

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

Description uses a specific verb ('Detalha') targeting a question resource by id and gives the exact endpoint GET /questions/{id}. This clearly distinguishes it from siblings like mercadolivre_list_questions and other get_* 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 bulk support note gives practical guidance for passing multiple ids, and 'por id' implies use when you have a question identifier. However, it never explicitly contrasts with list_questions or states when the batch variant should be preferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by naming the specific data returned (status, tracking, address, cost) and disclosing bulk support, which goes beyond the annotations. It doesn't contradict any annotations, and the additional details are helpful without being excessive.

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 first sentence immediately states the tool's action, endpoint, and key return fields. The second sentence adds bulk support concisely. No filler or repetition; every sentence earns its place.

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

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

For a simple GET operation, the description covers the essential context: what it does, how to get the id, what it returns, and bulk execution. The lack of output schema means the description must convey return info, which it does. The only gap is the unexplained 'account' parameter, but for a straightforward tool, this is minor.

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

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

With 0% schema description coverage, the description must compensate. It explains the 'id' parameter implicitly ('Detalha um envio por id') and mentions 'ids' for bulk support. However, the 'account' parameter is not explained at all, leaving its purpose unclear. The description provides some meaning beyond the schema but falls short of fully covering all three 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 clearly states it details a shipment by id (GET /shipments/{id}) and lists the returned fields (status, tracking, address, cost). It also differentiates from sibling tools by focusing specifically on shipment details, and even references how to obtain the shipment id from an order, making its purpose 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 explicitly instructs to use the shipping.id from mercadolivre_get_order, providing a clear when-to-use scenario. It also adds guidance on bulk execution with ids, distinguishing between single and batched usage. This is strong, actionable 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?

Annotations already mark the operation as read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond annotations: the user is public and bulk execution is supported via ids. It does not mention auth requirements, rate limits, or response format, but the annotations lower the burden.

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

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

Two short sentences: the first states the core purpose and endpoint, the second adds bulk behavior. No redundant words or 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-by-id tool, the description covers the main purpose and bulk mode, but it leaves the 'account' parameter undocumented and offers no usage alternatives. Given no output schema, a bit more detail about the response or parameter relationships would make it fully complete.

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

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

With 0% schema description coverage, the description must compensate. It explains 'id' (the user id) and 'ids' (bulk support), but the 'account' parameter is completely unexplained, and the relationship between id and ids is not clarified.

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 a specific verb and resource: 'Detalha um usuário público por id' and includes the exact endpoint GET /users/{id}. This clearly distinguishes it from sibling tools like mercadolivre_get_category or mercadolivre_get_order.

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

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

No explicit guidance on when to use this tool versus alternatives such as mercadolivre_me or mercadolivre_list_accounts. The phrase 'usuário público' implies scope, but there is no when-to-use or when-not-to-use 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?

The description aligns with the readOnly and idempotent annotations, but adds little beyond stating it's a GET request and supports bulk execution. Since annotations already cover safety, there is no contradiction, but the description does not enrich understanding of side effects or edge cases beyond the endpoint.

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

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

The description is two sentences long, directly conveys the core function and key parameters, and contains no superfluous text. It is well-structured and easy to parse.

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

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

For a simple read-only tool, the description provides sufficient context on purpose and primary parameters. It lacks details on return format or error handling, but given the absence of an output schema and the straightforward nature of the operation, it is reasonably complete.

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

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

The description explains `last` (quantity) and `unit` (day/week/month) but does not clarify `id`, `ids`, or `account`. With schema coverage at 0%, this covers only 40% of parameters, leaving key fields like `account` ambiguous, though `id` is self-explanatory.

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

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

The description clearly states it retrieves visit counts for an ad within a time window, with the specific endpoint GET /items/{id}/visits/time_window. This distinguishes it from sibling tools like get_item or list_items, which serve different data needs.

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

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

It mentions the required parameters `last` and `unit` and their allowed values, but does not explicitly state when to choose this tool over alternatives or provide context around when it's appropriate to use bulk `ids`. The guidance is implicit rather than 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds useful behavioral context by defining the scope ('connected to this install') and the returned fields, which is valuable beyond the 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 a single, front-loaded sentence with no filler. Every element adds value: the action, the resource scope, and the expected data fields.

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

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

For a simple read-only list tool, the description is mostly adequate given the strong annotations and the explicit field list. The main gap is the unexplained optional 'account' parameter, which prevents 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?

The schema exposes one optional string parameter 'account' with no description (0% schema coverage), and the description does not mention or explain this parameter. The description fails to clarify whether 'account' filters the list, selects a specific account, or serves another purpose.

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

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

The description uses a specific verb ('Lista') and resource ('contas Mercado Livre conectadas a este install') and includes the expected fields (id, label, seller_id). It clearly differentiates this from the market/sales/order tools in the sibling list.

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 when you need to see which Mercado Livre accounts are connected to the install. However, there is no explicit guidance on when to use this instead of related tools like connect, authenticate, or mercadolivre_me.

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 already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds useful behavioral context: the exact API endpoint and the default site code, which go beyond the annotations. It does not describe response format or pagination, but for a simple listing tool, this is acceptable given the annotation coverage.

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

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

The description is a single, brief sentence that contains only essential information: the action, the endpoint, and the default parameter value. There is zero filler, and it is front-loaded with the primary purpose first.

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

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

The description covers the core purpose and the main parameter default, but it omits any explanation for the `account` parameter and does not mention the return format or pagination. Given the tool's simplicity and the presence of read-only annotations, it is mostly complete but has a notable gap for the undocumented parameter.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the `site` parameter's default (MLB) and its role (site code), which adds meaning beyond the bare schema. However, the `account` parameter is not mentioned at all, leaving it completely unexplained. This partial compensation warrants a mid-range score.

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: 'Lista as categorias raiz de um site' (lists root categories of a site) and specifies the endpoint GET /sites/{site}/categories. It distinguishes from siblings like 'mercadolivre_get_category' which likely fetches a specific category, making the purpose specific and 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 provides clear context by mentioning the `site` parameter and its default value (MLB), indicating when to use it (to get root categories for a given site). It does not explicitly exclude alternatives or mention when-not to use, but the context is clear enough for an agent to distinguish from other listing tools like 'mercadolivre_list_items'.

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 already declare read-only, idempotent, non-destructive. The description adds behavioral detail: paginated response, returns ids + paging info, which goes beyond annotations. It also notes the endpoint, but no contradictions.

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

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

The description is a single, information-dense sentence plus a final pointer. It front-loads the core purpose, then adds pagination, filter, and return details without redundancy. No wasted 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 4-param tool with no output schema, the description covers the core functionality, pagination, filter, and return type, and directs to a sibling for details. Missing only the 'account' parameter and any error/edge-case behavior, which are minor for a list tool.

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

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

Schema coverage is 0%, so description must explain parameters. It explains limit/offset via pagination and status filter with allowed values, but 'account' is never mentioned, leaving a parameter semantically unexplained. Partial compensation for schema gaps.

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 lists IDs of the connected seller's ads, specifies the underlying endpoint, and distinguishes it from mercadolivre_get_items (which provides details). This directly addresses what the tool does and separates it from 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?

It provides a clear context: listing seller's item IDs, with pagination and status filtering. It explicitly directs to mercadolivre_get_items for details, offering an alternative. However, it doesn't contrast with search_items or other list tools, so guidance is not exhaustive.

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 already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds that the tool is paginated and lists filters, but does not detail pagination limits or default behavior. It provides minimal extra context beyond the annotations, which is acceptable given the annotations cover key traits.

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

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

The description is two sentences, front-loaded with the primary action and then filters. Every word contributes value, with no irrelevant details. It is concise and 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 list operation with six parameters and no output schema, the description covers the core function and some filters, but lacks details on limit/offset defaults, the account parameter, and response behavior. It is adequate for basic use but leaves gaps that an agent might need to infer.

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

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

Schema description coverage is 0%, so the description must compensate. It explains status, sort, and q, giving examples for sort values, but leaves limit, offset, and account unexplained. This partial coverage is helpful but incomplete, resulting in a moderate score.

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 it lists orders of the connected seller, specifies the endpoint, and distinguishes from sibling tools like mercadolivre_get_order by indicating a list action and seller scope. It is specific and 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?

While the purpose implies usage for listing orders, the description does not explicitly mention when to use this tool over alternatives such as mercadolivre_get_order for single orders or mercadolivre_list_items. There are no exclusions or alternative references, so guidance is implicit rather than 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so no safety contradiction exists. The description adds useful behavioral detail beyond those annotations by revealing the HTTP method, seller-oriented query parameter, pagination behavior, and supported filter values, including the status enum.

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 main purpose comes first, followed by endpoint context, pagination, and filters. There is no filler, repetition, or redundant restatement of the tool name.

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 read-only listing tool, the description covers endpoint, pagination, and core filters, and annotations cover the safety profile. Still, with no output schema and no descriptions for account/limit/offset, an AI agent may not know exactly which parameters map to seller selection and pagination, or what list items look like in the response.

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

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

The input schema has no parameter descriptions, so the description is the primary guide. It adds meaning for status (UNANSWERED, ANSWERED) and item (advertisement ID), and 'Paginado' indirectly hints at limit/offset. However, the account parameter is not explained at all, and limit/offset are not explicitly tied to their parameter names, leaving several parameters under-specified.

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

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

Description clearly uses a specific verb-resource pair: 'Lista perguntas recebidas pelo vendedor' and includes the exact endpoint. It also distinguishes itself from siblings like mercadolivre_get_question by indicating this is the listing/search-like variant.

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 conveys a clear context: use it to list seller questions, with optional filters, pagination, and a GET endpoint. However, it does not explicitly state when to prefer this tool over alternatives such as mercadolivre_get_question, nor does it mention exclusions or follow-up actions.

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 already indicate read-only, idempotent, non-destructive behavior. The description adds specific data fields returned (profile, reputation, etc.) and clarifies it pertains to the authenticated seller. However, it does not discuss potential rate limits, authorization requirements beyond 'connected', or nuances like account selection. With annotations covering safety, this is adequate but not extensive.

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

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

The description is a single concise sentence that front-loads the core action and data. It avoids fluff. However, it omits parameter clarification, which is a significant gap, but the conciseness itself is good.

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

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

Given there is no output schema and only 1 parameter with 0% description coverage, the description should describe what the tool returns and how the parameter works. It only lists data categories, not the parameter, nor any prerequisite like 'requires a connected account'. It is moderately complete for a simple GET, but lacks essential parameter guidance.

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

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

There is one optional parameter 'account', but the description does not explain its purpose or format. Schema coverage is 0%, so the description should compensate, but it completely omits parameter information. The agent cannot infer whether this is an account ID, name, or something else.

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 purpose: retrieving data of the connected seller account (GET /users/me), and lists specific data fields (profile, reputation, site, account type, seller status). It distinguishes itself from siblings like mercadolivre_get_user (which may fetch a different user) by specifying 'vendedor conectado'.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as authentication, nor does it compare with related tools like mercadolivre_get_user. The description is purely declarative without 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?

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the description's job is lighter. It adds useful behavioral context such as pagination, site default, and the search scope (by seller), which goes beyond the 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 a single concise sentence that packs endpoint, default behavior, pagination, and filter details without fluff. Every word contributes to the tool's understanding.

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 6 parameters and no output schema, so the description should clarify return shape and major parameter usage. It mentions 'details' but not what they contain, and it misses account and pagination specifics. Adequate for basic usage but incomplete 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?

With 0% schema coverage, the description must explain all parameters. It covers site, q, and category, and implies limit/offset via 'paginado', but omits 'account' (likely the seller ID) and does not explain limit/offset semantics. This leaves critical parameters undocumented.

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

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

The description clearly states it searches seller listings with details, providing the exact endpoint. It explicitly mentions pagination, site default, and optional filters, making the tool's purpose specific and distinguishable from sibling tools like list_items or get_items.

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 clear context: searching listings by seller with details, paginated, and filterable by text or category. It implies this is for when you need seller-specific search results, but does not explicitly exclude alternatives or state when not to use it compared to other listing 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?

The description doesn't contradict annotations. Annotations include idempotentHint=true (sending a report is idempotent) and readOnlyHint=false (it's a write operation). The description doesn't disclose additional behavioral details beyond what annotations imply, such as whether it requires authentication or how the report is processed. Since annotations cover some traits, a middle score is appropriate; it adds context about including the conversation array but doesn't explain 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 one sentence and fairly concise. It front-loads the purpose and adds the key instruction about including the conversation array. Every part earns its place, but it could be slightly more structured (e.g., separating purpose from usage note). A short, clear description is effective, so 4 is justified.

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 3 parameters with 0% schema coverage, no output schema, and moderate complexity. The description provides a clear purpose and a key usage hint (include conversation array) but doesn't define the parameters comprehensively or state what the tool does after reporting. Given the annotations and simplicity, the description is adequate but has gaps: it doesn't mention that 'context' is optional or how 'message' is used. Overall, it meets minimum viability but lacks 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 0%, meaning the schema does not explain parameters. The description mentions 'conversation array' but not the parameter name 'conversation', and it doesn't explain 'message' or 'context' beyond what the schema names imply. With zero coverage, the description must compensate, but it only partially does: it specifies that conversation is for reproduction but leaves message and context ambiguous. This is insufficient for a tool with 3 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 clearly states the tool's purpose: report a bug, a missing feature, or send feedback. The verb 'report' and explicit resources (bug, missing feature, feedback) make the purpose specific. It distinguishes itself from siblings, which are all MercadoLibre operations, by being a user-facing issue reporting 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 description gives a clear instruction on what to include (conversation array for reproduction), implying it should be used when the user wants to report an issue or feedback. However, it doesn't explicitly state when NOT to use it or compare with alternatives (e.g., for general questions). There are no sibling tools for reporting, so alternatives aren't relevant, but the description could be more explicit about the use case.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is clearly non-mutating. The description adds only the word 'current,' implying a live or dynamic version lookup, but it does not describe output structure, whether a single value is returned, or any potential formatting details.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes meaning, and it is fully aligned with the tool's simple nature.

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

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

For a zero-parameter, read-only, idempotent version lookup, the description is essentially complete. It does not describe the exact output format, which could be useful given there is no output schema, but that is a minor gap for this trivial tool 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?

The tool has zero parameters and an empty input schema, so parameter semantics are not a concern. With 0 params, the baseline is 4, and the description correctly focuses entirely on the tool's purpose rather than inventing parameter details.

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

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

The description uses a specific verb ('Show') and clearly names the resource ('current MCP platform and adapter versions'). This immediately distinguishes show_version from sibling tools that operate on Mercado Livre data, accounts, or marketplace operations.

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 the tool is used when a user or agent wants to check platform and adapter version numbers, but it gives no explicit guidance about when to use this tool versus alternatives. There are no context cues or exclusions, but the basic use case is reasonably inferable.

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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds value by detailing the content of the returned state (installed MCPs, connection status, accounts, catalog tool counts), which is beyond the annotations. No contradictions.

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

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

The description is a single, concise sentence that front-loads the action ('Returns') and provides a compact list of returned information. No wasted 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?

Given the tool is a read-only overview and has no output schema, the description sufficiently explains what the tool returns. It does not specify the exact format or structure of the response, but for a state-check tool, this is adequate. Sibling tools add context, and the description differentiates 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?

With zero parameters, schema coverage is 100% by definition. Per instructions, a baseline of 4 is appropriate since no parameter documentation is needed. The description does not need to address parameters, and it doesn't.

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

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

The description clearly states the tool's purpose: it returns the current toolkit state, specifying exact details like installed MCPs, connection status, accounts, and catalog tool counts. This distinguishes it from sibling tools that focus on individual data lookups.

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 used for an overview of the toolkit, but it does not provide explicit guidance on when to use it vs. alternatives like list_accounts or specific getters. There is no mention of exclusions or prerequisites, but the context is clear enough for an info tool.

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