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

The annotations already declare readOnlyHint=true and openWorldHint=true, indicating a safe, read-only operation. The description adds that it returns product and version, which aligns with these hints and confirms no side effects. However, it provides no further behavioral context beyond what the annotations imply, such as the exact return format or whether it requires an open model.

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 sentence in Portuguese that is succinct and to the point. It conveys the essential purpose with no unnecessary words, achieving maximum conciseness.

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

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

For a zero-parameter read-only tool with annotations covering safety, the description is fully sufficient. It tells the agent exactly what will be returned (product and version) and there are no missing inputs or outputs that would hinder correct invocation. Its simplicity does not warrant 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?

The tool has zero parameters, so the schema covers all parameters (100% coverage). Per the rubric, a baseline of 4 is appropriate for a parameterless tool. The description does not need to explain parameters since none exist, and it does not add any parameter-related detail.

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 the product and version of Solibri ('Retorna o produto e a versao do Solibri em execucao'), providing a specific verb and resource. It is distinct from all sibling tools, which focus on operations like updating, checking, or exporting, 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?

There is no explicit guidance on when to use this tool versus alternatives. While no sibling directly competes with it, the description does not mention any context or exclusions. Usage is implied by the tool's purpose, but the description lacks any additional direction.

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 this is a write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds that it highlights components by IFC GUID and modifies an existing presentation, which is extra behavioral detail. However, it does not disclose side effects, error handling, or return values, which are important for a mutation tool. Since annotations cover the safety profile, the description provides minimal additional behavioral context, scoring a 3.

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, succinct sentence that is front-loaded with the primary action and includes a specific detail (highlighting components). There is no redundant or irrelevant content, making it appropriately concise.

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

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

With full parameter documentation in the schema and annotations covering read/write and destructive safety, the description provides the essential purpose and the prerequisite of an existing presentation. However, it does not explain return values or error behavior, which is typical for a mutation tool. Given the absence of an output schema, the description is adequate but not fully complete, meriting a 3.

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 provides descriptions for all 11 parameters, achieving 100% coverage. The description's mention of 'componentes por GUID IFC' relates to the 'components' parameter but adds no extra semantic detail beyond what the schema already contains. Per the rubric, the baseline 3 applies because the schema does the heavy lifting.

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 adds a slide (issue) to an existing presentation and highlights components by IFC GUID. It specifies the action, resource, and distinct behavior, making it easy to differentiate from sibling tools like solibri_create_presentation.

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 states the tool operates on an existing presentation ('a uma apresentacao existente'), which is a clear prerequisite and usage context. It does not mention alternatives or exclusions, but the context is sufficiently clear for a 4.

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 destructiveHint=true and readOnlyHint=false, so the description does not need to restate destructive behavior. The description adds the context that this ends a running process, which aligns with the annotation. It does not go into detail about consequences (e.g., irreversibility, impact on other jobs), but given the annotation coverage, the additional context is sufficient. No contradiction exists between description and 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 in Portuguese that efficiently conveys the tool's purpose without any redundant or extraneous words. It is appropriately front-loaded with the core action and resource, making it easy for an agent to parse quickly.

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

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

Given the tool's simplicity (one parameter, no output schema, clear annotations), the description is largely complete. It specifies the action, the resource (Autorun job), and the condition (still running). It does not mention potential error scenarios or what happens post-cancel, but these are not critical for a straightforward cancel operation. The description covers the essential information an agent needs to invoke it correctly.

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

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

The input schema has 100% coverage, with jobId described as 'Id do job a cancelar.' The description does not add any additional information about the parameter beyond what the schema already provides. Since schema coverage is high, a baseline of 3 is appropriate; the description adds no extra semantic 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 clearly states the verb 'Encerra' (ends) and the resource: the Solibri process of an Autorun job that is still running. It distinguishes this from sibling tools like solibri_autorun_start (starting) and solibri_autorun_status (checking status) by specifying 'ainda em execucao' (still running). The purpose is unambiguous and not a tautology.

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

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

The phrase 'ainda em execucao' (still running) provides a clear condition for when to use this tool – only for Autorun jobs that are currently running. This implies it should not be used for completed or not-yet-started jobs. However, it does not explicitly name alternative tools (e.g., solibri_autorun_status for checking status or solibri_autorun_start for starting), so it lacks explicit exclusions 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?

