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

With no annotations, the description carries the full burden, and it does disclose a meaningful side effect: the output is 'automatically registered and returned by filename,' which tells the agent a backend record is created and what the return value is. It says nothing about write locations, overwrite behavior, or failure modes for unsupported/invalid GML.

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

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

Two tight sentences with the conversion scope front-loaded; 'using citygml-tools' is a minor implementation detail but justifies the version list. No filler or repetition.

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 zero schema coverage, no output schema, and a second boolean parameter, the description leaves too much unspecified — notably the meaning of 'source' and the effect of 'json_lines.' It covers the happy path and the registration side effect but not enough for confident 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 0%, so the description must compensate, and it largely does not. It never explains whether 'source' is a filesystem path, an uploaded file id, or a registered name, and it omits the 'json_lines' flag entirely, leaving the agent to guess that it produces CityJSONSeq-style output.

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

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

States a specific verb and resource ('Convert a CityGML 1.0/2.0/3.0 GML/XML file to CityJSON'), including the supported input versions, so the direction of conversion is unambiguous and clearly the mirror of cityjson_to_citygml. It does not explicitly name the reverse sibling, but the conversion direction alone is enough to distinguish it.

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

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

Usage is only implied: an agent infers it should call this when it holds a CityGML file. There is no explicit when-to-use, no statement of when NOT to use it, and no differentiation from nearby tools such as cityjson_import or cityjson_import_text that could plausibly also take external data.

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

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

With no annotations, the description carries the full burden, and it does disclose two non-obvious behaviors: coordinates are untouched (metadata-only change) and the result is a new filename rather than an in-place mutation of dataset_id. It says nothing about whether the source dataset survives, what happens with an invalid EPSG code, or permission requirements.

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

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

Two short sentences with zero filler; the key constraint (no coordinate change) and the return value are both front-loaded and immediately scannable.

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 two-parameter tool with no output schema, the description covers the essential contract: it mutates CRS metadata only and returns a new filename. Only error/mutation-safety details are missing, which is a minor gap at this complexity level.

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%: dataset_id is documented in the schema, but epsg only has numeric bounds. The description adds that epsg is an EPSG reference applied to the dataset metadata, which partially compensates, but it does not establish expected format (e.g. 7415 vs 'EPSG:7415') or validity constraints.

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

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

States a specific verb (assign/update) and resource (the EPSG reference in the dataset), and the clause 'without changing coordinate values' effectively separates it from cityjson_reproject, which does alter coordinates. It stops short of naming the sibling explicitly, so the differentiation is implied rather than stated.

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 'without changing coordinate values' phrasing implies when this is preferred over a reprojection, but there is no explicit 'use this instead of cityjson_reproject when...' guidance, nor any stated preconditions such as requiring an opened dataset.

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

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

No annotations are supplied, so the description carries the full behavioral burden and mostly drops it. It implies an irreversible mutation but never says whether the change is applied in place or returns a new dataset, what happens if the attribute is missing on some CityObjects, or whether the result needs cityjson_save to persist.

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

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

A single front-loaded sentence with zero filler, and the target scope is stated before the tooling reference. It is arguably too terse for a mutation, but nothing in it is wasted.

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 with no annotations and no output schema, the description should explain persistence, failure behavior, and the relationship to the sibling rename/remove tools. None of that is present, so an agent would have to guess about side effects.

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%: dataset_id is documented in the schema, while name has no description at all. The phrase "an attribute" indirectly tells the agent that name is the attribute key, which adds a little meaning, but it does not cover case sensitivity, namespaced/generic attributes, or nested paths.

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

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

States a specific verb-and-resource pair ("Remove an attribute") plus the scope ("across CityObjects") and the underlying engine (cjio). An agent can infer it is the inverse of cityjson_attribute_rename, though the description never names that sibling explicitly.

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

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

There is no guidance on when to use this versus cityjson_attribute_rename or cityjson_query, no stated prerequisites (e.g. the dataset must be opened first), and no exclusions. Usage must be inferred entirely from the name.

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

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

No annotations are supplied, so the description bears the full behavioral burden, yet it only implies a mutation via the word "rename." It does not say whether existing attributes on all objects are modified in place, what happens if old_name is absent, whether the change is persisted or in-memory only, or how errors are surfaced.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though the brevity is partly under-specification rather than disciplined editing.

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 parameterized mutation tool with no annotations, no output schema, and undocumented parameters, the definition is too thin. An agent lacks enough to know whether the rename persists, whether a save step is required, and how failures on missing attributes behave.

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 33% – just dataset_id is documented in the schema, and that text largely references other tools. The description adds nothing about old_name/new_name semantics: no statement on nested or dotted attribute paths, case sensitivity, or whether collisions with an existing new_name are rejected.

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?

"Rename an attribute across CityObjects with cjio" gives a specific verb (rename), resource (attribute), scope (across CityObjects) and engine (cjio). It is clear enough to distinguish from cityjson_attribute_remove by name, but the description itself does no explicit sibling 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?

There is no when-to-use guidance: nothing says this is a mutation on an already-opened dataset, whether the change must be followed by cityjson_save or cityjson_export, or when to prefer it over cityjson_attribute_remove or a query-based workflow. The agent must infer all preconditions from the sibling list.

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

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

With no annotations, the description carries the burden of explaining behavior. It states that the tool checks installation and callability, which is useful, but it does not disclose output format, possible side effects, or whether external processes are invoked. This is acceptable for a simple status check but not fully transparent.

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

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

Two short, purposeful sentences with no wasted words. The key action is front-loaded and the usage recommendation follows naturally.

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

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

For a zero-parameter diagnostic tool, the description covers what the tool does and when to run it. It does not specify the return value format, but the intent is clear enough; a brief note on output would make it fully complete.

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

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

The tool has zero parameters, so there is nothing for the description to add about parameter meaning. The baseline of 4 applies because no parameter documentation burden exists.

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 ('Check') and names a specific resource ('external CityJSON/CityGML engines installed and callable'), clearly distinguishing this diagnostic tool from the many file-operation siblings. It also frames the tool's role relative to backend-dependent failures.

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

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

It explicitly tells the agent when to run this tool: 'Run this first when a backend-dependent operation fails.' It does not mention exclusions or alternatives, but there are no obvious status-check siblings, so the guidance is clear 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?

With no annotations, the description carries the full burden, and it does disclose one important behavioral fact: the operation returns a new filename rather than modifying in place, so it is effectively non-destructive. However, it says nothing about whether the original dataset is discarded, whether the new dataset must be saved/exported separately, or what the return string looks like beyond 'a filename'.

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

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

Two short sentences, front-loaded with the action and ending with the return value. Nothing is padded, though the mention of the internal cjio command is mild implementation detail rather than agent-facing 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 one-parameter, no-annotation, no-output-schema tool this is close to adequate, and the return value is stated. Still missing is pipeline context: whether the result replaces the input handle, and whether the agent should chain into cityjson_save or cityjson_export afterwards.

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 dataset_id parameter is already documented in the schema as coming from cityjson_open, cityjson_import, or a transformation. The description adds no further meaning about accepted handle formats or constraints, so baseline 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?

