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

The description adds meaningful non-obvious behavior beyond the annotations: it reads the bounding box from glTF accessor min/max without loading the mesh, records file size and certificate if present, and explains why bounding box matters for catching scale errors. This is valuable context that annotations do not convey. There is no contradiction with the destructiveHint.

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 three sentences and efficiently front-loads the core action. The first two sentences deliver the essential behavior, and the third explains the value of the bounding box in a memorable way. It is slightly discursive but not bloated.

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 three simple parameters, no output schema, and destructive annotations, the description covers the core behavior, special recording behavior, and an important use case. It does not describe return values, but that is not critical here. The omission of explicit output details is 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%, so the schema already documents all three parameters. The description adds little parameter-level meaning beyond mentioning 'jalur' and the concept of what gets recorded, but it does not clarify parameter formats or relationships beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a clear, specific action: 'Daftarkan GLB ke adegan' (register GLB into the scene), which names both the verb and the resource. It then distinguishes itself from loading tools by explicitly stating it does not load the mesh, and enumerates what is recorded (file size, bounding box, certificate). This makes the tool's unique role among the many rupa_* siblings clear.

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

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

The intended use is implied by the purpose statement and reinforced by the rationale about catching scale errors before publication. However, the description does not explicitly compare this tool to alternatives like rupa_muat or rupa_proksi, nor does it provide when-not-to-use guidance. It offers context but no direct routing.

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

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