Given annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false), the description adds the key constraint that Solibri must be closed before invocation, which is not inferable from annotations. It also discloses that it exports files and returns a jobId, aligning with the open-world side effects. No contradiction with 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, tightly worded paragraph that front-loads the primary action and essential outputs, then immediately gives the follow-up instruction and the key prerequisite. No wasted words; every sentence earns its place.

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

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

For a tool with 8 parameters and no output schema, the description covers the overall workflow, return value (jobId), and how to track progress. It lacks explicit error handling or timeout notes, but the schema fully documents parameter details, and the async nature is implied by the status tool reference. Adequate for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions the main output types (BCF, report, project) which maps to several parameters, but it doesn't add details beyond what the schema already provides for individual parameters like bcfVersion, autocomment, or createPresentation. It offers minimal additional semantic 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 clearly states the tool's purpose: it opens Solibri in Autorun mode to load IFCs, apply rulesets, run checking, and export BCF, report, and project. It distinguishes itself from sibling tools by specifying it returns a jobId to follow with solibri_autorun_status, making its role as the batch-start entry point explicit.

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 critical usage precondition (Solibri must be closed) and instructs the agent to monitor progress with solibri_autorun_status, indicating this is the first step of a batch workflow. While it doesn't explicitly list alternatives, the context of being the autorun starter makes its usage clear.

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 readOnlyHint=true and openWorldHint=true, so the read-only nature is covered. The description adds the key behavioral nuance: the 'no jobId' behavior of listing all jobs in the session, which is not inferable from the schema alone. It does not disclose response format or error conditions, but given the safety profile is already in annotations, this is acceptable.

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

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

The description is two short, information-dense sentences. The primary action is front-loaded, and the conditional behavior is stated in a parallel structure with no wasted words. It is concise 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 with one optional parameter and no output schema, the description covers the essential invocation logic (with and without jobId). It does not describe the response structure, but given the tool's simplicity and the openWorldHint, this is likely acceptable. The agent has enough information to decide when to call it and what to expect.

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 jobId description explains its origin (returned by solibri_autorun_start). The description adds meaning beyond the schema by specifying the conditional behavior when jobId is absent, which is not explicitly in the schema. Since the description bridges the gap between 'optional parameter' and its runtime implications, it earns a 4.

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 verb 'query' (Consulta) and the resource 'Autorun job status', and explicitly covers the no-jobId case (listing all jobs). This directly distinguishes it from the sibling tools solibri_autorun_start and solibri_autorun_cancel, which are mutations, so an agent can easily pick the right 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 clear conditional guidance: when jobId is provided, query that job; when absent, list all jobs. It does not explicitly contrast with alternative status tools like solibri_status, but the 'sem jobId' clause effectively frames when to use this tool versus relying on other status mechanisms. The guidance is functional but 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 declare destructiveHint=true and openWorldHint=true, and the description adds a specific behavioral detail: 'Com force=true descarta alteracoes nao salvas' (with force=true discards unsaved changes). It also advises confirming with the user before using. This goes beyond the annotations by explaining the consequence of the force parameter and the safety step, which is valuable.

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, direct sentence that leads with the primary action and immediately follows with the safety caveat. Every word earns its place; there is no fluff or 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 close operation with one boolean parameter, the description covers the core behavior and the force condition. However, it does not clarify what happens when force=false and there are unsaved changes (does it still close? prompt?), nor does it state the result of calling the tool when no project is open. These gaps leave some ambiguity for an agent deciding how to handle 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?

The schema already documents the only parameter 'force' with 'Descartar alteracoes nao salvas' (discard unsaved changes). The description repeats this same effect when mentioning force=true, so it adds no new meaning beyond the schema. With 100% schema coverage, the baseline is 3 and the description does not significantly elevate 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 states a specific verb and resource: 'Fecha o projeto aberto no Solibri' (closes the open project in Solibri). This clearly distinguishes it from sibling tools like solibri_save_project or solibri_open_model, and it is unambiguous about the operation performed.

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 a caution about force=true but does not give any guidance on when to use the tool versus alternatives, nor does it mention prerequisites (e.g., whether a project must be open). There is no explicit when-to-use or when-not-to-use context, leaving the agent to infer when this tool is appropriate.

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

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