States a specific verb and resource (remove duplicate and orphan vertices) and names the underlying operation (cjio vertices_clean). It is clearly distinguishable from siblings like cityjson_remove_textures or cityjson_validate, though it does not explicitly contrast itself with any of them.

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

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

There is no when-to-use guidance, no preconditions (e.g. run after import/merge, before export), and no statement about how it relates to validate or triangulate. The agent must infer the workflow position entirely.

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

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

With no annotations, the description carries the burden and does disclose the read-only restriction (SELECT-defined subset) and the two-stage output shape (CityJSONSeq, then optionally a single CityJSON file). It does not state where files are written, how the output file is named, or what permissions the connection 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?

A single dense sentence that front-loads the verb and scope, with the optional behavior trailing. No filler, though the 'named CityJSON file' clause introduces ambiguity rather than 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 3-parameter tool with a self-describing connection object and no output schema, the description covers input modes and output format adequately. The notable gap is the unspecified output file naming/location, which matters for a tool that produces files.

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 33%: only 'query' is documented in the schema, and the description reinforces it as a SELECT-defined subset. It also hints that 'collect' controls consolidation into a CityJSON file, but never explains where the 'named' file's name comes from, leaving the boolean's effect only partially specified.

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

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

States a specific verb (Export) and resource (cjdb objects) with an explicit output format (CityJSONSeq) and an optional post-step (collect into a CityJSON file). The 'from cjdb' phrasing distinguishes it from the file-oriented cityjson_export sibling, though no sibling is named outright.

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

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

The 'all objects or a read-only SELECT-defined subset' phrasing implies the choice between omitting and supplying the query parameter, which is useful context. However, it gives no guidance on when to prefer this over cityjson_export, cityjson_query, or cityjson_subset, and no prerequisites or exclusions.

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

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

With zero annotations the description carries the full burden, and it does disclose the real pipeline (cjio conversion to CityJSONSeq before cjdb ingest) plus an authentication requirement: the password must come from the PGPASSWORD environment variable rather than arguments. It says nothing about what tables/rows are created, whether existing data is overwritten, or how failures are handled, which matters for a write-to-database 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?

Two short sentences, front-loaded with the conversion/import pipeline and followed by the credential constraint. Nothing is padded, though the auth note could have been folded into a fuller usage sentence.

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

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

For a tool that converts and writes data into a database with no annotations and no output schema, the description covers the what and the auth mechanism but leaves the agent guessing about index parameters, target table naming, and idempotency. Adequate as a starting point, but not sufficient for confident 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 25%, so the description must compensate, and it does not: attribute_indexes and partial_attribute_indexes are undocumented in both places, and the nested connection fields (host, user, database, schema) carry no descriptions. The only parameter-adjacent information is the negative statement that no password argument exists, which is useful but narrow.

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 specific verbs and resources: convert the dataset to CityJSONSeq with cjio, then import it into PostgreSQL/PostGIS using cjdb. That distinguishes it from generic siblings like cityjson_import or cityjson_save because it names the exact target and toolchain, though it never explicitly contrasts itself with cityjson_import or cityjson_db_export.

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

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

There is no explicit when-to-use guidance and no stated alternatives, so the agent has to infer that this (rather than cityjson_import or cityjson_export) is the path to a PostGIS database. The PGPASSWORD note is an operational prerequisite, not 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?

With no annotations supplied, the description carries the full burden and does add meaningful behavior: the transport differs by client type (web host streams a managed file; standalone MCP clients get an embedded application/json resource) and output is bounded by a configured inline-size limit. It does not disclose what happens when the inline-size limit is exceeded, whether the dataset is mutated or consumed, or permission requirements.

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, zero waste: purpose is front-loaded and the mode-dependent delivery behavior follows immediately. No repetition of schema content and no filler.

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

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

Given no annotations and no output schema, the description does well to explain the two delivery modes and the size bound. It is still incomplete on error behavior at the inline-size limit and on whether the download alters or finalizes the dataset, both of which matter for a no-annotation 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 description coverage is 100%, so both parameters (dataset_id and filename) are already fully documented in the schema. The description adds no per-parameter meaning beyond the schema, 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 gives a clear verb+resource ('prepare ... dataset for download') and ties it to the open/transform siblings that produce the dataset. It never distinguishes itself from the other output-path siblings (cityjson_export, cityjson_save, cityjson_db_export), so an agent cannot tell download vs export vs save from this text alone.

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

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

'An opened or transformed dataset' implies the prerequisite workflow (open/import/transform first), which is useful context. But there is no explicit when-to-use versus the many export/save siblings, and no exclusions or failure guidance, so selection remains partly inferred.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses very little. It does not say that a file is written to disk at the destination path, whether existing files are overwritten, what 'sloppy' changes, or whether the in-memory dataset is modified or consumed. For a tool that produces files in five different formats these are meaningful gaps.

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

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

A single compact sentence with no padding; the resource and the format set are front-loaded. It is terse to the point of under-specification, but that is a completeness problem rather than a verbosity one.

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?

Four parameters, three of them required, no annotations, and no output schema to describe what comes back. An agent must guess the meaning of 'destination' and 'sloppy' and cannot know how this differs from the save/download/db_export siblings. The definition is not sufficient for reliable invocation.

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

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

Schema coverage is only 25%: only dataset_id has a schema description. The description lists the format values (already fully captured by the enum) but explains nothing about destination (a path? a directory? a remote target?) or sloppy (tolerance for invalid geometry?). With low coverage the description should compensate and does 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?

States a specific verb (Export) and resource (an opened CityJSON dataset) and enumerates the supported output formats, which maps directly to the format enum. It does not differentiate itself from close siblings such as cityjson_save, cityjson_download, or cityjson_db_export, so an agent cannot tell from this text alone which export path to pick.

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

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

The phrase 'an opened CityJSON dataset' implies a prerequisite (cityjson_open / cityjson_import must have run first), which is useful. But there is no explicit when-to-use vs. cityjson_save, cityjson_download, or cityjson_db_export, and no statement of when this tool is the wrong choice.

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

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

No annotations are present, so the description carries the burden. The phrase 'Fetch ... from the canonical ... URL' conveys a read-only remote retrieval and identifies the source. It doesnot, however, disclose behavior on invalid versions, missing extensions, or the exact returned representation, which would make the behavior more transparent.

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

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

The description is a single, focused sentence with no filler. The action and target are front-loaded, and the canonical URL is supplied as useful context without excess detail.

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

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

This is a low-complexity retrieval tool, and the required parameters and their formats are fully specified by the input schema. However, with no annotations and no output schema, the description is missing explicit return-value or error behavior guidance, so an agent must infer what the tool returns and how failures are signaled.

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

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

Schema description coverage is 0%, and the description does not explain the semantics of 'name' or 'version'. The parameter names are self-explanatory and the JSON Schema patterns define valid formats, but the tool description itself adds no meaning beyond what the schema already provides.

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

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