Annotations already mark the tool as destructive, and the description adds the key behavioral detail that it overwrites 'adegan ruang ini' (this room's scene). It also explains that the scene is data and can be inspected, compared, versioned, and composed, which adds useful context 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 short and front-loaded, with the action and overwrite consequence in the first sentence. The second sentence about scene-as-data is slightly philosophical but reinforces the data-centric nature of the operation, so it earns a 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?

Given two optional parameters, full schema coverage, and a destructive annotation, the description covers the core operational facts: what is created, what is overwritten, and the data-oriented nature of scenes. It does not discuss return values or recovery, but no output schema exists and the destructive annotation already signals caution.

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

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

Schema description coverage is 100%, and both parameters ('nama' and 'ruang') already have meaningful descriptions explaining their purpose. The tool description adds no additional parameter-level detail, 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 clearly states a specific action ('Mulai adegan KOSONG') and a specific resource: an empty but valid scene containing camera, environment light, and sun. It also explicitly notes that it overwrites the current room's scene, which distinguishes it from sibling tools that add or modify individual elements.

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: use this tool to start a fresh, valid scene in a room, with the important consequence that it overwrites the existing scene. It does not name alternatives or state explicit when-not-to-use conditions, but the intended usage is unambiguous.

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 goes beyond the destructiveHint annotation by explaining that existing ids are overwritten and that publishing a scene with no light of strength > 0 produces a black screen with no message. This is exactly the kind of high-cost behavioral warning an agent needs.

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

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

Three short sentences, front-loaded with the core action and immediately followed by the most critical destructive and failure behaviors. No filler or redundant restatement of the schema.

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

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

The description covers the most severe risk and overwrite semantics, but with 8 parameters and no output schema it is not fully complete. An agent still has to guess the meaning of deletion, light type, color, position, and shadow parameters from names alone.

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

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

Schema description coverage is only 13%, so the description must compensate, but it only adds meaningful semantics for 'id' (overwrite) and indirectly for 'kuat' (strength must be > 0 to avoid black publish). It does not explain 'hapus', 'jenis', 'warna', 'posisi', 'bayangan', or how fields interact.

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-resource pair, 'Atur atau tambah cahaya' (set or add light), and clarifies scope by stating existing ids are overwritten and that the default sun can be changed. This clearly distinguishes it from other scene tools like kamera or lingkungan.

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 gives clear context for when the tool is appropriate: adding a light or modifying an existing one by its id, including the default sun. It does not explicitly list alternatives or exclusions, but the usage context is concrete enough for an agent to act on.

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 mutation risk is known. The description adds useful context that this only controls the initial view and that subsequent orbit belongs to the reader. It does not describe what is overwritten, but annotations carry the primary safety 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?

The description is two short sentences with no filler. It front-loads the main resource and attributes, then adds the key behavioral distinction. 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 mutating camera-setup tool with no output schema and sparse parameter documentation, the description omits coordinate conventions, whether an existing camera is replaced, and any return or confirmation behavior. It is not complete enough for an agent to invoke it confidently without additional assumptions.

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 only 25%, with only 'ruang' documented. The description mentions posisi, target, and fov, giving them the 'initial camera' meaning, but it does not explain units, coordinate space, array ordering, or how ruang affects the camera. With such low schema coverage, the description needed to compensate and did not.

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

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

The description names the resource (initial camera) and the attributes being set (position, target, field of view), and adds the temporal scope 'saat halaman pertama dibuka'. It also distinguishes this from interactive orbit by noting 'orbit sesudahnya milik pembaca', which separates it from related scene 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 clearly states when this tool applies: setting the camera seen when the page first opens. It also implicitly excludes later reader-controlled orbit, which tells an agent this is not for interactive camera manipulation. It does not explicitly name alternatives, but the usage context is 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 declare readOnlyHint=true and destructiveHint=false, so the safe-read profile is covered. The description adds context: the tool compares node diagonals against a scene median and cites 'a concrete historical scale failure' (438 satuan vs median 1.7) illustrating the check's purpose. A good color for comprehension, but it adds little about how the check is actually performed or what the output shape is.

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

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

The text is a single unlabeled block with the core function, a usage directive, and a extended anecdote about a past scale-faux lag. The anecdote provides domain color but takes up roughly half the text without adding call-time guidance, so the description is not tight.

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

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

For a one-parameter read-only tool with the schema fully covering the parameter, the description gives enough to use it: what it checks, which field it acts on via the annotated ruang param, and when to call it. A description of the memory format ('the numbers it fills in') would be nice, but no output schema exists and the tool's simplicity makes the current detail adequate.

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

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

Schema coverage is 100% — the single 'ruang' parameter is fully described in the schema ('Nama ruang kerja; tiap ruang punya adegan.blend sendiri'). The description adds no additional meaning about the parameter, so it hits the baseline 3 without going 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 states a specific function with a concrete scope: it reports each node's world size, each asset's certificate, and performs a skewed-scale check comparing node diagonals against the scene median. This distinguishes it functionally from the sibling list, though it does not explicitly contrast with nearby tools like rupa_periksa or rupa_ukur.

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 says 'call this before publishing' (Panggil ini sebelum terbit), which is clear workflow context for when to invoke it. It does not mention exclusions or alternative tools, but for a pre-publication check the timing guidance is direct and actionable.

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 mark the tool as destructiveHint=true and readOnlyHint=false, but the description does not disclose that the tool mutates the scene or that existing environment settings may be replaced. It adds a PBR-related warning about exposure, but not enough behavioral context for a destructive operation.

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

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

The description is short and front-loads the main feature categories in the first sentence. The second sentence adds useful PBR context without redundancy, though the noun-phrase style makes it slightly less direct.

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 9 parameters, no output schema, minimal schema descriptions, and a destructive annotation, the description is not sufficient. It does not state the tool's side effects, the meaning of most parameters, or what the agent should expect after invocation.

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

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

Schema description coverage is only 11%, so the description must compensate, but it only groups parameters into broad categories like sky, exposure, shadows, and fog. It does not explain the meaning of kabut_jauh, kabut_mati, kabut_dekat, kabut_warna, bayangan, or the sky color parameters in a way that helps an agent choose values.

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

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

The description identifies the tool's resource as the scene environment and lists its specific areas: gradient sky, exposure (ACES), shadows, and fog. It is clear and useful, though it does not use an explicit verb like 'mengatur' and does not explicitly differentiate this from sibling tools such as rupa_adegan_cahaya or rupa_adegan_lihat.

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 domain guidance that exposure is the correct brightness control in a PBR workflow and that increasing light strength would ruin reflections and shadows. However, it does not explicitly state when to use this tool versus alternatives or when not to use it.

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

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

Annotations already declare destructiveHint=true, and the description's 'hapus' aligns with that. The description adds context about the role system and scaling rationale, but does not disclose additional behavioral traits such as side effects, overwriting behavior, or whether deletion is permanent. It goes slightly beyond annotations but not substantially.

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, consisting of three short sentences, with the core action front-loaded. It avoids redundancy and is efficiently written, though it could be slightly more structured with bullet points, but it remains appropriately sized for the scope 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 29 parameters and no output schema, the description is far from complete. It does not explain the interplay between 'aksi' and required parameters (e.g., which fields are needed for add vs. update vs. delete), nor does it clarify return values or side effects. The heavy reliance on schema descriptions for parameters, combined with a minimal narrative, leaves significant gaps for an agent to safely invoke the 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?

With schema description coverage at 55%, the description compensates partially by explaining the semantics of 'jenis' and 'peran' (asset vs. basic shapes, and role-based scaling exclusion). It does not elaborate on many other parameters (e.g., fisika_* or transform fields), leaving gaps. The added context is helpful but not comprehensive enough to fully compensate for the moderate coverage.

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

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

The description states a clear verb and resource: 'Tambah, ubah, atau hapus node' (add, change, or delete a node). It further explains the concepts of 'jenis' and 'peran', giving specific semantics. However, it does not explicitly differentiate from sibling tools like rupa_adegan_aset or rupa_adegan_cahaya, so it lacks explicit sibling contrast.

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

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

The description provides context on when to use certain parameter values (e.g., why basic shapes exist, how 'peran' affects scaling evaluation) but does not give explicit guidance on when to use this tool versus alternative sibling tools. It implies usage through the node management context but 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?

Annotations already declare destructiveHint=true, and the description strongly complements this with rich behavioral detail: base64 embedding, the blank-screen failure mode under strict CSP, the 16 MB budget checked before writing, and the 4/3 byte inflation cost. This goes well beyond the annotation signal and gives an agent genuine expectations about side effects and failure behavior. No contradiction with 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 longer than minimal, but every sentence is dense with operational value: output format, embedding strategy, failure mode, cost math, and mode semantics. It is front-loaded with the core purpose before the caveats. Could be slightly trimmed, but no sentence is wasted 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?

With no output schema and a destructive hint, the description covers the tool's behavior thoroughly: output format, embedding, budget enforcement, and mode differences. The only gap is that it never states what the tool returns (success status, path, or error structure), which would help an agent interpret the call result. This is a minor omission for a write-and-return 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 50% (berkas and ruang have descriptions; judul and mandiri do not). The description directly compensates for the undocumented mandiri parameter by explaining what each boolean value produces. The base64 and budget details add meaning to the output context. judul remains undocumented in both places, but it is self-evident enough that this is a minor gap, not a failure to compensate.

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

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

The description states a specific verb+resource+output: publishing the scene (adegan) as a self-contained HTML page with orbit, click-select, and per-object numbers. It clearly differentiates the deliverable (a standalone HTML document with embedded assets) from sibling tools like rupa_ekspor and rupa_adegan_lihat by describing the exact output format, leaving no ambiguity about what this tool produces.

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 usage context for the two mandiri modes: mandiri=true for static servers producing a complete document, and mandiri=false for publishers with their own skeleton producing an HTML fragment. However, it does not name sibling alternatives or state when to prefer this tool over rupa_ekspor or other scene tools, so the guidance is clear for mode selection but lacks explicit 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 only mark the tool as destructive, so the description's added detail is valuable: it discloses automatic UV creation, cage distance computed from surface difference, a reported result with UV coverage and pixel variation, and a specific limitation (reverse direction is checked by polygon density, not from the image). This goes beyond the annotation without contradicting it.

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

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

The description is three dense sentences, each earning its place: purpose in the first, key algorithmic behavior in the second, and an important edge-case limitation in the third. It is front-loaded and free of 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 complex 10-parameter tool with no output schema, the description gives important behavioral context and result reporting, but it omits guidance on map types, output-file expectations, and several tuning parameters. It is minimally adequate but leaves noticeable gaps for an agent to call it correctly in varied scenarios.

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 50%, with descriptions on cage, ruang, berkas, rendah, and tinggi. The description adds semantic value by clarifying the low/high mesh roles and the cage-distance logic, but it does not explain several undocumented parameters such as jenis, ukuran, contoh, margin, or jarak_sinar. It provides some compensation but not full coverage.

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

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

The description uses a specific verb ('Panggang') and resource ('detail dari mesh RAPAT ke mesh RENGGANG jadi peta tekstur'), making the tool's core purpose immediately clear. It does not explicitly name a sibling tool for differentiation, but the high-to-low mesh baking direction is distinct enough from sibling texture tools.

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

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

The description implies the tool should be used when baking detail from a dense mesh onto a sparse mesh to produce a texture map, and mentions automatic UV creation and cage calculation. However, it does not explicitly state when to prefer this tool over alternatives like rupa_tekstur_buat, nor does it list exclusions or prerequisites.

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 destructiveHint=true, and the description adds specifics about what is destroyed ('Menghapus isi adegan ruang kerja ini') and the recommended single-call cadence. No contradiction with annotations exists; it enriches them by naming the affected scope.

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

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

The description is compact: one clause naming the purpose/effect, one clarifying destructive scope, and one usage directive. No filler 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 destructive initialization tool with no output schema, the description covers purpose, scope, and invocation timing. The main missing piece is the meaning of the satuan parameter; otherwise an agent has enough context 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 coverage is only 50% and the description adds no parameter meaning. The 'ruang' parameter has a schema description, but 'satuan' is undocumented in both the schema and description, and the prose does not explain how unit selection affects the new empty scene.

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: 'Mulai adegan KOSONG' and 'Menghapus isi adegan ruang kerja ini,' so an agent can tell it initializes/clears the current workspace scene. It does not explicitly name or contrast sibling tools, but the EMPTY-scene framing separates it from view, load, export, and other scene-related tools.

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

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

It gives clear when-to-use guidance: 'panggil sekali di awal sebuah model, bukan di tiap langkah' (call once at the start of a model, not at every step). This is positive and negative usage direction, though it does not mention alternatives by name.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds useful behavioral context by claiming volumes are exact and backed by analytic surfaces, but it does not disclose potential side effects like overwriting an existing named shape. 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?

Two sentences, front-loaded with the core purpose and then a sharp contrast with rupa_skrip. The example proving exact volume earns its place by making the claim concrete. No filler or redundant restatement.

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

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

The tool is complex: 12 parameters, 6 shape types, and no output schema. The description gives the key conceptual distinction but omits guidance on per-type required dimension parameters and what happens on naming conflicts or overwrites. The schema fills many gaps, but the description alone would not fully support correct invocation for all shape types.

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 75%, so most parameters are documented structurally. The description adds a concrete example tying jari and tinggi to exact volume (r=7.5, t=12), but it does not clarify the undocumented parameters (jenis, pusat, tinggi) or type-specific required combinations. This is adequate but not compensating beyond baseline.

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 opens with an explicit verb+resource: 'Buat primitif b-rep bernama.' It clearly differentiates itself from the sibling rupa_skrip by contrasting analytic B-rep surfaces with triangle-based approximations. The purpose is unambiguous and distinguishes the tool from nearby CAD siblings.

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 names rupa_skrip as the main alternative and states the fundamental difference: this tool stores exact analytic surfaces rather than meshes. This gives clear selection context for when exact geometry is needed, though it does not give explicit when-not-to-use conditions or mention other 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?

Annotations already mark the tool as destructive and not read-only. The description adds genuinely useful behavioral context: volume direction is checked, half-failed booleans can silently return an intact operand, and invalid-direction results are never saved. This goes beyond what annotations reveal.

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 compact sentences, front-loaded with the action and followed by a critical warning. Every sentence earns its place, with no filler or repeated schema information.

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

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

For a destructive five-parameter boolean tool with no output schema, the description covers purpose, failure mode, and result validation. It does not explain return behavior, but the schema handles overwrite and workspace semantics, and the main risk is clearly disclosed.

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 80%, so most parameters are already documented in the schema. The description adds little parameter-level detail beyond clarifying the operation involves two shapes, which is a reasonable baseline when the schema carries the load.

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

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

The description names the specific operation set ('potong, gabung, atau iris dua bentuk') and the resource acted on (two shapes). It clearly conveys what the tool does and distinguishes the core boolean semantics without 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?

No guidance is given on when to use this boolean tool versus sibling CAD tools, nor are prerequisites mentioned such as overlapping shapes or valid volume direction. The intended context is implied only by the operation type, with no 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description does not contradict them. It adds useful behavioral context by disclosing that the tool returns all shapes with computed metrics and validity, though it does not cover performance, failure modes, or whether metrics are computed on demand.

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 compact sentence that leads with the object and packs the output fields into one list. There is no filler or repetition of schema or annotation information.

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

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

For a read-only, one-optional-parameter listing tool, the description covers the essential return values (all shapes plus volume, area, edge count, and validity). It does not specify output format or behavior for an unknown room, but the annotations and schema cover safety and the parameter, leaving only 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 100%; the sole 'ruang' parameter is already described in the schema as the workspace name with its own scene file. The description adds no additional parameter-level meaning, so the baseline score 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 conveys that the tool enumerates all shapes in the current CAD space and returns derived properties (volume, area, edge count, validity) rather than only names. It identifies the resource and result content clearly, but relies on the tool name 'daftar' for the verb and does not explicitly differentiate 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?

There is no direct guidance on when to use this tool versus alternatives such as rupa_cad_bentuk, rupa_cad_ukur, or rupa_lihat. The phrase 'bukan cuma namanya' hints at a richer option than a name-only listing, but no alternative or exclusion condition is named.

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 real behavioral context beyond the annotations: triangle exports always deviate regardless of tolerance, and the error/deviation is reported. It also warns that a success message without a numeric error is untrustworthy. The destructive hint is not contradicted because writing a file is consistent with destructiveHint=true.

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 dense and front-loaded, with a clear purpose statement, a structured format list, and a useful warning. The phrase 'dan tidak disebut pesan galat mana pun' is slightly cryptic, but no sentence is purely 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?

There is no output schema, so the description must convey expected return behavior; the numeric-error warning helps but does not fully define the response. Details such as overwriting existing files and the exact structure of reported errors are missing, leaving the description 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds useful context about extension categories and tolerance behavior, but it does not substantially clarify nama or ruang 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 clearly states 'Tulis bentuk ke berkas' (write shape to file) and distinguishes exact B-rep formats from triangle mesh formats. It is specific about the resource and output categories, though it does not explicitly name a sibling alternative like rupa_ekspor.

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 gives concrete format-selection guidance: .step/.iges for CAD/CNC and .stl/.glb/.obj for web/print. The warning that triangle formats always deviate also helps the agent choose exact formats where precision matters. It does not mention exclusions or alternative tools explicitly.

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?

Even though annotations already mark this as destructive, the description goes well beyond that by disclosing a dangerous kernel behavior: fillet can return ok with a corrupted solid that adds material, and this tool guards against it via two independent validators. It also states that failed results are never saved, which is essential safety context for an agent.

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 front-loaded with the action and selection modes, followed by a measured, technically specific warning. The warning paragraph is long but earns its place because it prevents the agent from trusting a successful-looking but corrupted operation.

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

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

For a destructive mutation tool with seven parameters and no output schema, the description plus input schema cover selection modes, safety thresholds, overwrite semantics, and failure behavior. The only minor gap is that the success return payload is not described, but this is less critical for a mutating tool and the safety disclosures are unusually 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?

Schema coverage is already high (86%), so the description does not need to re-document parameters. It adds meaningful semantic value by explaining the safety boundary for `ukuran` with a concrete 10x20x30 example and by showing how edge selection modes relate to `tepi`, `arah`, and the all-edges default.

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

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

The description states a concrete action ('Bulatkan (fillet) atau serong (chamfer) tepi') on a specific resource (CAD edges), and enumerates the three selection modes: all edges, edges along a direction, or an explicit index list from `rupa_cad_tepi`. This makes the tool's scope unambiguous and separates it from the related edge-listing sibling.

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

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

The description gives explicit when-not-to-use guidance: for fillet above half the smallest side, it warns that results can be corrupted and the tool rejects them, then directs the agent toward `chamfer` as the clean-failing alternative. It also clarifies the three edge-selection modes, so an agent can choose the right call shape.

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 flag destructiveHint=true, and this description adds non-obvious behavioral context: external STEP files often contain invalid shapes that only surface during later operations, and import without measurement is uninformative. It does not explain the destructive side effects, but it does not contradict 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?

Two sentences with no waste: the first front-loads the action and formats, the second gives a practical rationale. Everything present 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?

The core workflow is clear, but there is no output schema and the description does not state what the measurement actually returns, nor what destructive effects may occur. For an import/measure tool, this leaves some operational ambiguity, although the main purpose is well covered.

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 documents 'nama' and 'ruang', but 'berkas' lacks a semantic description. The description compensates by specifying the accepted file formats (STEP/IGES/STL) and their origin (another CAD), giving meaning to the otherwise bare 'berkas' parameter.

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 specific action ('Baca STEP/IGES/STL dari CAD lain') and an explicit second purpose ('lalu UKUR isinya'). This distinguishes it from related siblings by combining external CAD import with measurement, so an agent can infer when to use it instead of rupa_cad_ukur or rupa_cad_bentuk.

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 contextual guidance: it is for importing STEP/IGES/STL from another CAD system and warns that importing without measuring provides no useful information. It does not explicitly name alternatives or state exclusions, but the context is clear enough for selection.

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

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

The description goes well beyond the annotations. It reveals that every solid is checked against closed-form formulas (extrusion vs area×distance, revolve vs Pappus theorem) and that results that deviate from these references are NOT saved. It also warns about specific pitfalls that break revolve (profile crossing the axis, angle outside 0–360). This adds critical behavioral context not available in 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 information-dense but well-structured. It front-loads the core purpose, then explains the unique verification mechanism, and ends with critical warnings. Every section earns its place, and the formatting (bold and clear headings) makes it scannable despite length.

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 complex tool with 23 parameters and no output schema, the description provides the essential conceptual framework, including verification logic and failure modes. It does not detail every parameter interaction, but the schema covers most parameter semantics. The description is sufficient for an agent to understand what the tool does and when to use it.

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 high (87%), so the schema already documents most parameters. The description adds value by explaining how key parameters are validated (e.g., extrusion compared to area×distance, revolve compared to Pappus) and highlights the pitfalls for sumbu and sudut. This enriches understanding beyond the schema definitions.

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 converts 2D sketches into 3D solids via extrusion, revolve, or loft, and gives concrete examples (floor plan → walls, profile → shaft/flange/container, path → solid). It distinguishes itself from sibling CAD tools by focusing on creating solids from sketches, not boolean or fillet operations. The resource and action are 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?

It provides clear context for when to use this tool (to model real objects from sketches) and gives domain examples. However, it does not explicitly name alternatives to avoid or conditions for preferring other CAD tools. The differentiation is implicit through the description of what this tool uniquely does.

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 annotations already state readOnlyHint=true and destructiveHint=false, so no contradiction exists. The description adds useful behavioral context beyond the annotations by disclosing the kernel cold-start latency and noting that subsequent CAD calls are effectively free.

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, stating the core purpose first and then the invocation guidance. Every sentence earns its place and no unnecessary details are included.

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

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

There is no output schema, but the description names the two expected outputs: kernel on/off status and shapes present in the workspace. It is adequate for an optional-parameter read-only status tool, though it does not describe the exact return structure.

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

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

Schema description coverage is 100%, and the ruang parameter is already documented as the workspace name with its own adegan.blend. The description adds little parameter-specific meaning beyond referring to 'this space', so it does not meaningfully improve on the schema.

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

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

The description clearly identifies the tool as a status/initialization check for the OCCT b-rep kernel, reporting whether it is on and which shapes exist in the workspace. It distinguishes itself from general tools like rupa_status by scoping to rupa_cad_* usage and naming the kernel 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 gives an explicit invocation rule: call once before using any other rupa_cad_* tool. It also provides the reason, the ~0.4s cold-start cost and free subsequent use, which helps an agent decide when this tool is required.

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 covered. The description adds the behavioral context that the tool returns edge indices with direction and length, and that these indices are stable enough to be referenced by fillet. However, it doesn't disclose the return format or whether the list is ordered, which would be useful for an agent relying on indices.

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 waste. The core purpose is front-loaded, and the usage warning is placed immediately after. 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 read-only listing tool with 100% schema coverage and no output schema, the description is nearly complete. It explains the purpose, the prerequisite relationship, and why the tool matters. The only gap is the lack of detail about the output format (how edges are identified, ordering), but since there is no output schema, a bit more detail there would help. Still, the description is strong for its 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?

Schema description coverage is 100%, so the schema already documents both parameters (nama and ruang) with patterns and descriptions. The description adds no parameter-specific meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Daftar tepi sebuah bentuk berikut ARAH dan PANJANGNYA' (list edges of a shape with direction and length). It clearly identifies the tool as a listing/inspection tool for CAD edges. It doesn't explicitly distinguish from siblings like rupa_cad_daftar or rupa_cad_ukur, but the edge-specific focus is clear enough.

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

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

The description gives explicit when-to-use guidance: 'Panggil ini SEBELUM fillet selektif' (call this BEFORE selective fillet) and explains why: without this list, 'fillet tepi tegak saja' means guessing indices, and edge indices are not guessable. This is strong usage guidance that names the prerequisite relationship with a sibling tool (rupa_cad_fillet).

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?

Beyond the destructiveHint annotation, the description reveals a volume-check behavior: it verifies that the transformation matches mathematical expectations (e.g., scale changes volume cubed). It also warns that volume shifts indicate a faulty matrix, providing valuable diagnostic context that the annotations do not cover.

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-loading the core action and following with a concise behavioral note. There is no extraneous information; every sentence contributes meaning and the structure is efficient.

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

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

For a tool with nine parameters and no output schema, the description is minimal. It does not clarify whether multiple transformations can be combined in one call or whether they are exclusive, which is a notable gap given the schema permits all parameters. It also omits any mention of error conditions or prerequisites beyond the volume check.

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 description coverage is 44%, and the tool description lists the operations but does not map them to specific parameters (e.g., 'geser' for translation, 'putar_sudut' and 'putar_sumbu' for rotation). The description adds general context about operations but does not compensate for the missing parameter-level details, leaving some ambiguity about how each parameter is used.

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 (translate, rotate, scale, mirror) and the object (a shape) in the first sentence. It distinguishes the tool as a transformation operation, which is distinct from creation, measurement, or other sibling tools. The operations are 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 does not specify when to use this tool versus alternatives like shape creation or boolean operations. It mentions no prerequisites, conditions, or when-not-to-use guidance, leaving the agent to infer the appropriate context from the operation names alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful context by explaining why two numbers are always reported together, i.e., to indicate what is lost when the shape is sent to the web. This goes beyond the annotations but is limited in scope—no discussion of error handling, permissions, or side effects (though unlikely given read-only).

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

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

The description is concise (two sentences) and front-loaded with the key measurements. The second sentence adds a purposeful explanation without unnecessary words. Every sentence earns its place, and the structure supports quick comprehension.

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 comprehensively lists the return values (volume, area, edge/face counts, bounding box, mesh approximation cost) despite the lack of an output schema. It explains the rationale for the pair of numbers. It is mostly complete for a read-only measurement tool, though it omits potential error conditions or prerequisites (e.g., shape existence).

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 67% (nama and ruang have descriptions; toleransi does not). The description does not add any parameter-specific details. It mentions tolerance implicitly but does not explain its semantics or valid range. With moderate coverage, a baseline of 3 is appropriate, but the description adds no value 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 clearly specifies the tool's function: measuring exact volume and area, edge and face counts, bounding box, and mesh approximation cost at a tolerance. It names specific resources and metrics. However, it does not explicitly distinguish from the sibling 'rupa_ukur' or other measurement tools, so it lacks explicit differentiation.

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 does not mention context, prerequisites, or distinctions from related tools like 'rupa_ukur'. A user would have to infer usage from the name and schema alone.

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

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

The description adds meaningful behavior beyond annotations: scale is applied to vertices first with a rationale, and the result reports triangle count, bounding box, and warnings. The destructiveHint annotation already covers the write/mutation risk, so the description does not need to repeat it.

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

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

A single dense sentence that front-loads the core action and then adds valuable behavioral details and output information. The parenthetical rationale about three.js is short and 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 destructive export tool with no output schema, the description covers the key action, the important scale-baking behavior, and what the result contains. The schema handles parameter specifics and the annotations handle the destructive hint, so the overall context 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?

Schema descriptions already document draco, ruang, and berkas. The description adds useful context around scale-baking, which relates to terapkan_transformasi, and describes the output report. However, draco_level and terapkan_transformasi are not explicitly explained, leaving a partial parameter coverage gap.

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

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

The description states a specific action and resource: 'Ekspor adegan ke GLB' (export scene to GLB). This clearly distinguishes it from sibling export tools like rupa_cad_ekspor, which target CAD data rather than a scene.

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

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

Usage is implied: an agent would use this when it needs to export a scene to GLB. However, the description gives no explicit when-to-use guidance, exclusions, or references to alternatives such as rupa_cad_ekspor or rupa_adegan_terbit.

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 provide readOnlyHint=true and destructiveHint=false, so safety is known. The description adds valuable behavioral context beyond that: camera and lights are automatically set from the scene bounding box, ensuring framing regardless of object size, and the enforcement that the agent must read the image. This is beyond what the annotations convey and helps the agent understand side effects and limitations.

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

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

The description is two sentences, front-loaded with the primary action and output, followed by the automatic camera/lighting behavior and the angle list. It is efficient and packed with necessary information without excessive fluff. The second sentence is long but logically 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 tool with 7 parameters and no output schema, the description covers the core purpose, return type (PNG paths), and a critical behavioral requirement (read the image). However, it does not describe the output format beyond paths, nor does it explain several parameters. Given the moderate complexity, 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?

Schema coverage is low at 29%, with only mesin and ruang having descriptions. The description compensates for the most complex parameter, sudut, by listing named angles and the 'yaw,pitch' format in degrees. However, it does not clarify other parameters like fov, contoh, ukuran, or latar_tembus. Given the low coverage, the description partially compensates but leaves 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 renders multiple angles to PNG and returns their paths, with a specific verb and resource. It also lists supported angle names and a custom format, making the purpose unambiguous and distinct from any sibling that might just view or inspect a scene.

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 explicit comparison to sibling tools or conditions for when to choose this over alternatives. However, it does offer behavioral guidance: 'BACA gambarnya sesudah ini, jangan mengaku selesai dari angka saja' (read the image, don't claim done from numbers alone), which tells the agent to actually visually inspect the output. This is useful but not a full when-to-use/alternatives discussion.

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 destructiveHint=true and readOnlyHint=false, so the description adds value by explaining that reduction always 'succeeds' but the real criterion is error tolerance. It also clarifies that the error is measured as distance to original surface, which is a useful 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 concise, front-loads the core functionality, and provides a meaningful heuristic (2% diagonal) without fluff. It's a single paragraph with no 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?

Given the tool's moderate complexity (3 params, no output schema), the description covers the essential purpose and quality trade-off. It doesn't explain return values, but that's mitigable since no output schema exists and the description implies error metrics are provided. Slightly more detail on result format could help, but it's adequate.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description doesn't add much per-parameter detail, but it does frame the 'nisbah' parameter as the fraction of triangles to keep, which matches the schema description. The mention of 'same as Decimate modifier' adds context beyond the schema, but not crucial.

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 creates a chain of LODs with geometric error measurements, and explains the trade-off between mesh reduction and quality loss. It distinguishes itself from sibling tools like rupa_rantai, but doesn't explicitly name a sibling 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?

It implies usage for mesh simplification with a quality threshold ('above 2% diagonal'), but doesn't explicitly state when to use this versus alternative simplification tools (e.g., rupa_proksi) or when not to use it. It provides a general guideline but not explicit routing.

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

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

Annotations include destructiveHint=true, and the description confirms this by noting that SVG paths are 'di-extrude' or 'di-bevel', implying modification and potential destruction of original data. It adds valuable behavioral context on how SVG fills and strokes are treated differently, and mentions that using the same extrusion value for both results in 'pita setipis kertas yang melayang' (paper-thin floating ribbon). This goes beyond the annotation's binary flag and provides concrete behavioral expectations.

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, with two sentences that pack critical information. The first sentence lists formats and introduces the SVG extrusion capability. The second sentence explains the precision advantage. It is front-loaded with the core purpose and key differentiator. No fluff, but it could be slightly more structured with bullet points for formats, though the brevity is a strength.

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

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

Given the tool's complexity (multiple formats, mode-specific parameters for SVG, and the nuance of relative vs absolute thickness), the description provides enough context for an agent to understand the primary use case and key pitfalls. It mentions the precision benefit of SVG extrusion and warns about the 'paper-thin' issue. However, it does not describe return values or side effects (like whether the original file is modified), but with no output schema and destructiveHint=true, these are minor gaps. The description covers the essentials well.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. However, the description adds significant extra meaning beyond the schema, especially for `ekstrusi` and `tebal_nisbi`, explaining the difference between fill vs stroke paths and the recommended relative thickness method. It also notes that absolute units are unpredictable due to scale differences (SVG 64x64 becomes 0.0169 Blender units). This enriches the agent's understanding of how to use parameters correctly.

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 imports 3D files (.glb, .gltf, .obj, .fbx, .stl, .ply) and 2D vectors (.svg) into a scene. It uses a specific verb ('Impor') and resource ('berkas 3D... atau VEKTOR 2D') and mentions the unique 2D→3D capability for SVG. This distinguishes it from siblings like `rupa_cad_impor` (likely CAD-specific) and `rupa_adegan_aset` (likely asset placement).

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 for when to use this tool, especially highlighting the SVG extrusion as 'jalur 2D→3D paling presisi yang ada' (most precise 2D→3D path). However, it does not explicitly say when NOT to use it or mention alternatives like `rupa_cad_impor` for CAD files. But the supported file types are enumerated, making it clear this is for general model/vector import.

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 destructiveHint=truehare, so the description correctly implies mutability (issuing certificates). It adds behavioral context beyond annotations: it explains the weighted rules (wajib vs peringatan) and the critical behavior that missing measurements are counted as FAILED, warning against silent non-execution. This is valuable context that helps the agent understand the tool's semantics, even though it does not detail all destructive side effects (e.g., whether copying files is considered destructive).

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 paragraph that packs critical information without fluff. It front-loads the core purpose (evaluate and issue certificate), then explains the distinctive output and rule semantics. Every sentence adds value: purpose, differentiation, rule behavior, and the caution about missing measurements. It is appropriately sized for the tool's complexity.

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 moderate complexity (5 parameters, no output schema) and the rich annotations (destructiveHint), the description covers the most important aspects: what the tool does, how to choose between direct GLB and scene, and how rules behave. It lacks explicit information on return values or how the certificate is structured, but since there is no output schema, the description could have mentioned the output format. However, it is sufficient for an agent to invoke the tool 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 covers 100% of parameters with descriptions, so baseline is 3. The description adds context by explaining the semantics of 'berkas' vs 'ruang' (direct GLB vs scene), which is already in the schema but re-emphasized. It does not add new parameter meaning beyond the schema, such as exact formats or examples of the 'spek' parameter's contents beyond the built-in paths. Thus, it does not exceed baseline significantly.

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 evaluates a scene against a specification (SPEK) and issues a certificate. It goes beyond a simple verb+resource by explaining the distinctive output (a list of promises with numbers that prove or refute them), which distinguishes it from sibling tools like rupa_ukur (measure) or rupa_lihat (view). The mention of the certificate attached to the file adds specificity.

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 explains when to use direct GLB measurement via 'berkas' vs. the scene in 'ruang' when Blender is needed: 'Ini yang seharusnya dipakai untuk aset yang sudah jadi... Kosongkan untuk mengukur ADEGAN di `ruang` (butuh Blender).' It also clarifies the 'tempel_ke' behavior (copy the file and attach certificate, never overwrite the source). This gives clear guidance for selecting the appropriate mode, although it does not explicitly compare to sibling tools, it provides enough context for usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description goes beyond by disclosing the critical behavioral trait: the silent failure of Rapier's convexHull above ~8000 points, including a detailed warning with consequences (zero-volume collider, objects falling through world) and mitigation (pre-reduction and exact checks). This is exactly the kind of beyond-annotations context that helps an agent avoid a nasty surprise.

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 front-loaded with the core purpose and integration point, followed by the measurement rationale and a critical warning. It's dense but every sentence adds value; the warning is essential and well-placed. Slightly long for a tool description, but justifiably so.

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

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

Given the tool's complexity (3 params, no output schema, annotations for safety), the description covers the key aspects: purpose, integration, measurement methodology, and a critical gotcha. It doesn't describe the return format beyond cost and points, but since there's no output schema, that information is missing. However, the description provides enough for an agent to call it correctly, and the warning is a critical addition.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds context for the 'arah' parameter by explaining how it affects proxy tightness and cost reporting, which is marginally useful, but the basic semantics are already in the schema. No significant compensation needed.

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 builds a convex collision proxy from a GLB and measures the cost, with a specific verb and resource. It differentiates from siblings by mentioning it works with rupa_adegan_node's 'cembung' shape, but it doesn't explicitly name an alternative tool for collision generation, though the sibling list includes rupa_tabrakan.

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 for generating collision proxies, and it provides a specific integration point, but it doesn't explicitly state when to use this over alternatives like rupa_tabrakan. It gives context on measurement methodology (using projectPoint) but no explicit when-not-to-use or alternative selection 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?

Annotations already communicate readOnlyHint=false and destructiveHint=true; the description adds valuable behavior beyond that: the chain halts at the first failure ('RANTAI BERHENTI DI KEGAGALAN PERTAMA'), per-op timing is intentionally not measured, and only whole-chain time is reported. It also makes the 'identical results' claim explicit and keeps performance claims empirical. This is genuinely supplementary, not contradictory.

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 longer than a one-liner, but it earns its length by establishing why the tool matters (benchmark figures), how execution differs (fail-fast, no per-op timing), and when not to use it. The main purpose is front-loaded in the first sentence. The benchmark details are slightly over-elaborate but acceptable; this is near the upper bound of 'no wasted sentences.'

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 there is no output schema, an agent is left uncertain about the return/reported result beyond the statement that whole-chain time is reported. The description covers batching eligibility, failure behavior, and consistency, which goes a long way, but it never states what happens when an op is not describing return values or how successful results are delivered. The absence of per-op timing and return shape leaves a gap for a tool of this 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?

Second-dimension schema coverage is 100%: both `ops` and `ruang` have complete descriptions, so the baseline is 3. The description content adds no direct parameter-level detail (e.g., no mention of the `ops` array format or `ruang` placement) but it also does not need to repeat schema information. It receives no credit 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 opens with an unambiguous verb and resource: 'Jalankan beberapa op Blender dalam satu proses.' It clearly defines the tool as a batching mechanism and contrasts it with repeated single-op calls ('Enam op satu per satu makan 22,2 detik'), which distinguishes it from the many individual `rupa_*` siblings even without naming them. A full 5 would be justified if it explicitly named the alternative tools such as `rupa_lod` or `rupa_ukur`.

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 when-not condition: 'YANG TIDAK BISA DIRANTAI: urutan yang punya KEPUTUSAN di tengah' and tells the agent to split these into separate chains ('Pecah jadi beberapa rantai'). It also explains the failure-stop approach but stops one step short of naming which single-op tool to use as an alternative for a chain that can't be batched.

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 supply destructiveHint=true and readOnlyHint=false, covering the main safety profile. The description adds useful context: execution is headless, the scene is saved afterward, and a `keluaran` dict is returned. It does not discuss failure behavior or partial mutation, but the destructive annotation and save side-effect are the most important 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 compact: it front-loads the purpose, then lists the available environment, then gives coding guidance. Each sentence earns its place, with no filler. It is slightly run-on, but still scannable and appropriately sized.

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 complex code-execution tool with no output schema, it covers many key aspects: available modules, workspace path, return dict, and save behavior. It does not specify what happens on error, whether the scene is loaded before execution, or the expected shape of `keluaran`. This leaves enough ambiguity that an agent may need to probe or infer before calling.

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 only 50%, and the required `kode` parameter has no schema description. The description compensates by explaining what code can reference (bpy, bmesh, math, mathutils, RUANG, keluaran) and gives concrete guidance about using named numbers instead of magic values. The `ruang` parameter is already described in the schema, so the added context is meaningful.

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 core operation: run Python `bpy` inside headless Blender and save the scene. It also labels itself a low-level modeling primitive, which helps separate it from the many specialized sibling tools. It does not name a sibling, but the raw-script identity is specific enough.

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

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

The 'PRIMITIF PEMODELAN' label implies it is meant for custom, low-level modeling code, and the available bpy/bmesh/mathutils context suggests a general scripting use. However, there is no explicit statement of when to choose this tool over the specialized siblings, nor any exclusions. Usage guidance is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful behavioral context by specifying exactly which status facts the tool reports and by instructing that it should be called once at the start. No contradiction exists.

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

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

The description is extremely concise: two short clauses that front-load what the tool returns and then state when to call it. Every word earns its place with no repetition 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 read-only status tool with no output schema, the description covers the key return values and call timing. It could mention what happens when the workspace does not exist, but for a status probe with one optional parameter, the description is adequately 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?

Schema description coverage is 100%, and the single optional parameter 'ruang' is already well-documented with a default value and pattern. The description does not add additional parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies a status-checking tool for the Blender workspace and enumerates three concrete outputs: Blender version, workspace root, and scene existence. It is understandable even without a title, but it does not explicitly differentiate itself from sibling tools like rupa_cad_status.

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 instruction 'Panggil sekali di awal' gives clear guidance on when to invoke it: once at the beginning of a workflow. It does not explicitly mention when not to use it or name alternatives, but the timing instruction is actionable and sufficient for a status probe.

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 signal destructiveHint=true; the description does not contradict that. It adds useful constraints such as dynamic trimesh not being supported by most engines and clarifies the behavior of `tembus` and `longgar`, but it does not say what is actually mutated or what the invocation result is.

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 core purpose is front-loaded and the rest of the description explains only relevant jargon and constraints. The technical details are compact and not redundant, even though the phrasing is dense and assumes some collision-proxy familiarity.

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 four-parameter mutation tool with no output schema, the description does not fully clarify what object or current scene receives the proxy, nor what a successful call returns. It provides strong domain detail but leaves the invocation contract partially implicit.

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

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

The description adds meaningful semantics around the `bentuk` parameter and the meaning of proxy surface gaps, which the schema does not fully provide. With only 50% schema description coverage, it still leaves `objek` semantically implicit and does not tie every parameter to its intended function.

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 establishes that the tool deals with collision proxies and explains the two error directions, so it is not a tautology. However, it never states an action verb such as 'create' or 'update', and it does not differentiate the tool from siblings like rupa_proksi.

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 gives concrete when-to-use guidance for shape selection: `cembung` is the workhorse for web physics engines like Rapier, and `mesh_sederhana` should be used only for static objects. But it gives no context on when to use this tool as a whole versus related tools, so the guidance is incomplete.

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 tool as read-only and non-destructive, and the description adds substantial behavioral context: it computes pixels per meter, catches three specific waste patterns, validates normal maps under two conditions, and warns about misinterpreting factors. This goes far beyond what annotations or schemas 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 longer than average but every paragraph earns its place: purpose, thresholds, hidden-waste categories, normal-map pitfalls, and factor interpretation. It is front-loaded with the core metric and organized by topic, though some sentences could be tightened without losing meaning.

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

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

With no output schema and only three simple parameters, the description supplies all essential context an agent needs: what to pass, what it computes, how to interpret results, and which texture pathologies it detects. Nothing critical is missing for correct invocation and interpretation.

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

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

Schema description coverage is 100%, so the parameters are already well-documented individually. The description reinforces the meaning of piksel_per_meter with metric thresholdsanding, but it does not add new parameter-level semantics beyond what the schema states.

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

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

The description opens with a specific verb—'Periksa TEKSTUR sebuah GLB'—and names the exact question it answers: whether texture resolution is sufficient or too large. It also distinguishes itself from siblings like rupa_tekstur_buat by framing itself as an analysis tool, not a creation 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 clearly explains when this tool is useful—checking texel density and hidden texture waste—and provides concrete thresholds for interpreting results. It implies no other tool does this ('tidak ada alat yang mengalikannya'), but it does not explicitly name alternatives or state when not to use it.

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

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

Annotations declare destructiveHint=true, and the description reinforces this by mentioning replacing materials. It adds valuable behavioral details beyond annotations: the need for an active image node, the lighting inclusion in diffuse bake, and color space requirements. This enriches the agent's understanding of side effects and prerequisites.

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 structured in three clear paragraphs: action, export warning, and key gotchas. It is somewhat long but every sentence contributes valuable information. The critical pitfall is front-loaded in the second sentence, making it immediately visible.

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

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

For a tool with 8 parameters, no output schema, and destructive behavior, the description covers the process and pitfalls but omits explanation of several parameters and the output format (beyond the schema's 'PNG' hint). It is adequate for understanding the workflow but not fully complete for parameter selection and expected results.

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

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

Schema description coverage is 50%, and the description does not add any parameter-specific meaning. It focuses on the process and pitfalls, leaving parameters like gaya, jenis, contoh, and ukuran undocumented both in schema and description. The description does not compensate for the missing schema descriptions.

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

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

The description states a specific verb sequence (build procedural material, bake to image maps, replace with image-based material) and the resource (Blender material). It clearly distinguishes this tool from sibling rupa_bake by covering the full pipeline, not just baking. The export motivation is 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?

The description implies usage when exporting to glTF and explains the procedural material limitation, but it does not explicitly name alternatives or exclusion conditions. It gives context for when to use this tool but leaves the agent to infer that rupa_bake might be for baking-only scenarios.

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 agent knows it's safe. The description goes well beyond that by disclosing the critical vertex-welding preprocessing step with a concrete example (30,790 vs 360 after welding, inflating 85x), and it transparently states the limitations of glTF (no quad/n-gon info). This adds significant behavioral context that the annotations cannot convey, and there is no contradiction.

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 well-structured: it opens with a crisp one-sentence purpose, then lists the reported metrics, then highlights the critical welding caveat with a concrete example, and finally states the inherent limitations. Every sentence earns its place, and the most important information (purpose and the welding caveat) is front-loaded. It is detailed but not bloated.

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

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

Given the tool's complexity, the description covers all essential aspects: purpose, supported checks, preprocessing behavior, and limitations. It also lists the output metrics in the description, which partially compensates for the lack of an output schema. A minor gap is the absence of the exact output structure or return format, but for an agent deciding whether to call it, this is sufficient. Overall it is complete for the task at hand.

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% with each parameter having a descriptive comment, so the baseline is 3. The description's main body reinforces the meaning of toleransi_las by explaining the welding concept and its implications, which helps an agent understand why the parameter exists and how it affects results. This adds context beyond the schema's individual descriptions, justifying 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 tool's purpose: inspecting the topology of a GLB file, focusing on connectivity rather than positions. It lists specific checks (non-manifold edges, boundary edges, inverted triangles, degenerate triangles, vertex split ratio, texel density, UV out of range) and explicitly differentiates from a generic inspect tool by naming the resource and the operation. The phrase 'bagaimana verteksnya TERSAMBUNG, bukan di mana letaknya' makes the scope unambiguous, and it is distinct from siblings like rupa_periksa or rupa_ukur.

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 strong usage context: it works on any GLB file without Blender, and it warns about the vertex-welding behavior that affects interpretation of manifold results. It also explicitly states what cannot be measured (quad/n-gon ratio, edge loops) because glTF is triangulated, cautioning against tools that claim otherwise. However, it does not explicitly name alternative tools or give a when-not-to-use directive, so it falls short of a perfect 5.

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, and the description adds substantial behavioral context: all-triangle meshes produce a warning because the tool cannot distinguish genuine triangle topology from import triangulation, boundary vertices are excluded from pole analysis, and a concrete measurement example confirms zero quad recovery from GLB. These edge cases materially affect how an agent should interpret results.

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

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

The text is long, but each bolded section serves a distinct purpose: scope, differentiation from the sibling, rationale, limitation, and analysis caveat. The core definition is front-loaded, though the motivational paragraph and measured example could be trimmed without losing essential invocation guidance.

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 measurement tool with no output schema, the description covers the source-vs-GLB distinction, the warning condition for fully triangulated meshes, boundary handling, and the four measured topology metrics. It stops short of describing the exact return shape, but an agent has enough context to invoke and interpret the result correctly.

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

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

Schema description coverage is 100% and every parameter (objek, ruang, per_objek, ambang_sebidang) already has a meaningful schema description. The tool description does not add parameter-level explanation, so it stays at the baseline expected when the schema carries the semantic load.

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 first sentence names a specific action and resource: measuring SUMBER topology metrics (quads, n-gons, vertex valence, poles, edge loops) from the mesh inside Blender. It also explicitly contrasts with the sibling rupa_topologi, which reads GLB and reports these as immesurable, so an agent can immediately distinguish the two tools.

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

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

The description states that the tool reads the source mesh rather than approximating from a GLB, names rupa_topologi as the GLB-reading sibling, and warns that loading a GLB into Blender does not recover quads. This conveys the main usage context, though it does not spell out an explicit when-not-to-use rule for every alternative.

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 safety is covered. The description goes beyond that by disclosing the exact nature of the output: per-object mesh stats, scene bounding box, and warnings. This clarifies what the agent can expect back, which is useful behavioral context 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 two sentences: the first packs a comprehensive list of output items, and the second adds a short rationale. It is concise and the most critical information (what the tool returns) is front-loaded. The second sentence is slightly philosophical but not wordy, so it does not detract from clarity.

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 measurement tool with a single optional parameter, the description provides a solid overview of the return contents (per-object metrics, scene bbox, warnings). Since there is no output schema, this is the only source of what an agent will receive. It could be slightly more explicit about the output format (e.g., JSON structure) but otherwise covers what an agent needs 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?

The only parameter 'ruang' is fully described in the schema with a clear explanation (workspace name, each has its own blend scene) and default value. The description does not mention this parameter or add any additional semantics. Schema coverage is 100%, so the baseline of 3 applies; the description adds no extra value for parameter understanding.

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 provides numeric measurements for each mesh object, enumerating specific metrics (triangles, vertices, n-gons, non-manifold edges, loose vertices, area, size, location, scale, applied scale, materials) plus scene bounding box and warnings. This is a specific, concrete resource-and-verb definition that distinguishes it from measurement-adjacent siblings like rupa_cad_ukur (CAD measurement) or rupa_lihat (view).

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 does not mention any preconditions (e.g., selection required), exclusions, or alternative tools. The final sentence ('This is what makes the result precise') vaguely implies it is for precise measurement, but it does not tell the agent when to prefer it over sibling tools or when not to use it.

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