Assetize — IBM Maximo knowledge

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that answers cite evidence with [R#] markers and URLs, that it DECLINES when the record cannot support an answer, and that it never guesses. This is rich, specific, and lets an agent predict the tool's behavior accurately.

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 tight sentences, front-loading the core purpose and evidence behavior, then adding the scope of use. Every sentence 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?

The description covers the tool's core behavior, evidence citing, and decline mechanism, and the schema fully documents parameters. It does not describe the exact return format (e.g., plain text vs structured), but given the tool's nature and the absence of an output schema, this is a minor gap. Overall it is complete enough for an agent to use correctly.

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

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

Schema coverage is 100%, and both parameters (question and version) are adequately described in the schema. The description adds no extra parameter-level detail, so the 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?

The description clearly states the tool answers IBM Maximo questions using source-backed knowledge, and it explicitly lists the question types it is best for (how-to, troubleshooting, version-behaviour, error). This distinguishes it from the more specialized sibling tools (e.g., lookup_error_code, compare_maximo_versions) that focus on single aspects.

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

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

The description gives a 'Best for' scope, implying it is not the right choice for very specific queries better handled by siblings, but it does not name any alternatives or state when NOT to use it. The guidance 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?

With no annotations, the description carries the full behavioral disclosure burden but mostly describes content categories rather than observable behavior. It implies a read-only historical lookup but says nothing about output format, pagination, limit semantics, or how records are ordered or grouped. The external 'same data' reference adds provenance, not behavioral transparency.

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

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

The description is a single compact sentence that front-loads the subject matter and avoids boilerplate. The long list of record types and the external URL are slightly vague but not redundant. Overall it is concise, though the metaphor costs some precision.

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

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

Given no annotations, no output schema, and a large sibling set, this description leaves important invocation decisions open: an agent cannot tell what the returned records look like, whether to choose this over lifecycle_dates, or what the version filter changes. It works as a thematic label but is incomplete as a standalone tool contract.

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

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

The input schema already explains the limit and version parameters with 100% coverage, so the baseline is 3. The description adds no parameter-level meaning, such as how version filtering interacts with history or what the default ordering is. The schema is sufficient for this simple two-parameter tool.

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 defines the resource as historical/lifecycle/deprecation/architecture records and adds an 'archaeology' metaphor, so an agent can roughly tell this is a history lookup. However, it never uses an action verb like 'retrieves' or 'lists', and the categories overlap heavily with siblings such as lifecycle_dates, deprecation_register, and maximo_changelog. This makes the purpose clear in theme but not distinct enough.

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

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

The 'how did this get here / when does it end' archaeology phrase implies a usage context: questions about origin and end-of-life lineage. It does not state when to prefer this tool over lifecycle_dates, deprecation_register, or change_watch, and it names no alternatives or exclusions. The guidance is therefore only implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well: it discloses that the feed is curated (not exhaustive), that the Assetize interpretation is 'clearly-labelled' and 'never presented as IBM's', and that each record includes sources and corpus records. This is significant behavioral context—it tells the agent that the tool returns interpreted analysis, not just raw data, and that the interpretation is clearly separated from IBM's official stance. It also implies a read-only operation (no side effects mentioned). The only minor gap is not stating pagination or error behavior, but the description is quite transparent for a read-only list/detail tool.

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

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

The description is a single, dense paragraph that front-loads the core value proposition ('curated feed of genuinely material IBM Maximo / MAS 9.x changes') and then lists the key attributes in a compact, scannable list. Every sentence earns its place: the first sentence defines the scope and content, the second explains the data structure, the third gives usage instructions, and the fourth provides a reference to the same data online. No fluff, no repetition of schema details. It is appropriately sized for a tool with this complexity.

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

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

Given the tool's moderate complexity (3 optional params, no output schema, no annotations), the description is quite complete. It explains the two modes (detail vs list), the filtering option, the content of each record, and the provenance of the data. The only missing context is what the output looks like (no output schema) and any rate limits or pagination behavior, but the description's mention of 'limit' and 'default 30, max 60' in the schema partially covers that. For a read-only feed tool, this is nearly complete. A 5 would require explicit output format details or explicit sibling differentiation, so 4 is appropriate.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (slug, limit, category) with descriptions. The description adds value by explaining the relationship between slug and listing mode ('Pass a slug for one change in full; omit it to list'), which is not fully captured in the schema's individual parameter descriptions. It also adds the category filter context. However, the description doesn't add detail on the limit parameter's default/max (though the schema does), so the description's added value is moderate. Baseline 3 for 100% coverage, plus the mode-switching explanation, justifies a 4.

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

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

The description clearly states the tool's purpose: it provides a curated feed of material IBM Maximo/MAS 9.x changes, with a specific verb ('Pass a slug... omit it to list') and resource ('curated feed'). It distinguishes itself from siblings by emphasizing 'curated' and 'genuinely material' changes, and by describing the unique data structure (What Changed / Why It Matters, version comparison, Assetize interpretation). This is a specific, actionable description that an agent can use to select this tool over alternatives like maximo_changelog or deprecation_register.

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

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

The description provides clear usage context: 'Pass a slug for one change in full; omit it to list, optionally filtered by category.' This tells the agent exactly how to invoke the tool for two modes (detail vs list). It also mentions the data is the same as assetize.com.au/change-watch, which gives context. However, it doesn't explicitly state when to use this tool versus siblings like maximo_changelog or deprecation_register, nor does it state exclusions (e.g., 'use deprecation_register for a full deprecation list'). The usage is implied by the 'curated' and 'material' framing, but not explicitly contrasted with alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does this well by explaining that fixes/APARs and newly announced capability are 'reported as context only, never scored as upgrade work,' and by promising a cited, source-backed, reviewed comparison. It does not mention any output format details or edge-case behavior, but for a read-only comparison tool this is a strong behavioral disclosure.

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

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

The description is front-loaded with the core action and report scope, then adds essential detail in later sentences. It is somewhat dense and includes the assetize.com reference, but every sentence contributes useful information about output, sourcing, or valid inputs.

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 tool with no output schema, the description is nearly complete: it defines the report sections, the scoring distinction, the accepted input formats, and known bucket values. It could be slightly more complete by explicitly addressing from/to ordering or error handling for invalid labels, but those are minor gaps given the schema already defines 'starting version' and 'target version.'

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema by explaining that parameters can accept either version labels ('7.6.1.3', '9.2') or bucket ids ('9-2'), and by enumerating known buckets. This significantly improves an agent's ability to supply valid values for from and to.

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 action and resource: 'Compare two Maximo versions/eras' and explicitly defines the output as a 'cited upgrade-impact report per functional area.' It also distinguishes the tool from narrower sibling tools by naming the included categories (deprecations, behaviour changes, API changes, gotchas, fixes/APARs, newly announced capability), so an agent can tell what this tool uniquely offers.

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

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

The description gives strong context on when to use the tool: comparing two versions/eras to get an upgrade-impact report, with clear acceptance of version labels or bucket ids. It does not explicitly name alternatives or say 'use this instead of upgrade_checklist/fixes_gained/deprecation_register,' so it stops short of a 5, but the context is clear enough for an agent to infer the primary use case.

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

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

With no annotations provided, the description must carry behavioral disclosure. It conveys that this is a read-only statistics tool by listing aggregate measures like published records and unique source documents, which implies no mutation. However, it does not disclose details such as data freshness, access requirements, or any operational limitations.

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

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

The description is a single, well-structured sentence with the core purpose front-loaded before a colon and a concise list of outputs. There is no redundant wording or filler, and every element contributes to understanding the tool.

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

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

For a zero-parameter, low-complexity statistics tool, the description is nearly complete: it names the corpus and enumerates the main return categories. It does not provide an exact output schema, but the listed categories are sufficient for an agent to know what to expect. Additional detail on return format would be nice but is not essential given the tool's simplicity.

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 no parameter semantics for the description to explain. The description adds value by enumerating the dimensions of statistics the tool returns, which helps an agent understand the output despite the empty input schema. This meets the baseline expectation for a no-parameter tool.

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

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

The description clearly identifies the resource as the Assetize corpus and the action as providing coverage/transparency stats, listing the specific stat categories. It distinguishes the tool from siblings, none of which are about corpus coverage. The only minor weakness is the absence of an explicit verb like 'returns' or 'gets,' but the meaning is unambiguous.

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

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

The description implies its usage context well: an agent should call this tool when it needs corpus-level coverage or transparency statistics. No alternatives are named, but no sibling tool overlaps with this responsibility, and there are no exclusions to state. The context is clear enough for an agent to decide when to invoke 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, the description carries the behavioral disclosure burden. It adds useful context: the data is curated, rows publish only on evidence, replacements are blank when IBM has not named one, and the data mirrors assetize.com.au. This gives an agent a realistic picture of data provenance and quality.

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 dense sentence with no filler. It front-loads the core content (what, for which product, what versions, replacement, evidence) and then adds the curation caveat and external-source equivalence, all in one efficient statement.

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

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

For a simple one-optional-parameter lookup with no output schema, the description covers the record fields and data quality behavior. It stops short of stating the return shape explicitly, but the field-level enumeration makes the expected output understandable.

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

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

The only parameter, 'kind', is fully documented in the schema with allowed values DEPRECATION, REMOVAL, or RENAME. Since schema coverage is 100%, the description does not need to add parameter-level detail, meeting the baseline.

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

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

The description clearly states the tool returns a curated register of deprecations, removals, and renames for Maximo/MAS, including version, replacement, and evidence. It distinguishes itself from generic changelog or record tools, though it lacks an explicit imperative verb like 'get' or 'list.'

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

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

The usage context is implied: use this when you need deprecation, removal, or rename facts with evidence. However, it does not explicitly say when to use this versus sibling tools like maximo_changelog or records_by_version, nor does it mention any exclusion criteria.

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

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

Even though annotations are absent, the description provides some behavioral context: it states that records are counted, not scored as upgrade weight, and notes the log starts at 9.1. However, it does not disclose implications of the limit parameter, pagination, or any read-only vs side-effect behavior. Since annotations don't cover safety, this is a gap.

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

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

The description is concise (two sentences) and front-loads the core purpose. It wastes no words, but could have been slightly more structured by separating the option mention. Still, it earns high marks for brevity.

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

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

Given the tool's moderate complexity (4 parameters, no output schema) and absence of annotations, the description is adequate but not complete. It explains the input range and the nature of the data, but does not describe the structure of the output or any behaviors like the limit's effect, which might be important for an agent to interpret responses correctly.

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

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

Schema coverage is 100%, so each parameter is described in the schema. The description adds the semantic clarification that results are 'counted, never scored,' which adds meaning beyond the schema. However, it does not explain the meaning of 'area' values beyond the example, and the description is sufficient given high coverage.

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

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

The description clearly states the resource (9.x change log records) and the action (listing FIX and SECURITY records for a move). It also notes the optional area filter. However, it could more strongly differentiate itself from sibling maximo_changelog, which also deals with change log content.

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

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

The description implies usage in the context of a 'move' and 9.x releases, but does not explicitly state when to use this versus maximo_changelog or compare_maximo_versions. It does not provide exclusions or alternatives, leaving some ambiguity.

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

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

With no annotations provided, the description carries the full burden. It states 'Fetch' which implies a read-only operation, and lists the returned content. However, it does not explicitly disclose safety (e.g., 'does not modify data'), potential error behavior (e.g., not found), or any side effects. It is not contradictory, but it leaves some behavioral aspects implicit.

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

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

The description is a single sentence that is front-loaded with the verb and resource, then efficiently lists the included components. There is zero waste; every word contributes to understanding the tool's purpose and output.

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

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

For a simple tool with one parameter and no output schema, the description is fairly complete. It specifies what is returned (established fact, claims, version scope, source URLs), giving the agent a clear idea of the response. It lacks explicit error handling or response format details, but these are minor for a straightforward fetch operation. Given the lack of annotations, it could be more explicit about read-only behavior, but the verb 'Fetch' covers that.

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

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

Schema coverage is 100% – the only parameter, slug, has a description that already explains its origin. The tool description adds 'by slug' but does not provide additional semantic detail beyond the schema. Since the schema already documents the parameter, the baseline of 3 is appropriate.

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

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

The description clearly states the specific verb 'Fetch', the resource 'one published record', and the method 'by slug'. It also enumerates the contents (established fact, claims, version scope, source URLs), which distinguishes it from sibling tools like search_records that return lists. The title reinforces the purpose.

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

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

The description implies usage when you have a slug and want full details, but it does not explicitly state when to use this tool versus alternatives. The schema description for the slug parameter mentions it comes from search_records / lookup_error_code, which is helpful but resides in the schema, not the tool description. No explicit exclusions or alternative routing are provided.

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

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

With no annotations provided, the description must carry the behavioral burden. It discloses that the tool returns structured rows, lists the row fields, and names the source, but it does not explicitly state whether it is read-only, what happens with no filters, or whether there are pagination or performance considerations.

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

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

The description is three efficient sentences, front-loading the core data delivered and then adding scoping and source context. There is no filler or redundant repetition of schema details.

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

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

The description is sufficiently complete for a simple optional-filter lookup: it names the returned fields, states optional scoping, and identifies the data source. It does not explain default behavior with no parameters or output ordering, but these are minor gaps given the tool's simplicity.

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

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

Schema description coverage is 100%, so the schema already fully explains both parameters. The description adds only the general statement that scoping is optional, which does not materially extend the schema's meaning.

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

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

The description clearly identifies the resource: end-of-support, Extended Support, and Dual Support dates for Maximo and MAS, and enumerates the fields returned. It is narrower than the broad 'support_lifecycle' sibling, but it does not explicitly contrast itself with that sibling, so it misses full 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?

The description implies usage by noting optional scoping by product or version and referencing the same data as a known web page. However, it does not state when to prefer this tool over siblings like support_lifecycle or deprecation_register, nor does it give any exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full transparency burden. It does disclose optional version scoping and that the data mirrors assetize.com.au/gotchas, but it does not state return format, pagination, or explicitly confirm a read-only/no side-effect profile. Adequate for a simple list tool, but not rich.

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

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

The description is a single front-loaded sentence that communicates the data domain, version scoping, and source URL with no filler. Every phrase contributes useful 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 list tool with no required inputs and fully documented parameters, the description is largely sufficient: it identifies the record type, the optional filter, and the data source. Additional output or ordering details would be nice, but they are not critical for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mainly echoes the optional version scoping and adds little semantic value beyond what the schema already documents for limit and version.

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 concrete resource: 'Known traps, upgrade landmines, installation issues, security and troubleshooting records', and it ties the data to a known source URL. It lacks an explicit verb like 'lists' and does not directly contrast with sibling tools, so it stops just 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?

Phrases like 'upgrade landmines, installation issues, security and troubleshooting' imply this tool is for known-issue and upgrade-planning lookups, but there is no explicit 'use when' guidance or named alternative. With many sibling tools present, more explicit routing would be an improvement.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read operation ('Find') but does not mention permissions, rate limits, return format, or what 'published records' entails. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single, well-structured sentence that front-loads the purpose and includes useful examples. There is no redundancy or filler.

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

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

For a simple lookup with one parameter and no output schema, the description is mostly sufficient. However, it does not specify the return structure (e.g., whether multiple records may be returned, or if a not-found case is handled), leaving some ambiguity for the agent.

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

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

The schema documents the 'code' parameter with an example, and the description adds multiple example formats (BMXAA1234E, IJ12345, APAR...), enhancing the agent's understanding of acceptable inputs beyond the schema's single example.

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

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

The description clearly states the tool's function: finding published records for a specific Maximo error or fix identifier, with concrete examples of code formats. It distinguishes itself from generic record tools by targeting error codes specifically, though it does not explicitly name siblings it is not.

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

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

No guidance is given on when to use this tool versus alternatives like search_records or get_record. The description implies usage when you have an error code, but does not state exclusions or recommend when a different tool would be more appropriate.

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

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

No annotations are provided, so the description must disclose behavior. It does so by stating it returns only real change records, excludes data-dictionary noise and demoted items, and clarifies data source. This adds transparency beyond the schema. However, it does not describe return format or pagination limitations, which are minor given the simplicity of a list tool.

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

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

The description is concise, front-loaded with the core purpose, and every sentence adds value. It includes source citation, filtering details, and a reference to the web version, with no redundancy. Well-structured and efficient.

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

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

Given the tool's moderate complexity (3 optional params, no output schema), the description covers the essential points: purpose, filters, and source. It lacks details on return format or default behavior, but those are not critical for an agent to invoke it correctly. It is complete enough for a straightforward changelog query tool.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds value by explaining the 'type' filter's allowed values and the 'version' format, but it does not go beyond that. Since the schema covers the basics, a baseline 3 is appropriate; the description does not add major new semantics.

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

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

The description clearly states the tool's purpose: it logs changes across IBM Maximo/MAS 9.x, with specific categories (deprecations, behaviour changes, etc.). It distinguishes itself from siblings by scoping to the changelog and even mentions the same data as a website. This is a specific verb-resource pair.

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

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

The description explains the optional filters (version and type) and says omitting version gives all 9.x, which implies when to use it. However, it does not explicitly state when not to use it or point to alternatives; siblings like deprecation_register or behaviour_history might be better for specific types. Still, the context is clear enough for an agent to infer appropriate use.

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

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

Even with no annotations, the description discloses the result format: 'Every fact carries IBM's verbatim sentence, page and read date.' It also says the data is the same as assetize.com.au/mobile and that facts holding for every release are always included, which clarifies scope behavior. It doesn't state explicitly whether the call is read-only or describe limits, but the tool's static research nature makes side effects unlikely.

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 informative but structured as one long run-on paragraph with a massive comma-separated list of topics. It front-loads the core purpose and includes necessary routing/provenance details, but bullet structure or shorter sentences would improve scannability for an 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?

For a two-optional-parameter lookup with no output schema, the description covers selection topics, release scoping, citation contents, and a sibling alternative. It doesn't specify pagination or error behavior, but those are not essential for a research-statement lookup. Overall, an agent has enough to choose and call it correctly.

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

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

Schema coverage is 100%: both optional params already have descriptions enumerating topics and releases. The main description adds only 'Scope by release and/or topic' and the version schema notes the always-included facts. This is baseline value rather than a significant layer of meaning beyond the schema.

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

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

The title and opening line ('Researched IBM statements about Maximo Mobile, by topic') plus the topic list make the resource and scope explicit. It also points to search_records as the tool for fixes and gotchas, helping set it apart from at least one sibling. However, it doesn't contrast with other closely related knowledge tools such as compare_maximo_versions or records_by_version.

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

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

The description explicitly says 'Scope by release and/or topic', telling the agent how to refine a query. It also gives a clear routing rule: 'For fixes and gotchas use search_records.' This is solid but not exhaustive, since it doesn't mention when other sibling research/version tools would be preferred.

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

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

With no annotations, the description carries the full burden. It does disclose the scope of results ('Every published record scoped to a given Maximo version or family') and points to an external reference, which gives some expectation of content. However, it says nothing about pagination, ordering, record structure, or any limits beyond what the schema already provides.

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

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

Two compact sentences with no filler. The core behavior is front-loaded, the version scenarios are demonstrated with examples, and the URL reference is a useful anchor. Every sentence earns its place.

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

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

The tool is simple and the schema covers both parameters, but there is no output schema and the description does not describe the shape of returned records or whether they are full records or summaries. The URL reference adds context, but an agent is left to assume what 'record' means and how results are returned.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some semantic flavor to the version parameter by explaining that it can be a family (e.g., '9.2') and equivalently maps to a URL, but it does not materially add meaning beyond the schema's own parameter descriptions.

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

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

The description clearly identifies the resource (published records) and the scope (Maximo version or family), with concrete version examples. It conveys that the tool returns all records for a version, but it lacks an explicit verb like 'list' or 'retrieve' and does not distinguish itself from sibling tools such as search_records or get_record.

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

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

No guidance is given about when to use this tool versus alternatives. The sibling tools are not referenced, and there is no mention of when a search or a single-record lookup would be more appropriate. The only contextual hint is the URL equivalence, which is not a usage guideline.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add useful context: it searches only 'published' records and states the return fields. However, it does not disclose whether this is strictly read-only, how matching works, whether exact identifiers behave differently, or any pagination/sorting behavior beyond the schema's limit parameter. This is adequate but not rich.

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

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

Two short sentences, front-loaded with the core purpose and followed by the return shape. Every word earns its place; there is no filler or redundant restatement of 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 simple keyword-search tool, the description covers what it searches, what it returns, and the schema covers all parameters. There is no output schema, so the description appropriately mentions return fields. The main gap is the lack of sibling routing guidance, but the core invocation information is present and sufficient.

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

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

Schema description coverage is 100%, so the schema already documents query, limit, and version with meaningful descriptions. The tool description adds little parameter-level meaning beyond 'keyword search' and the output shape; it does not need to compensate because the schema already does the heavy lifting. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Fast keyword search over published Assetize knowledge records.' It also clarifies the return shape ('slugs, titles and short answers with record URLs'), which clearly distinguishes it from sibling tools like get_record (single record retrieval) and records_by_version (version-based listing). The operation 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?

No guidance is given about when to use this tool versus alternatives. It does not mention ask_maximo, get_record, lookup_error_code, or records_by_version, nor any condition that would route an agent to one tool instead of another. The only implied usage is 'keyword search,' but no exclusions or alternatives are provided.

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

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

With no annotations, the description must carry the behavioral burden. It usefully discloses that facts come from source-backed records and the curated Change Watch, implying a read-only knowledge lookup. However, it does not explain what a result looks like or how missing/omitted version affects behavior, so transparency is adequate but not rich.

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

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

The description is a single dense, information-rich sentence with an explicit optional-scoping instruction. It is reasonably front-loaded with the topic and contains 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?

For a two-optional-parameter query the description covers subject, source, deadlines, and version scoping, which is enough structure to invoke it. Yet with no output schema, no annotations, and many sibling tools, it leaves the return shape, use cases, and selection boundaries to the agent.

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

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

Schema description coverage is 100%, so the schema already documents both optional parameters. The description's 'Optionally scope to a version' reinforces the version parameter but adds no form, format, or default details beyond the schema; limit is not addressed.

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 concrete subject ('Maximo / MAS support-lifecycle facts') and the specific data points: end-of-support, Extended Support transitions, and 2026/2027 deadlines. It is clear, but it lacks an explicit verb and does not distinguish itself from the conceptually similar sibling lifecycle_dates.

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

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

The description gives no when-to-use/when-not-to-use guidance and names no alternative tool, despite numerous siblings and a likely overlap with lifecycle_dates. 'Optionally scope to a version' is parameter usage, 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, the description carries the full burden of behavioral disclosure and does so thoroughly: static-only analysis, no script execution, missing attributes reported as NOT_ASSESSED rather than runtime failures, and a clear list of the accessor methods it scans for. This is strong, non-misleading behavioral context.

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

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

The description is dense but efficient, with each clause earning its place: the core action, the extraction mechanism, the static-only limitation, the NOT_ASSESSED semantics, and the routing to runtime alternatives. The lens list partially duplicates the enum in the schema, but the added release labels make it acceptable.

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

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

The description explains the tool's inputs, what it reports, and its limits, which is especially important because no output schema exists. However, it stops short of specifying the concrete shape of the evidence report, such as an attribute-to-status mapping. This is a minor gap in an otherwise complete definition.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents source as Jython/JavaScript up to 64 KiB and lens as an enum. The description adds useful context such as the MXAPIWODETAIL dictionary and lens labels, but it does not materially change or deepen parameter semantics.

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

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

The description states a specific action and resource: 'Statically check a WORKORDER Object launch point Automation Script' against a release lens's MXAPIWODETAIL dictionary. It also explains exactly what the tool extracts and reports, which clearly differentiates it from record-lookup, changelog, and lifecycle sibling tools.

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

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

The description explicitly marks the tool as static evidence only and says it does not run the script. It then directs users who need a real pass/fail/skip verdict to the CLI or browser runner, providing explicit when-to-use and when-not-to-use guidance. It also enumerates the five supported lenses, so selection context 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that items are resolved against the corpus and dropped if not published, and that VERIFY items are questions to settle against IBM. This gives meaningful behavioral context beyond a simple 'returns checklist'.

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 fluff. The purpose is stated first, followed by the key behavioral caveat (CITED vs VERIFY, resolution logic). Every clause earns its place and the description is 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 checklist tool with all parameters documented and a clear behavioral explanation, the description is nearly complete. The only gap is the exact return structure (e.g., array of items, statuses), but since there's no output schema, the agent might benefit from knowing the shape of the response. However, the core behavior is 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%, with descriptions for from, to, and phase including examples. The description adds no extra semantic meaning to the parameters themselves; it only mentions the optional phase in passing. Baseline 3 is appropriate when the schema already documents all parameters.

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

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

The description states a clear purpose: provides a phased checklist (before/during/after) for a Maximo move. It names the resource (Maximo move) and the action (provides checklist), which is specific enough to distinguish from generic tools, though it doesn't explicitly differentiate from the sibling upgrade_plan.

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 upgrade_plan or ask_maximo. It mentions the phased nature but doesn't state prerequisites or exclusion criteria, leaving the agent to infer usage from the description 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?

There are no annotations, so the description carries the full burden, and it largely delivers: it discloses that the output is composed from the published record, includes IBM's exact words and page references, and notes which items only the customer's system can answer. It does not explicitly state whether the tool is read-only or has side effects, but the level of compositional detail is strong.

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

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

The description is long but information-dense, using a colon-separated list to enumerate the plan's components rather than rambling. It front-loads the core purpose before the details, and every listed item adds value. It could be split into shorter sentences for scannability, but it is not 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?

Even with no output schema, the description gives substantial detail about what the plan will contain, where the content comes from, and how items are linked. The main gaps are the lack of explicit return-format information and side-effect status, but those are minor relative to the richness provided. For a complex aggregation tool, this is largely complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by stating the ordering constraint 'from an earlier catalogue release to a later one' and enumerating the release range. It does not redundantly re-document the parameters themselves, which is appropriate given the schema already covers them.

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 defines a specific deliverable: a composed Maximo move/upgrade plan from a source release to a target release, enumerating the categories it contains. This clearly distinguishes it from more focused siblings like compare_maximo_versions or upgrade_checklist by emphasizing breadth and the published-record composition. The verb is implied by the tool name and title, but the resource and scope are exact.

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

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

The description gives no explicit 'use when' guidance, prerequisites, or when-not-to-use instructions. With 18 sibling tools, the absence of any alternative routing is a real gap; usage is only implicitly conveyed by the tool's purpose. It never says what to use instead for a narrower comparison or a simple checklist.

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