The description identifies a specific verb+resource: fetching a registered CityJSON Extension schema from the canonical registry URL. The title and description align, and the resource is concrete enough to distinguish this from most sibling tools. However, it does not explicitly contrast itself with cityjson_extensions_registry, which is the closest sibling for registry operations.

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

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

The canonical registry URL and 'registered Extension schema' imply that this tool should be used when an agent needs a specific schema by name and version. There is no explicit statement about when to prefer cityjson_extensions_registry or other schema-related tools, nor any exclusionary guidance, so the usage context is implied rather than explicit.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It states 'Fetch' (suggesting a read operation) but does not describe output format, truncation behavior, registry size, rate limits, or any side effects. The max_chars parameter hints at length control, but the description does not explain how the tool behaves around 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 a single sentence with no filler, and it front-loads the core purpose. It is efficient for a simple fetch tool, though the optional clause could be slightly more precise about what 'context' means.

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

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

For a tool with no output schema and no annotations, the description should explain what the response contains and how the parameters affect it. It does not mention the output type, what the returned context looks like, or how max_chars caps the result, leaving important details for the agent to discover.

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

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

Schema description coverage is 0%, so the description needs to compensate for documenting parameters. It only partially covers 'query' by referring to 'a search term,' but max_chars is completely unexplained. The description adds minimal meaning beyond the schema's raw property names.

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 has a specific verb ('Fetch') and a clear resource ('official CityJSON Extensions registry'), and the optional search-term context clarifies a distinct feature. However, it does not explicitly contrast with sibling tools like cityjson_extension_schema, so differentiation relies on inference.

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

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

The description implies the tool is for browsing the registry and optionally searching within it, but it gives no explicit guidance about when to use this tool versus alternatives. There is no mention of when not to use it or how it relates to sibling registry/extension tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that a new filename is returned, implying a non-destructive transformation, but says nothing about whether the original dataset remains available, whether the operation can fail on mixed-LoD input, or whether there are performance or size constraints. For a transformation tool with zero annotation coverage, this is a significant gap.

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

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

Two short sentences, front-loaded with the core action and followed by the return behavior. There is no wasted wording, though the brevity contributes to the gaps in other dimensions rather than being a structural flaw.

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 a dataset transformation with two required parameters, no output schema, and no annotations. The description omits the lod value format, whether the original dataset is preserved, and how the returned filename relates to other sibling tools. It is not complete enough for an agent to call this tool confidently without inspecting the schema and inferring behavior.

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%: dataset_id is documented in the schema, but lod has no schema description. The tool description does not explain the accepted LoD format (for example '2.2' or '1.2') or whether multiple LoDs can be retained. With half the parameters undocumented and the description adding no parameter meaning, the description fails to compensate for the 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 verb and resource: keep only one level of detail from a CityJSON dataset, implemented via cjio lod_filter. It also states the result is a new filename, which distinguishes it from in-place transforms. It stops short of differentiating itself from sibling transformations such as cityjson_subset or cityjson_clean_vertices.

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 like cityjson_subset (which may also filter by attributes) or the other transformation tools. Prerequisites are unstated, and the agent is not told what happens to the original dataset or whether the output must be fed into a subsequent tool.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful behavior: the bounding box is computed in real-world coordinates from referenced vertices rather than stored. It says nothing about error behavior for an unknown object_id, whether the object must belong to an already-opened dataset, or whether geometry/children/parents are included in 'complete'.

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

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

A single front-loaded sentence with no filler; the primary return value leads and the secondary computed value follows. Nothing in it is redundant.

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 two-parameter read tool with no annotations and no output schema, the description covers what is returned but leaves the object_id contract and failure modes unexplained. Adequate as a minimum, but an agent could still call it with a malformed id and be surprised.

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%: dataset_id is described in the schema (including where handles come from), but object_id has only a minLength constraint and no description. The description does not compensate at all — it never clarifies that the identifier is a CityJSON object id or what form it takes.

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

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

States a specific verb and resource ('Return one complete CityObject') with an explicit scope of exactly one object, which implicitly contrasts with the listing/query siblings. It also names a second output (a computed real-world bounding box), giving a precise picture of what comes back. It stops short of naming a sibling such as cityjson_list_objects or cityjson_query as the alternative.

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

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

There is no when-to-use or when-not-to-use guidance and no alternative tool is named. An agent must infer from the name alone that this is the single-object fetch versus list/query, and nothing states prerequisites such as whether the dataset must first be opened.

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

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

With no annotations supplied, the description carries the full behavioral burden. It discloses the key precondition (file must already exist in the inbox) and the return value (the filename), but says nothing about what happens on filename collision, whether the file is moved or copied, permissions/configuration requirements, or error behavior when no file or multiple files are present. These are meaningful gaps for a registration mutation.

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 action and return value, followed by the client-type qualifier and the fallback condition. No filler, no redundancy with the title, and each sentence carries distinct 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 two-parameter, no-output-schema tool, the description covers purpose, the intended client type, and the single precondition for the optional-parameter path. The remaining gap is failure-mode behavior (collisions, multiple/no files), which an agent would likely need to handle gracefully.

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 both parameters are already documented, which sets the baseline at 3. The description adds one piece of real semantics beyond the schema: omitting filename requires the inbox to contain exactly one JSON file. It does not mention display_filename, leaving that entirely to 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 a specific verb and resource: "Register a CityJSON file already placed in the configured input inbox and return its filename." That clearly separates it from the upload family (cityjson_upload, cityjson_upload_start, cityjson_upload_chunk) by placing the file in an inbox rather than transferring bytes. It stops short of naming those siblings explicitly, so the differentiation is implied rather than spelled out.

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 a clear selection condition: "This is for clients with an upload bridge, such as Datum," which tells an agent when this path applies instead of a direct upload tool. It also states the precondition for omitting filename (exactly one JSON file in the inbox). What is missing is an explicit pointer to the alternative tool for clients without an upload bridge.

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

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

No annotations are supplied, so the description must carry behavior. It does disclose two useful traits: the original filename is preserved and validation of completeness is the caller's responsibility ('complete' document required). It says nothing about what the import produces, whether it mutates workspace state, or how errors on malformed JSON surface.

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 action and scope, followed by the preservation behavior and the fallback route. No filler and nothing repeated from the title.

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 two-parameter import tool with a fully documented schema and no output schema, the description covers what to supply, the size boundary, and where to go otherwise. The remaining gap is what happens after import (does it open, list, return an id), which a sibling like cityjson_list_imports or cityjson_open implies but the description never states.

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

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

Schema coverage is 100% and both parameters are described in the schema, including the 200-char cap and default filename, so the baseline is 3. The description adds only the 'complete CityJSON document' requirement for content and the filename-preservation intent, not format details or size limits beyond 'small'.

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

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

States a specific verb and resource (import a small complete CityJSON document already available as text) plus the scope constraint 'small', and explicitly differentiates from the sibling cityjson_upload for missing/incomplete/large cases.

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?