Annotations already indicate mutating behavior (readOnlyHint=false). The description adds that it returns an id, but does not disclose any side effects, prerequisites (e.g., requiring an open model), or persistence behavior. For a mutating tool, this is a significant gap beyond what annotations provide.

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 sentence that front-loads the action ('Cria uma apresentacao'), then states the return value and its consumer. There is no extraneous information; every clause 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 tool with two parameters and no output schema, the description adequately covers the return value (id) and workflow linkage. However, it omits potential prerequisites like an open model and error conditions, which would be useful for a mutating tool, though not critical for this simple creation task.

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 both parameters (name and prefix), and they are adequately described in the schema. The description adds no parameter-specific details, so it meets the baseline of 3 without compensating for any 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 uses a clear verb ('cria' - creates) and resource ('apresentacao de resultados' - results presentation), and explicitly states the return value (id) and its linkage to solibri_add_slide. This differentiates it from sibling tools like solibri_export_bcf or solibri_read_bcf by framing it as the creation step for a presentation workflow.

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 a usage workflow by stating the returned id is 'usado por solibri_add_slide', which suggests this tool is a prerequisite for adding slides. However, it does not explicitly mention when to use this tool vs alternatives or when not to use it, lacking clear 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?

Annotations already indicate this is not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds the specific side effect of creating a BCF file in the workspace, which is useful context. However, it does not disclose potential failure modes (e.g., no model open, file overwriting), though these are partially implied by the schema. Given the annotations cover the safety profile, this is adequate but not rich.

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 and output. There is no filler or redundant detail; every word contributes to the meaning.

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

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

For a simple export tool with well-documented parameters, the description is fairly complete. It mentions the prerequisite of an open Solibri model ('aberto') and specifies the output path via the output parameter. However, it lacks information about return values or error conditions, which would be helpful since no output schema is provided. Overall, it covers the essential calling 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%, with all three parameters (scope, output, version) having meaningful descriptions. The tool description adds no extra parameter information beyond the schema. Per the rubric, a baseline of 3 applies when schema coverage is high.

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 ('Exporta'), the resource ('as issues do Solibri aberto'), and the output ('arquivo BCF dentro do workspace'). This clearly distinguishes it from siblings like solibri_read_bcf and solibri_update_model, leaving no ambiguity about what the tool does.

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

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

The description implies usage when an agent needs to export issues to a BCF file, but it provides no explicit guidance on when to use this tool versus alternatives (e.g., solibri_read_bcf) or any conditions/exclusions. The sibling list exists but is not referenced in the description, so the agent must infer 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 declare readOnlyHint=true and openWorldHint=true, so the description's job is to add detail beyond that. It does by listing all returned camera attributes. It does not mention potential errors or edge cases, but for a simple getter with no side effects, the field list is sufficient transparency.

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. It states the purpose and lists the returned fields without any filler. Every word earns its place, and it is highly efficient.

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

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

Since there is no output schema, the description is the sole source of return information. It comprehensively lists every field the camera state includes (projection, position, direction, up, FOV, scale), which is exactly what an agent needs to interpret the result. Nothing essential is missing for this getter tool.

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

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

There are 0 parameters, and the schema is empty with 100% coverage. The baseline for 0 params is 4. The description adds no parameter semantics because none exist, and it correctly omits any parameter references.

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 ('Retorna' = returns) and resource ('estado da camera 3D'), and enumerates the exact fields (projection, position, direction, up, FOV, scale). This clearly differentiates it from the sibling solibri_set_camera, which is the setter counterpart.

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

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

The purpose is unambiguous: it reads the camera state. While it doesn't explicitly state 'use this when you need the camera state' or exclude other tools, the pairing with solibri_set_camera provides clear context. The description itself gives no exclusion guidance, but the scope is so specific that the intended usage is obvious.

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?

As anotações já declaram readOnlyHint=true e openWorldHint=true, cobrindo a natureza de leitura e a possibilidade de mudanças externas. A descrição acrescenta o comportamento de paginação ('Use limit e offset para paginar modelos grandes'), que é informação adicional. Não contradiz as anotações e fornece contexto útil sobre como a ferramenta lida com grandes conjuntos de dados.

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

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