Explicitly names the alternative (cityjson_upload) and the exact conditions that select it: missing, incomplete, or large attachments. It also indicates the positive case — a complete document plus a small chat attachment — so routing 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?

No annotations are supplied, so the description carries the full behavioral burden. It implies a read via 'Return', but never states that the call is non-destructive, has no side effects on the dataset, or whether it is expensive on large files. Beyond listing the fields returned, it discloses nothing about the operation's behavior.

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

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

A single sentence with the action front-loaded and every element of the returned payload enumerated; nothing is redundant or padded.

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, and does, enumerate what comes back (metadata, counts, types, LoDs, attributes, transform, extensions). For a one-parameter read tool this is nearly complete; only the read-only/non-destructive guarantee and the open-first prerequisite are missing.

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

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

With one parameter and 100% schema description coverage, the schema already explains that dataset_id is a filename from cityjson_open/import or a transformation handle. The description adds only the 'opened dataset' framing, which is a marginal restatement rather than new meaning.

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

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

A specific verb (Return) plus the exact resource (metadata for an opened dataset) and an enumerated payload: object counts, types, LoDs, attribute names, transform and extensions. An agent can distinguish it from cityjson_list_objects or cityjson_get_object, though the description never names those siblings to sharpen the distinction.

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

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

Usage is only implied by the phrase 'for an opened dataset', which hints at the prerequisite that cityjson_open/import must run first, but this is never stated as a condition. No guidance is given on when to prefer this inspection call over cityjson_list_objects, cityjson_query, or cityjson_backend_status.

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

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

No annotations are provided, so the description carries the burden, and it does disclose what the tool returns: 'Returns filenames only.' It alsotells the agent to never ask for an absolute path, which is useful interaction behavior. It could go slightly further by noting side-effect-free behavior, but the word 'list' plus the return statement make the safety profile reasonably clear.

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

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

Two short sentences, with the core purpose first, then usage conditions, then a user-interaction constraint. Every sentence adds value; there is no boilerplate or redundant text.

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 an zero-parameter list tool with no output schema, this description is complete: it specifies the source (configured input inbox), the scope (JSON files), the return content (filenames only), the trigger conditions, and an explicit interaction constraint. Nothing critical is missing for an agent to select and invoke it correctly.

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

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

The tool has zero parameters, and the input schema is an empty object, so the schema fully covers the parameter surface. The description appropriately adds no unnecessary paramter detail; the baseline of 4 for a zero-parameter tool applies.

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

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

The description states a specific verb and resource: 'List JSON files in the configured input inbox.' This clearly distinguishes the tool from siblings like cityjson_open or cityjson_import by indicating it is a listing operation over the input inbox, not an open/import action.

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

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

It explicitly says when to use the tool: 'when the user did not name an attached/imported file or when cityjson_import reports multiple candidates.' It also instructs against asking for absolute paths, giving the agent clear behavioral guardrails. This is strong usage guidance for a simple listing tool.

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

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

No annotations are provided, so the description carries the full burden. Calling it 'List' implies a read-only enumeration and 'pagination' signals result paging, but it omits the default page size of 100, the 5000 cap, and what 'selected attributes' actually means (which attributes, decided by whom). Read-only behavior and pagination are implied rather than stated.

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

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

Two short sentences with no filler, and the resource plus returned fields are front-loaded before the optional capabilities. No restructuring needed; only the vague phrase 'selected attributes' wastes a little space.

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 is the only source of return-value information, and it lists the returned field categories but not their shape or nesting. For a payload-listing tool with three undocumented parameters and no annotations, it covers the essentials but leaves meaningful 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 25% — only dataset_id is documented in the schema. The description partially compensates by tying filtering to CityObject type (types) and mentioning pagination (limit/offset), but gives no format, defaults, or range guidance for any of the three undocumented parameters. That earns above-baseline but not full credit.

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

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

Names a specific verb (List) and resource (CityObjects) and enumerates what each entry carries (IDs, types, attributes, LoDs). It is not explicitly differentiated from siblings like cityjson_query or cityjson_get_object, but the enumeration of returned fields makes the tool's role recognizable.

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 notes type filtering and pagination exist, but never says when to reach for this tool instead of cityjson_query, cityjson_filter_lod, or cityjson_get_object for a single object. An agent must infer the use case from the tool name alone.

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

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

No annotations are supplied, so the description carries the full disclosure burden. It does reveal two useful traits — inputs must already be opened and the result is a new filename (inputs presumably untouched) — but says nothing about ordering effects, CRS/metadata conflicts between datasets, or what happens on incompatible inputs.

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

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

Two short sentences, zero filler, with the action front-loaded and the return value appended last. It is efficient but borders on under-specified rather than optimally 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 one-parameter tool with no output schema, telling the agent the return value is a filename is valuable and largely sufficient structurally. The gaps are behavioral — conflict handling and input-mutation semantics — which matter for a merge operation but are not addressed.

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 reported as 0% at the property level, and the description never mentions the single parameter 'dataset_ids' or its semantics such as ordering or minimum count. The only help comes from the nested items description in the schema itself, not from the description.

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

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

States a specific verb and resource ('Merge two or more opened CityJSON files') plus the engine (cjio), which is unambiguous and no other sibling performs merging. It doesn't name a contrasting sibling, but none exists, so an agent can still place it correctly in the toolset.

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

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

The phrase 'opened CityJSON files' implies the prerequisite that inputs must come from cityjson_open/import first, which is real usage guidance. However, there is no statement of when to merge versus e.g. cityjson_subset or cityjson_db_import, and no exclusions or failure conditions.

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

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

With no annotations, the description carries the full behavioral burden and does disclose two non-obvious traits: the server snapshots the file, and the return value is a filename used by later tools. It stops short of stating whether the snapshot persists, whether it is read-only, or any error conditions.

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 action and source options, then the snapshot/return behavior. Every clause adds information and nothing is padded.

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 single-parameter tool with no annotations and no output schema, the description covers what the tool does, where it looks, and what it returns. Missing only error/failure behavior and explicit confirmation that the snapshot does not mutate the original.

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

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

Schema coverage is 100% and the single 'source' parameter already documents all three resolution modes, so the description largely restates it. Baseline 3 is appropriate for a fully documented one-parameter schema.

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

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

States a specific verb and resource (open a CityJSON file) and enumerates the three accepted source forms (filename, relative path, full server-visible path). It separates itself from the upload family implicitly but never names a sibling, which keeps it short of a 5.

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

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

The 'optional configured project or data folder' phrasing hints at context, and the schema description routes attached files to cityjson_upload. However, the description itself gives no explicit when-to-use/when-not guidance against the many upload and import siblings (cityjson_import, cityjson_upload_start, etc.).

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

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

With no annotations supplied, the description carries the full behavioral burden and discloses very little. It never states that this is a read-only operation, how results are ordered or paginated, that results are capped (limit default 100, max 5000), or whether filters combine with AND semantics. 'Natively' is the only hint about execution mode and is left unexplained.

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

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