A descrição tem duas frases, sem excesso de palavras. A primeira frase estabelece a finalidade principal (retornar GUIDs IFC) e a segunda dá uma dica concisa sobre paginação. Não há ruído ou redundância.

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?

Para uma ferramenta de listagem com três parâmetros (um obrigatório), a descrição é suficiente: informa o que retorna e como paginar. Não há schema de saída, então não é necessário explicar o formato de retorno. A anotação openWorldHint já cobre a possibilidade de mudanças externas. Poderia mencionar se a lista é ordenada ou se há limites padrão, mas isso não é essencial para uso correto.

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?

A cobertura do esquema é 100%: todos os parâmetros têm descrições no próprio schema, incluindo o cruzamento 'modelUuid obtido em solibri_list_models'. A descrição apenas repete a ideia de paginação ('Use limit e offset para paginar modelos grandes'), que já está implícita nas descrições do schema. Não adiciona significado considerável além do que o schema já fornece, portanto a pontuação base de 3 é apropriada.

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?

A descrição declara claramente o verbo e o recurso: 'Retorna os GUIDs IFC dos componentes de um modelo'. Isso distingue a ferramenta de irmãos como solibri_list_models (que lista modelos) e solibri_get_model_metadata (que obtém metadados). O propósito é específico e inequívoco.

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?

A descrição não fornece orientação sobre quando usar esta ferramenta em vez de alternativas. A única instrução sobre uso é 'Use limit e offset para paginar modelos grandes', que é orientação de parâmetros, não de seleção de ferramenta. Não há menção a contextos como 'quando precisar dos GUIDs dos componentes' ou 'use esta em vez de solibri_get_model_metadata'.

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 openWorldHint=true, indicating a safe read operation without destructive side effects. The description confirms this by saying 'Le um metadado'. It adds no extra behavioral context, such as behavior on missing keys, return structure, or whether the result could be null. With annotations covering the safety profile, a 3 is appropriate—there is no contradiction, but little added transparency beyond the structured data.

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

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

The description is a single, focused sentence that front-loads the core action (read metadata by key) and includes examples. There is no wasted text; it is appropriately concise and directly useful.

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 operation with two parameters, full annotation coverage (read-only, open world), and unambiguous schema, the description provides enough context: verb, resource, and parameter examples. It does not explain the return format or error handling, but given the simplicity and annotations, it is sufficiently complete for an agent to invoke correctly. The lack of output schema means the description could have included return expectations, but the low complexity keeps this a minor gap.

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

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

Schema description coverage is 100%; both modelUuid and key are described in the schema. The description adds value by providing concrete examples of valid keys ('timestamp ou version'), which helps clarify the semantics of the key parameter beyond the generic schema description. This enriches the parameter understanding, so a 4 is warranted.

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

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

States a specific verb 'Le um metadado' (reads a metadata) with a resource 'model' and a key parameter, plus examples ('timestamp ou version'). It is clear what the tool does, though it does not explicitly differentiate from sibling read tools like solibri_get_model_components or solibri_get_selection_basket, which read other model aspects.

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

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

The description implies usage: use this when you need a metadata value for a specific key on a model. However, it offers no explicit when-to-use or when-not-to-use guidance, nor references any alternatives among the 24 sibling tools. It is adequate but relies on the agent to infer 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 readOnlyHint=true and openWorldHint=true, so the description adds no additional behavioral context. It does not disclose what happens when the basket is empty, whether the returned list is sorted, or any other execution characteristics. Since it carries the full burden of behavioral disclosure beyond annotations, and it adds essentially nothing, a score of 2 is appropriate.

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 primary action and resource. It contains no fluff and conveys the essential purpose efficiently. This is an ideal example of appropriate brevity for a simple getter 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?

Given the tool's simplicity (no parameters, read-only, no output schema), the description is mostly adequate—it states what is returned. However, it leaves minor gaps such as whether an empty basket returns an empty list, and it doesn't specify the format of GUIDs (e.g., as strings). With no output schema to fall back on, a bit more clarity would be helpful, but it is not severely incomplete.

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

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