Two tight sentences, front-loaded with the capability and followed by the operator list an agent needs to build a predicate. No filler, though the second sentence could have been spent on behavioral detail rather than an operator enumeration alone.

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 seven-parameter, nested-object query tool with no annotations and no output schema, the description is thin. It omits prerequisites (dataset must be opened first), result shape, pagination/limit behavior, and predicate combination semantics, leaving real gaps an agent would hit on first 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 coverage is only 29% across seven parameters, so the description must compensate; it does so partially by naming ids, types, bbox and attributes, and by enumerating the supported attribute operators (eq, neq, gt, gte, lt, lte, contains, in), which the schema does not spell out. However, limit, offset, and how the attributes object maps keys to operators are undocumented in both places.

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

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

States a specific verb and resource ('Query CityObjects') and enumerates the four filter dimensions (IDs, types, 2D bbox, attribute predicates), which clearly delimits what the tool can select. It does not name or contrast with close siblings such as cityjson_list_objects, cityjson_get_object, or cityjson_subset, so the agent must infer the boundary.

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

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

There is no explicit when-to-use guidance, no statement of when-not-to-use, and no named alternatives. An agent cannot tell from the description whether this supersedes cityjson_list_objects or cityjson_subset, nor whether it requires that a dataset already be open.

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

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

With no annotations supplied, the description carries the full behavioral burden. It discloses that the operation returns a new filename, which usefully implies a non-destructive output pattern, but it does not state whether the original dataset is modified, whether the operation is reversible, or what permissions are required for this mutation.

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 wasted words, and the primary action is front-loaded ahead of the return behavior.

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 single-parameter mutation tool without an output schema, the description is minimally adequate: it names the operation and the return type. However, it omits behavioral details that matter for a destructive transformation, such as whether the original data is preserved and how the result should be used downstream.

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

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

Schema description coverage is 100% for the single dataset_id parameter, so the schema already explains its source and compatibility. The description adds no parameter-specific detail beyond what the schema provides, making the baseline of 3 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 — 'Remove all materials with cjio' — which is clear and distinguishable from most siblings. However, it does not explicitly differentiate itself from the closely related cityjson_remove_textures sibling, leaving some ambiguity about which removal tool to choose.

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

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

There is no guidance on when to use this tool versus alternatives such as cityjson_remove_textures or cityjson_attribute_remove. The description gives no context about prerequisites, when-not-to-use conditions, or workflow placement.

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

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

No annotations exist, so the description carries the full burden. It does disclose one genuinely useful behavioral fact — the operation returns a new filename rather than mutating in place — but says nothing about whether the source dataset survives, whether removal is reversible, or what happens on a textured-less input.

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

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

Two short sentences, the action front-loaded and the return value second; nothing is wasted. The brevity is efficient but leaves the gaps noted in other dimensions.

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 single-parameter tool with no output schema, the definition covers the action and the shape of the return (a filename). It omits the fate of the input dataset and any preconditions, which an agent would want before chaining into a subsequent call.

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

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

Only one parameter (dataset_id) with 100% schema description coverage that already explains accepted filename provenance and internal handles. The description adds no further meaning about the identifier, which is acceptable at this coverage level.

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

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

States a specific verb and resource ("Remove all textures") plus the engine used (cjio), which clearly separates it from siblings like cityjson_remove_materials or cityjson_attribute_remove. It does not explicitly name those near-neighbours, so the differentiation is inferable rather than stated.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the closest alternatives (remove_materials, attribute_remove). An agent must infer from the name alone that this is a strip-textures step rather than a general cleanup.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It usefully discloses the underlying engine (cjio) and that the result is a new artifact ('Returns a new filename'), implying the input dataset is not mutated in place. It stops short of stating failure behavior when no CRS is present, whether intermediate datasets accumulate, or how the new file relates to the original dataset_id.

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 action before the precondition and the return value. Every clause carries information and nothing is redundant.

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 coordinate-transforming mutation tool with no annotations and no output schema, the definition covers the core action, the precondition, and the return shape. It leaves gaps on how the undocumented 'digit' parameter behaves, what happens to the source dataset, and how errors surface when the CRS is missing.

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

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

Schema coverage is only 33%, so the description must compensate. It effectively explains 'epsg' as the target CRS and hints that 'dataset_id' is a filename handle ('Returns a new filename'), which aligns with the schema note. The 'digit' parameter receives no explanation at all in either the schema or the description, leaving one of three parameters opaque, which caps this below 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 gives a specific verb and resource ('Reproject coordinates to a target EPSG CRS') and names the engine ('with cjio'), so the operation is unambiguous. It does not explicitly contrast itself with near-siblings like cityjson_assign_crs or cityjson_translate, which is the only thing keeping it from a 5.

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

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

One real prerequisite is stated: 'The source file must already define a CRS,' which tells the agent a precondition for calling. However there is no guidance on when to choose this over cityjson_assign_crs (which sets a CRS) or cityjson_translate (which shifts coordinates), and no mention of what to do if the precondition fails.

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

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

No annotations are supplied, so the description carries the full behavioral burden. 'Copy' usefully implies the source dataset is left intact, but it says nothing about what happens when the destination already exists, how the overwrite flag (default false) behaves, required permissions, or whether the destination must be inside a server-managed directory.

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

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

A single front-loaded sentence with no filler; the verb and target come first. It is efficient, though it is arguably too terse for a write operation with an undocumented overwrite flag.

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

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

This is a filesystem-writing tool with three parameters, no annotations, no output schema, and low schema description coverage, so the description should explain overwrite behavior and return value. Instead it gives one sentence, leaving the agent guessing about the overwrite default's effect and failure modes.

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 33%: dataset_id is documented in the schema, while destination and overwrite are bare. The description re-states that the destination is an explicit path but adds no path format, relative-vs-absolute rules, or overwrite semantics, so the undocumented parameters remain unexplained in both places.

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

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

The description names a specific verb ('Copy') and resource ('opened/derived CityJSON dataset') and states the output target ('explicit destination path'), so the agent can picture the operation. It does not differentiate itself from close siblings such as cityjson_export, cityjson_db_export, or cityjson_download, which also move dataset content out.

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

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

There is no guidance on when to use this versus cityjson_export, cityjson_download, or cityjson_db_export, nor any stated prerequisites beyond 'opened/derived'. The agent must infer the selection rule from the word 'explicit destination path' alone.

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

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

With no annotations, the description must carry the behavioral burden. The verb 'Fetch' clearly indicates a read-only retrieval operation, and 'canonical ... JSON Schema' identifies the domain. It does not describe the response shape, error behavior, or whether the raw JSON is returned directly, but these are low-risk details for a simple fetch.

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

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

The description is a single, tightly worded sentence with no wasted content. It front-loads the action, resource, version, and selection method immediately.

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 tool with an enum and default in the schema, the description is mostly sufficient: it tells the agent what is fetched and how selection works. It lacks explicit return-value or usage-context details, and there is no output schema, but the low complexity makes this an acceptable 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 0%, and the description adds only 'by name', which is minimal. However, the single 'name' parameter is fully constrained by an enum and a default in the input schema, so the parameter is still unambiguous. The description adds modest context by framing these as canonical CityJSON 2.0.2 schemas, but does not explain how to choose among the enum 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 states a specific verb ('Fetch'), exact resource ('one canonical CityJSON 2.0.2 JSON Schema'), and selection mechanism ('by name'). The 'canonical' qualifier helps distinguish this from related schema or specification tools.

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

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

No explicit usage guidance is provided, and no alternative tools are named. The phrase 'canonical CityJSON 2.0.2' implies official schemas, but the agent is left to infer when to choose this over sibling tools like cityjson_extension_schema or cityjson_spec_read.

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

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

With no annotations, the description carries the full behavioral disclosure burden. 'Return' clearly signals a read-only information retrieval operation, and 'bundled' implies the data is local rather than fetched remotely. It identifies what is returned without detailing exact formatting, but for a zero-parameter informational tool that is sufficient.

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

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

One sentence with no redundant phrasing; the verb and object are front-loaded so an agent immediately knows what the tool does. Every word earns its place.

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

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

Given the low complexity, zero parameters, no output schema, and no annotations, the description is nearly complete for safe invocation. It names both output components, outline and canonical URLs. A brief pointer to cityjson_spec_read for full content would improve context, but is not required for correct usage.

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

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

There are zero parameters, so the baseline is 4. The description does not need to explain parameter behavior, and the empty schema leaves nothing unknown for caller preparation.

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

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

States a specific verb ('Return') and a concrete resource: the bundled outline and canonical URLs for the current CityJSON specification and schemas. This is clearly distinct from siblings like cityjson_spec_read and cityjson_schema_read, which imply reading actual content rather than an outline and URLs.

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

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

The description implies a quick-reference retrieval use, but there is no explicit when/when-not guidance or mention of alternatives. An agent is not told to choose this over cityjson_spec_read or cityjson_schema_read, though the purpose makes the intended context reasonably inferable.

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

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

The description conveys a read-only operation and the conditional behavior based on whether a query is supplied. With no annotations and no output schema, though, it does not explain how max_chars affects the returned text, what format the text takes, or how the context window is determined.

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

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

The description is a single front-loaded sentence with no filler. It efficiently covers the source, version, and two output modes without wasting words.

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

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

For a simple read tool this is mostly adequate, but it leaves gaps around max_chars semantics, output format, and how this relates to sibling spec tools. The absence of annotations and an output schema increases the burden on the description, and those gaps remain.

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 query parameter gains some meaning from 'context window around a search query' and 'beginning' when absent. However, max_chars is not mentioned at all, and with 0% schema description coverage, the agent must infer its behavior solely from the parameter name and constraints.

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

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

The description states a specific action ('Fetch'), a specific resource ('canonical CityJSON 2.0.2 living specification'), and a clear output behavior (beginning or context window around a search query). This distinguishes it from sibling tools like cityjson_spec_outline and cityjson_schema_read, which target other spec artifacts.

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

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

The use case is implied: retrieve spec text, optionally near a search query. However, the description never states when to choose this over cityjson_spec_outline or cityjson_schema_read, and it provides no exclusions or alternative conditions.

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

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

No annotations are supplied, so the description carries the full disclosure burden. It does usefully state that the output is a derived dataset plus a new filename, implying the source dataset is not destroyed, but it is silent on whether selectors combine or are mutually exclusive, what happens when nothing matches, and what 'exclude' inverts.

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 action and followed immediately by the return value. 'with cjio' is implementation detail, but it is short and the rest of the text earns its place 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?

For a 7-parameter, mutation-style operation with no annotations and no output schema, the description covers the return value ('a new filename') but leaves selector interaction rules and the non-destructive guarantee implicit. It is adequate to attempt a call but not complete enough to guarantee a correct one.

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

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

Schema description coverage is only 29% across 7 parameters, so the description must compensate. It does name five of the seven selector parameters (ids, bbox, radius, random, types), which adds meaning over their bare types, but it never explains 'exclude', the mutual exclusivity of selectors, or the required dataset_id contract.

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

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

States a specific verb+resource ('Create a derived CityJSON subset') and enumerates the five selection modes (IDs, bbox, radius, random count, CityObject types). It is clear what the tool produces, though it does not name any sibling it supersedes or contrasts with, so an agent must infer the boundary against cityjson_filter_lod or cityjson_query.

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 enumeration of selection criteria implies the situations the tool is for, but there is no explicit when-to-use / when-not-to-use framing and no named alternative. An agent can guess that this is the extraction tool, but cannot tell from the text whether it should prefer this over cityjson_query or cityjson_filter_lod.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose genuinely non-obvious behavior — that citygml-tools performs the conversion and that the installed version determines the default target encoding — but it says nothing about what artifact is produced, where it lands (output_directory), whether the source dataset is consumed or preserved, or what happens on failure.

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

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

Two short sentences, front-loaded with the action and resource, with no filler. It is efficient, though its brevity is part of why other dimensions are under-specified.

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

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

With no annotations, no output schema, and two of three parameters undocumented, the definition is thin for a conversion tool. An agent cannot tell what the call returns (a file path, a dataset handle, or an inline GML payload) or what crs_name/output_directory do, which is required information to invoke it correctly.

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

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

Schema description coverage is only 33%: dataset_id is documented, but crs_name and output_directory are undocumented in both schema and description. The description never mentions reprojection/crs handling or output location, so it fails to compensate for the coverage gap; only the encoding remark loosely touches target-format behavior.

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

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

The description gives a specific verb and resource pair ('Convert an opened CityJSON dataset to CityGML') plus the underlying engine (citygml-tools). The direction of conversion distinguishes it implicitly from the reverse-direction sibling citygml_to_cityjson, though it never names that sibling or cityjson_export 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?

Usage is only implied: the word 'opened' hints that a dataset must first be opened via cityjson_open/cityjson_import, and the conversion direction makes the general use case obvious. There is no explicit guidance on when to choose this over cityjson_export or how it differs from the reverse converter, and no stated preconditions or exclusions.

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

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

No annotations exist, so the description carries the full behavioral burden. It discloses the two coordinate-shift modes, but says nothing about whether the dataset is mutated in place or a new dataset handle is returned, what the response looks like, whether repeated application compounds the shift, or what units/axis order are assumed.

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

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

Two short sentences with the action front-loaded and no filler; the conditional minxyz behavior is packed into the single follow-on clause. Slightly compressed phrasing ('with minxyz ... without it') costs a little clarity but nothing is wasted.

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

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

For a parameterless-annotation, no-output-schema mutation tool, the description leaves out the most decision-relevant facts: in-place vs returned dataset, effect on the dataset_id handle, and coordinate conventions. Given the complexity of geometry transformation, this is under-specified.

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

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

Schema coverage is 50%: dataset_id is documented in the schema, while minxyz is not, and the description does compensate by explaining that minxyz defines the shift origin versus defaulting to the model minimum. It still does not specify the coordinate ordering, units, or CRS implications of the three-element array.

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

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