The input schema has zero parameters and schema description coverage is 100% (trivially, as there are no properties). According to the rubric, 0 params earns a baseline of 4. The description adds no parameter information because none exist, so this baseline 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 that the tool returns the IFC GUIDs of components in the current Selection Basket, using a specific verb ('returns') and a resource ('components in the Selection Basket'). It is unambiguous and not a tautology. However, it does not explicitly distinguish itself from sibling tools like solibri_set_selection_basket or solibri_get_model_components, though the resource is unique enough that an agent could infer the difference.

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 merely states what it does without explaining the context (e.g., when you need the current selection vs. setting it, or vs. querying all model components). There is no mention of exclusions or alternatives, so an agent receives almost no direction on choosing this tool.

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 and openWorldHint, covering safety and non-mutating behavior. The description adds that it returns name, UUID, and metadata, which is useful but minimal. It does not disclose ordering, pagination, or potential failures, though for a read-only listing that is acceptable given 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?

Description is a single concise sentence, front-loaded with the action verb 'Lista'. Every word adds value, and it fully conveys the tool's purpose without 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 low complexity (no parameters, no output schema), the description provides enough information for an agent to understand the operation and its expected result. It lacks details like whether the list is sorted or what 'metadata' includes, but these are minor for a simple listing tool.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description does not need to explain any parameters, and the schema is empty with 100% coverage. No additional semantics required.

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

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