States a specific verb and resource ('Translate CityJSON coordinates') and names the underlying engine (cjio), so an agent can tell it apart from siblings like cityjson_reproject or cityjson_clean_vertices. It stops short of explicitly contrasting itself with those siblings, so it is clear but not fully differentiated.

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

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

The description implies when to use it (coordinate shifting/minimum-normalization) and explains the two operating modes via minxyz. It gives no explicit when-not guidance and never mentions the nearby alternatives cityjson_reproject or cityjson_assign_crs, which an agent could easily confuse with a coordinate transform.

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

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

No annotations are supplied, so the description carries the full burden. It does not say whether triangulation mutates the dataset in place or produces a new dataset handle, whether it is reversible, whether textures/materials survive it, or how expensive it is — critical omissions for a geometry-mutating 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?

Two short sentences, action first and parameter caveat second, with no redundant restatement of the name or title. Nothing could be removed without losing 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?

With no annotations and no output schema, the definition should cover mutation semantics and result handling, and it does neither. For a geometry-rewriting tool the agent is left guessing whether the dataset_id stays valid after the call and what the response looks like.

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%: dataset_id is documented in the schema, while sloppy has no schema description. The description compensates by explaining what sloppy means functionally (a less robust fallback path) and when to enable it, which is meaningful context beyond the boolean 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 names a specific verb and resource ('Triangulate surfaces') and identifies the underlying engine ('with cjio'), so an agent knows exactly what operation is performed. It does not, however, distinguish this tool from neighbors that also alter geometry (e.g. cityjson_clean_vertices, cityjson_filter_lod), so sibling differentiation is absent.

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 one explicit conditional: 'Use sloppy=true only when the robust triangulator fails', which correctly frames sloppy as a fallback. However, there is no guidance on when triangulation itself is needed versus other geometry operations, and no prerequisites (e.g. valid geometry, suitable LoD) are stated.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it never says whether the upgrade mutates the referenced dataset in place, produces a new dataset_id, or leaves the original intact. It also omits whether the call fails on already-current files and what error or return the agent should expect after a mutation-style 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?

A single front-loaded sentence with no filler; the key constraint (older supported version) appears before the target version. It is arguably terse to a fault, but nothing is wasted or buried.

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

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

With no annotations, no output schema, and a write-like operation, the definition leaves the agent guessing about the outcome: in-place mutation versus new dataset handle, preservation of the source file, and failure behavior. For an upgrade/migration tool that is a meaningful completeness 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 coverage is 100% and the single dataset_id parameter is fully documented in the schema, including its origin from cityjson_open/import and handle compatibility. The description adds no further semantics about that parameter, so the baseline of 3 applies when the schema does the work.

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

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

The description names a specific verb and resource ('Upgrade ... CityJSON file') and bounds the scope to 'older supported' inputs targeting the version of the installed cjio. That is enough to distinguish it from validation, export, save, or format-conversion siblings, though no sibling is named 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?

Use is implied by the phrase 'older supported CityJSON file', which tells the agent this is for outdated data rather than fresh imports. However, there is no explicit when-not guidance, no mention of what to do for unsupported versions, and no stated alternative such as re-importing the source.

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

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

With no annotations supplied, the description carries the full disclosure burden and does more than most: it states the interaction happens in-chat via a picker, that the bytes are streamed 'outside the model context,' and that no project folder or workspace setup is required. What it omits is the outcome side — whether the call blocks on user selection, what happens if the user cancels, and whether the file becomes server-visible afterwards.

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

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

Four short sentences, front-loaded with the action, then the when-to-use condition, then the transfer mechanics. Nothing is padding, though the workspace/setup sentence is the weakest and could be folded into the transfer note.

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

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

There is no output schema and no annotations, so the description is the only source of truth, and it stops short of saying what the call returns or what state the file lands in (upload handle, server-side object, or nothing). For an interactive UI-triggering tool that is a meaningful hole, even though the interaction model and precondition are 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?

Schema coverage is 100% for the single parameter, so the baseline is already high. The description still adds purpose the schema lacks justification for: the question is 'passed' so 'the app can continue after upload,' explaining why a question string accompanies a file transfer. It could have added whether the question is required in practice despite being optional.

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 and resource: 'Open an in-chat file picker to upload a CityJSON file directly.' An agent immediately knows this is an interactive upload entry point rather than a server-side ingest. However, it never distinguishes itself from the closely named siblings cityjson_upload_start/_chunk/_finish or from cityjson_import, so the boundary has to be inferred.

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 an explicit triggering condition: 'Use this when the user attached or wants to choose a file that is not visible to the MCP server.' That is a real discriminator against server-visible import paths. The gap is that the chunked-upload siblings are never mentioned as alternatives or as a follow-on chain, leaving the agent to guess whether this single call replaces that flow.

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

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

With no annotations, the description carries the full behavioral burden. "Discard" hints at a destructive operation, but it never states whether the upload and its uploaded chunks are permanently removed, whether the action is reversible or resumable, whether special permissions are needed, or what error occurs for an invalid or already-finished upload.

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

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

A single short sentence with zero filler, and the key concept (discard an unfinished upload) is front-loaded. It is efficient but borders on under-specified rather than being 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 destructive, annotation-free cancel operation with an undocumented required parameter and no output schema, the description leaves out essential context: irreversibility, the origin of upload_id, and expected outcomes. An agent could invoke it but cannot predict its side effects.

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

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

Schema description coverage is 0%, so the only parameter, upload_id, has no documentation anywhere beyond its name and UUID format. The description does not explain where an agent obtains the upload ID (presumably from cityjson_upload_start) or that it must reference a still-open upload.

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

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

The description names a specific verb and resource ("Discard an unfinished CityJSON upload"), which cleanly separates it from siblings like cityjson_upload_finish and cityjson_upload_chunk. It stops short of naming those alternatives explicitly, but the intent is unambiguous.

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

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

Usage is only implied: the qualifier "unfinished" signals the tool applies to an in-progress upload, so an agent can infer it is not for completed uploads. There is no explicit statement of when to choose cancel versus finish, or what happens if the upload is already complete.

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

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

With no annotations, the description carries the full burden of explaining behavior, but it only weakly implies a stateful upload operation. It does not disclose sequencing requirements, retry or idempotency behavior, offset validation, chunk limits in practical terms, error handling, or what server-side state is changed.

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

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

The single short sentence is direct and front-loads the operation without filler. Its brevity comes at the cost of essential protocol details, and the file-picker wording is less precise than describing a chunk of file data.

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 stateful chunked-upload tool with three undocumented required parameters, no annotations, and no output schema, the description is insufficient for reliable invocation. It needs the surrounding start/chunk/finish workflow, byte encoding and offset rules, and expected sequencing or response behavior.

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

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

Schema description coverage is 0%, and the description does not explain any of the three required parameters. In particular, it omits where upload_id comes from, whether bytes is base64 or another encoding, and whether offset is a byte offset that must match the accumulated upload length.

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

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