The description clearly states the tool lists open models ('modelos abertos') with name, internal Solibri UUID, and metadata. It is a specific verb+resource and distinguishes itself from siblings like solibri_get_model_metadata (which deals with a single model's metadata) and solibri_list_workspace.

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. It does not mention scenarios such as needing to enumerate models before opening one, nor does it contrast with solibri_get_model_metadata or solibri_get_model_components. Usage context is entirely 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds context about the authorized folder and file types, which is useful but not deeply behavioral. No contradictions exist between description and 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?

A single, efficient sentence with zero fluff. The purpose is front-loaded and the file types are listed concisely. No 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 list operation with annotations covering safety and a fully documented single parameter, the description is adequate. It does not specify return format or pagination, but no output schema exists and the tool's simplicity makes this acceptable.

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% for the single 'subfolder' parameter, so the schema already documents its meaning. The description does not add parameter-specific detail beyond what is in the schema, so 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 states a specific verb ('Lista' - lists) and resource ('arquivos disponiveis na pasta autorizada do MCP' - available files in the authorized MCP folder), and enumerates file types (models, rulesets, reports, BCFs). This clearly distinguishes it from the sibling solibri_list_models, which presumably lists only models.

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 explains what the tool does but does not provide explicit guidance on when to use it versus alternatives like solibri_list_models. The presence of a sibling with a more specific scope implies usage could be generalized, but no when/when-not 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is established. The description confirms a non-mutating download operation ('Baixa... em execucao') and adds the context that it reflects the currently running API. It does not disclose output format or size, but for a read-only metadata tool, annotations plus description cover the key behavioral 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?

Two compact sentences in Portuguese, front-loaded with the core purpose and immediately followed by the use-case trigger. Zero filler, 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 parameter-free, read-only tool with no output schema, the description is complete. The agent knows what it does, when to use it, and that it is safe (via annotations). Nothing essential 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?

There are 0 parameters and schema description coverage is 100%, so there is nothing for the description to document. The description correctly omits param detail. Baseline 4 is warranted because with no parameters, the description needs no compensating semantic information.

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 (downloads/downloads) and resource (the OpenAPI spec of the running Solibri REST API). It is immediately clear what the tool returns and it is easily distinguishable from the sibling tools, none of which retrieve API specifications.

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 states when to use this tool: to discover exact parameters of less-used endpoints. This gives the agent a clear trigger condition. It does not reference alternatives explicitly, but with 24 siblings and 0 overlapping purpose, the intended context is sufficiently directive.

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 the mutation (readOnlyHint=false) and open world interaction (openWorldHint=true). The description adds context that the file comes from the workspace and goes to the current project, but it does not disclose any further side effects (e.g., handling of existing models, file validation, or error scenarios). This is consistent with annotations but adds limited extra value.

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 and omits any unnecessary words. It is appropriately sized for the simplicity of the 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?

Given that the annotations and schema cover mutation, open world, and both parameters, the description is mostly adequate. However, it does not explicitly mention potential conflicts (e.g., if a model with the same name already exists) or prerequisite conditions beyond the implicit 'Solibri aberto'. It could be more explicit about expected behavior when the file cannot be found or when Solibri is not open.

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%: both 'file' and 'name' have descriptions in the schema. The tool description does not add any additional information about parameters, so the baseline of 3 applies. It neither enriches nor contradicts 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 the action clearly: 'Envia um arquivo IFC do workspace para o Solibri aberto e o adiciona ao projeto atual' (sends an IFC file from workspace to open Solibri and adds it to the current project). It specifies the resource (IFC file) and the action (add to project), but it does not differentiate from sibling tools like solibri_update_model or solibri_run_checking, so it loses a point for not explicitly distinguishing itself.

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

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

There is no guidance on when to use this tool versus alternatives. The description only states what it does without mentioning when it is appropriate (e.g., for adding a new model) or when not to use it. No exclusions, prerequisites, or alternative tool references 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that it checks API responsiveness, which is useful context, but it does not disclose the return format (e.g., boolean, status code) or any potential side effects beyond that. Given the annotations, the description provides adequate but minimal additional behavioral transparency.

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 no wasted words. It is front-loaded with the purpose and immediately follows with usage guidance. Every sentence earns its place, and there is no redundancy or padding.

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 health-check tool with no parameters, the description covers purpose and usage. However, since there is no output schema, the description should ideally mention what the tool returns (e.g., a boolean or status indicator). That information is missing, leaving a minor gap for an agent that needs to interpret the result. Overall, the description is adequate but not 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?

The tool has zero parameters, so the schema is trivially complete (coverage 100%). Per the baseline rule for zero parameters, the score is 4. The description does not need to explain any parameters since there are none, and it does not introduce any conflicting parameter information.

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 'Verifica' (verifies) and a specific resource 'a REST API local do Solibri esta respondendo' (the local Solibri REST API is responding). It clearly differentiates this health-check tool from the other Solibri tools by focusing on connectivity, which is distinct from status, model, or export 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 explicitly tells the agent when to use this tool: 'Use antes das demais ferramentas quando nao souber se o Solibri esta aberto' (Use before the other tools when you don't know if Solibri is open). This provides a clear condition and ordering, leaving no ambiguity about when it should be invoked.

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, so the description correctly aligns with a read-only operation. It adds context about the return format (structured issues with counts) but does not disclose potential edge cases like file-not-found behavior or performance implications. The added output detail is useful, but with annotations covering safety, a 3 is appropriate.

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

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

A single, front-loaded sentence states the purpose and key output. There is zero wasted wording, and the essential information is immediately clear.

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

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

For a straightforward read operation with well-documented parameters and annotations, the description adequately conveys what the tool does and returns. It lacks detailed output schema (no output schema exists) but the high-level summary of issues with counts is sufficient for an agent to understand the tool's deliverable.

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% – all four parameters have descriptions already. The tool description does not add further parameter-level detail beyond what the schema provides. Baseline of 3 applies because the schema does the heavy lifting.

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 ('Le' – read), a specific resource (BCF file from workspace), and the expected output (structured issues with counts by status, priority, type, and responsible). It clearly distinguishes from siblings like solibri_export_bcf, which is for exporting rather than reading.

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 for reading existing BCF files, but it does not explicitly mention when to use it over alternatives or any exclusions. It is not misleading, but it lacks explicit guidance on sibling tool selection (e.g., solibri_export_bcf vs this).

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 readOnlyHint=false and destructiveHint=false, so no contradiction. The description adds minimal behavioral context: it mentions 'executa' (executes) and 'retorna os resultados' (returns results), but does not disclose any side effects (e.g., whether it modifies project state, requires a model to be open, or has rate limits). Given the annotations cover the basic safety profile, the description offers only modest extra value.

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

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

Two sentences with zero filler. The purpose and the differentiating guidance are front-loaded, and every sentence earns its place. Ideal length for the tool's simplicity.

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 conditions usage on pre-loaded rulesets and an open Solibri, which covers prerequisites. However, with no output schema, 'retorna os resultados' is vague—it doesn't specify the format (list, report, status), error handling, or what happens if no rulesets are loaded. For a tool that returns substantial data, this is a notable gap.

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

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

The schema has 100% coverage for the single optional boolean parameter 'checkSelected' with its own Portuguese description. The tool description does not add any additional meaning about the parameter, but the schema already fully documents it, so the baseline of 3 applies.

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

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

The description states a specific action ('Executa o checking') on a clearly identified resource ('rulesets ja carregados no Solibri aberto') and explicitly says it returns results. It also distinguishes itself from the alternative tool (solibri_autorun_start) by the loading condition, making it easy for an agent to pick the right one.

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 an explicit condition for use ('com os rulesets ja carregados') and a direct alternative for a different scenario ('Para rodar um ruleset a partir de arquivos, use solibri_autorun_start'). This is a clear when-to-use vs when-not-to-use guidance that fully disambiguates from the 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?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds specific behavior beyond that: it overwrites the destination file if it exists. This is valuable context that the agent would not know from annotations alone, and it does not contradict them.

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 only two sentences with no filler. The primary action is front-loaded in the first sentence, and the critical overwrite warning is concisely presented in the second. Every word earns its place.

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

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

For a simple save operation with one required parameter, the description fully covers the action, the destination, and the destructive overwrite behavior. No output schema is present, but none is needed for this tool. The description is sufficient for an agent to call it correctly.

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

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

The schema provides 100% coverage for the 'destination' parameter with a clear description ('Caminho .smc de destino relativo ao workspace'). The tool description adds no further meaning to the parameter beyond what is already in the schema; 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 clearly states the action: saves the current project as a .smc file in the workspace. The specific verb 'salva' and resource 'projeto atual' distinguish it from sibling tools like solibri_open_model or solibri_close_project. No 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 warns that the destination is overwritten if it exists, instructing the agent to confirm with the user before use. This is a clear usage condition, though it does not explicitly mention alternatives (none exist). It provides actionable guidance for when to use the tool.

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 mutability (readOnlyHint=false, openWorldHint=true) and non-destructive (destructiveHint=false). The description adds a caution to call get_camera first and only change necessary fields, which hints at potential side effects of omitting parameters, but does not detail what happens to optional params or coordinate conventions. No contradiction with annotations, but minimal extra behavioral detail.

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, purpose first, then usage advice. 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?

The tool has six parameters, three nested objects, and no output schema. The description covers the basic workflow (get then set) but does not explain behavior for omitted optional parameters (fieldOfView, viewToWorldScale), nor coordinate system conventions or constraints between direction/upDirection. Given the getter exists for reference, it is adequate but not 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?

All six parameters have descriptions in the schema (100% coverage), so the schema does the heavy lifting. The description only advises to change what is necessary, which is generic and not parameter-specific. It adds no additional semantic detail 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 verb ('Define') and resource ('camera 3D do Solibri'), and explicitly names the complementary getter tool (solibri_get_camera), distinguishing it from the sibling getter. The purpose is unambiguous.

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

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

The description instructs the agent to call solibri_get_camera first and only change what is necessary, providing a clear usage protocol for setting the camera without unintentionally altering unknown state. It does not list other alternatives, but for a setter the getter is the main counterpart, so this is adequate.

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 adds a behavioral detail not captured by the annotations: the previous selection is lost. This is useful context because destructiveHint=false might suggest no destructive effect, but the description clarifies that the old selection is replaced. It does not cover other behaviors like permissions or rate limits, but given the annotations already declare readOnlyHint=false, the added note is valuable.

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 concise sentences with no filler. The primary purpose is front-loaded, and the key behavioral effect (previous selection lost) is stated immediately. Every word earns its place.

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

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

For a simple setter with one well-defined parameter and no output schema, the description plus schema cover the operation completely. The agent knows what it does, what input it expects, and the consequence of overwriting. Nothing essential 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?

The schema fully describes the 'guids' parameter (22-character IFC GUIDs, min 1, max 5000). The description only reiterates 'GUIDs IFC informados' without adding new semantic meaning. With 100% schema coverage, the baseline score of 3 applies; the description does not compensate further.

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 verb (substitui/replaces), the resource (Selection Basket), and the input (IFC GUIDs). It also distinguishes from the sibling solibri_get_selection_basket by naming the opposite operation. The effect (previous selection lost) is included, making the 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 implies when to use the tool (to set the selection basket) but does not explicitly mention alternatives, conditions, or exclusions. While the sibling get_selection_basket provides an obvious contrast, the description itself offers no usage guidance beyond the basic operation.

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=false and openWorldHint=true, so the description doesn't need to restate those. It adds that it selects a component and opens an info window, which gives some behavioral context beyond annotations. However, it doesn't mention side effects like changing selection state or error behavior. With annotations covering the basic traits, this is adequate but not rich.

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 words. It immediately states the action and target. Every word earns its place.

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

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

For a simple one-parameter tool with no output schema, the description adequately covers what the tool does. It doesn't elaborate on prerequisites (like having a model open) or error handling, but these are not essential for a straightforward UI action. The description is complete enough for an agent to understand what to expect.

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% – the schema already documents that 'guid' is an IFC GUID with 22 characters. The description only reiterates that the component is selected by GUID, adding no new semantic detail. Baseline for full schema coverage is 3, and this does not exceed 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 states a specific verb ('seleciona' and 'abre') and a specific resource ('componente pelo GUID IFC' and 'janela de informacoes'). It clearly distinguishes itself from siblings like get_model_components (which retrieves data) or set_selection_basket (which changes selection) by focusing on opening an info window.

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. The description merely describes the action without mentioning conditions, prerequisites (e.g., model must be loaded), or when another tool would be more appropriate. This is a bare description 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?

The description adds meaningful behavioral detail beyond the annotations (readOnlyHint=true, openWorldHint=true) by specifying exactly what state information is exposed: busy flag, open file, and ongoing operation status. It does not contradict the read-only annotation and provides useful context about the tool's observable behavior, though it does not cover potential error states or availability guarantees.

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 that packs the essential information (what it returns and the three specific aspects) with no wasted words. It is concise and immediately usable.

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 status tool with no parameters and no output schema, the description covers the key dimensions an agent needs: it tells what state is inspected (busy, file, operation) and implies it is a safe, non-mutating query. It does not describe return format or error behavior, but given the tool's simplicity and the annotations covering read-only/open-world semantics, it is sufficiently 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?

This tool takes no parameters, so the baseline of 4 applies. The description does not need to explain parameter semantics, and the schema is trivially complete. The description correctly focuses on what the tool returns rather than inputs.

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 verb 'Retorna' and the resource 'estado do Solibri', and enumerates the specific items returned (busy status, open file, ongoing operation status). This distinguishes it from siblings like solibri_ping (connectivity) and solibri_autorun_status (autorun-specific state), giving an agent a precise idea of what this tool does.

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

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

The description implies usage context by listing the kind of information returned (busy, open file, operation status), but it does not explicitly state when to use this tool versus alternatives like solibri_autorun_status or solibri_ping. No exclusions or alternative routing is provided, so an agent must infer when this is the right choice.

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 readOnlyHint=false (mutation) and openWorldHint=true (side effects). The description adds the partial-update behavior, which is useful. However, it does not clarify what happens to the previous version of the model, whether the operation is reversible, or any permission requirements. Given the annotations cover the safety profile, the description adds modest contextual value but not rich behavioral detail.

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 concise sentences, zero waste. The primary action is front-loaded, and the second sentence adds the key parameter guidance. Every word earns its place; the description is exceptionally 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 mutation tool with no output schema, the description leaves gaps: it does not state prerequisites (e.g., the model must exist and be open), what the return value is, or potential side effects beyond the model being replaced. The sibling solibri_list_models could be inferred for getting modelUuid, but this is not explicit. The description is adequate but not fully complete for an agent to call it confidently 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 coverage is 100%, so the baseline is 3. The description goes beyond the schema by clarifying that the model must already be open ('ja aberto') and provides a more specific meaning for 'partial' (updating only components present in the file). This adds actionable nuance to the parameter usage.

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 ('Substitui' - replaces) and a specific resource ('um modelo ja aberto' - an already open model) with a new IFC version. This clearly distinguishes it from siblings like solibri_open_model (which opens a new model) and solibri_list_models (which lists models). The scope is 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?

It explicitly identifies the use case: replacing an already open model with a new IFC version. It also provides a clear guideline for the 'partial' parameter ('Use partial=true para atualizar somente os componentes presentes no arquivo'). While it does not name alternative tools or state when not to use it, the context is sufficiently clear for an agent to select it appropriately.

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