The description gives a clear action and resource: sending the next chunk of a CityJSON upload. It distinguishes the operation from starting or finishing an upload, but 'from the CityJSON file picker' is vague and does not explain the upload-session workflow.

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

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

The word 'next' implies that this is used after an upload has begun and that chunks are sent sequentially. However, it never explicitly directs the agent to call cityjson_upload_start first, repeat this tool until all bytes are sent, or use cityjson_upload_finish or cityjson_upload_cancel afterward.

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

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

With no annotations, the description carries the full behavioral burden. It states that validation and registration occur, implying mutation, but omits validation failure behavior, whether upload_id is consumed, idempotency, required permissions, and what registration changes.

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

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

A single front-loaded sentence with no redundant wording. It is efficiently sized for the information it conveys, though that information is limited.

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 side-effecting finalization tool with no annotations, no output schema, and an undocumented upload_id, the definition is too sparse. It omits workflow prerequisites, validation failure outcomes, and return/registration details.

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 single required upload_id parameter has 0% schema description coverage, and the description does not mention it or explain that it comes from the upload workflow. The UUID format is in the schema, but the semantic linkage to upload_start/chunk is missing; only the parameter name supplies meaning.

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

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

States a specific verb combination ('Validate and register') and resource ('uploaded CityJSON file'), making the tool's function clear. It does not distinguish this finalization step from sibling tools such as cityjson_validate or cityjson_upload, so it falls short of a 5.

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

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

Provides no explicit when-to-use guidance or prerequisites. It does not say that it should follow cityjson_upload_start/chunk, nor when to choose it over cityjson_validate or cityjson_upload; only the word 'finish' implies sequencing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure and provides almost none. It does not say what the call returns (presumably an upload identifier), whether the upload expires, what happens if it is never finished, or what permissions are needed. For a state-creating operation in a multi-step protocol this is a significant gap.

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

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

It is a single front-loaded sentence with no wasted words, but the brevity comes at the cost of under-specification rather than efficiency. There is no structure such as a follow-up step or return-value note to anchor the agent.

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

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

This is the entry point of a four-part upload protocol (start/chunk/finish/cancel) with two required parameters, no annotations, and no output schema. The definition omits the sequencing contract, the returned handle, and any size or format constraints, leaving the agent unable to complete the workflow from this description 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 0%, and the description mentions neither parameter. The agent must guess whether filename needs a path or just a basename, and whether size_bytes is used for validation or quota checks. Nothing is added beyond the bare property names.

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

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

The description names a specific verb ('Start') and resource ('an upload'), and 'from the CityJSON file picker' hints at the UI origin. However, it never states what distinguishes this from cityjson_upload_chunk, cityjson_upload_finish, or cityjson_upload itself, so an agent must infer that this is step one of a multi-part flow.

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

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

There is no guidance on when to use this versus the sibling upload tools, no mention that chunk/finish calls must follow, and no preconditions such as file type or size limits. The only usage hint is the word 'Start', which implies a sequence without describing 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?

With no annotations supplied, the description carries the full burden. It usefully discloses that two engines run underneath and points to geometry.reportSummary for the complete invalidObjectIds list, which is real value. But it says nothing about whether the dataset is mutated, expected runtime cost of geometric validation, or failure behavior on malformed input.

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, zero padding, and the core action plus its engine composition are front-loaded. The second sentence earns its place by warning where the untruncated ID list lives.

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 the return shape, and it only describes one nested field path (geometry.reportSummary.invalidObjectIds). The structural half of the combined result is left undescribed, leaving the agent to discover the rest of the payload by calling 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 100% and the single dataset_id parameter is already documented in the schema, including the provenance of the value ('Filename returned by cityjson_open...'). The description adds no additional meaning about the identifier, 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 names a specific verb ('Run cjval and val3dity') and resource ('structural + geometric validation'), and the word 'combined' implicitly positions it as the superset of cityjson_validate_schema and cityjson_validate_geometry. It stops short of naming those siblings, so an agent must infer the distinction from the adjective alone.

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

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

Usage is only implied: 'one combined ... result' suggests this is the full check versus the narrower sibling validators, and the follow-up mention hints at subsetting invalid objects. There is no explicit when-to-use/when-to-prefer-a-sibling statement or cost warning for running both engines.

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

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

With no annotations at all, the description carries the full behavioral burden and does disclose the return shape: a detailed report plus a compact reportSummary enumerating invalid object IDs and per-error-code counts. It never states that the operation is non-mutating/read-only or what happens on an invalid dataset, which matters when annotations are absent.

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, zero filler, and the core action is front-loaded before the return-value sentence. Nothing is redundant, though the second sentence is a dense list that could be split for scannability.

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

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

With no output schema, the description rightly spends its second sentence on return values, which covers the biggest gap. Still missing: the meaning of 'verbose', the read-only nature of validation, and any hint about runtime or limits on large datasets, which an agent needs before invoking 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 only 50%: dataset_id is documented in the schema as coming from cityjson_open/cityjson_import, and the description adds nothing to it. The 'verbose' parameter has no description anywhere yet plainly affects the reported output size, and the description misses the chance to explain it.

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

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

The description names a specific verb (validate) and resource (CityJSON 3D primitives), and pins the engine and standard: val3dity, ISO 19107, CityJSON-specific geometric checks. That scope implicitly separates it from cityjson_validate and cityjson_validate_schema, but no sibling is ever named, so the differentiation is inferred rather than 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?

Usage is only implied by the phrase '3D primitives ... geometric checks' – an agent can guess this is the geometry-check complement to schema validation, but there is no statement of when to prefer it over cityjson_validate or cityjson_validate_schema, and no prerequisite (e.g. a loaded dataset) is spelled out.

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

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

With no annotations, the description carries the full burden. It usefully discloses that validation is delegated to the official cjval validator and what categories of problems are checked, which is meaningful context. However, it is silent on whether errors are returned as a list or a pass/fail flag, whether validation is read-only, and how long a large dataset might take.

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

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

A single front-loaded sentence with no filler; the validator name and check list are the most useful information and appear immediately. Slight density in the comma list but nothing that should be cut.

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

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

No annotations and no output schema, so the description is the only source of behavioral information. It covers what is checked but leaves the caller unsure what a result looks like and how to trigger extension-aware validation, which matters for a two-parameter tool with one undocumented parameter.

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

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

Schema description coverage is only 50%: dataset_id is documented in the schema, but extension_schemas has no description. The description mentions "extensions" as something validated but never explains that the caller can supply custom extension schema identifiers or paths, so it does not compensate for the 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 names a specific verb (Validate) and resource (a CityJSON dataset) and enumerates the check classes performed: JSON syntax, CityJSON schemas, extensions, and structural consistency. This implicitly distinguishes it from cityjson_validate_geometry (geometry-only checks), though that sibling is never named 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?

Usage is only implied by the enumerated check types — an agent can infer this is the full schema-level check versus the geometry-only sibling, but there is no explicit "use this when..." or "use cityjson_validate_geometry instead for..." statement. No prerequisites (e.g., dataset must be loaded first) are stated.

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