MCP-Maltego

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description adds useful behavior beyond that: it saves results and reports transforms missing due to API keys, which helps an agent anticipate side effects and incomplete 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 front-loaded sentence with no wasted text. The Maltego comparison and API-key caveat both add useful context efficiently.

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 open-world, non-idempotent bulk operation with no output schema, the description covers purpose, persistence, and API-key limitations but does not describe the response shape or operational caveats such as time/cost/partial failures. It is adequate 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 100%, so every parameter including reason, soft_limit, max_transforms, and response_format is already documented in the schema. The description adds no parameter-level semantics beyond what the schema provides, 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?

States a specific verb and resource: run all available transforms that declare the entity's type on a case entity, and save results. The 'todos los transforms' phrasing distinguishes it from the single-transform sibling, but it does not explicitly name osint_run_transform 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?

The 'like Run All in Maltego' comparison and 'all transforms' wording imply this is the bulk-expansion option, but there is no explicit when-to-use or when-not-to-use guidance versus osint_run_transform or osint_investigate. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the write-a-file nature is covered; the description adds useful behavior (mtgx embeds the investigation memory, inline=true also returns the Markdown report). However it never states where the file is written, whether an existing file is overwritten, or what the response contains besides the inline report, which are the real open questions for a non-idempotent write 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?

A single dense sentence that front-loads the export action and the format enumeration before the inline note. Slightly run-on with nested parentheticals, but every clause carries 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 output schema, the description carries the burden of explaining the return value, and it only covers the inline=true case. It omits what a normal export returns (file path, download reference, size) and does not resolve where the artifact lands, leaving a meaningful gap for an export 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 baseline is 3, but the description adds meaning beyond the schema: it explains what each format is useful for and clarifies that inline returns the Markdown in the response rather than only writing it. It still does not clarify that layout is only relevant when format=mtgx, which the schema phrases ambiguously.

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 ('Exporta a fichero') and the resource (caso/informe), and enumerates every supported output format including the natively specialized mtgx. It is immediately distinguishable from the inverse sibling osint_import_graph and from read-oriented siblings like osint_get_case_summary.

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?

Goes beyond a bare format list by attaching a purpose to several formats (graphml for SIEM/SOAR and Gephi, report_md/report_html for an executive report, mtgx for the native graph with investigation memory), which effectively tells the agent which format to pick. It stops short of explicit when-not-to-use or prerequisites.

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

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

The annotations already establish read-only, idempotent, non-destructive behavior, so the description's added context is valuable: it discloses that paths are acyclic, may traverse in any direction, and are ordered shortest-first. It does not cover permissions, rate limits, or result structure, but the traversal semantics it adds go meaningfully beyond the annotations.

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

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

It is a single front-loaded sentence with no filler. The traversal constraints are packed efficiently into parentheses and every clause contributes to the tool's core meaning.

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

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

For a six-parameter graph traversal tool with no output schema, the description covers the core traversal behavior but omits guidance on when to use it versus related graph tools and gives no sense of the returned path structure. The rich schema and annotations cover parameters and safety, so it is adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter explanation in the description. The description only implies that source_id and target_id identify the two entities; it adds no semantics beyond what the schema already documents for case_id, limit, max_depth, and response_format.

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 ('Encuentra') and resource ('caminos') scoped to two entities, which distinguishes it from single-entity siblings like osint_get_neighbors and osint_expand_entity. It stops short of naming an alternative, so it is clear but not maximally 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?

There is no explicit when-to-use guidance, no when-not guidance, and no named alternative. The phrase 'entre dos entidades' implies the use case but does not tell an agent when to choose this tool over osint_get_neighbors or osint_expand_entity.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds computation semantics beyond that: the priority score is 'explicable' and derived from confidence, source reliability, connections and novelty, which tells the agent how to interpret results. It stops short of stating cost, entity limits or response size.

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 that enumerates the output sections without filler. The nested parenthetical listing score components is dense but each clause maps to a real output section rather than padding.

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

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

There is no output schema, so the description carries the burden of describing return values, and it does so by naming the four result blocks (counts, priority entities with score dimensions, isolated entities, quality indices). Combined with fully documented parameters and full annotation coverage, an agent has what it needs to call it and interpret the result.

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 case_id, top and response_format are already documented in the schema, including the enum and defaults. The description adds nothing about parameters (e.g. that 'top' caps the priority-entity list), 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?

Uses a specific verb ('Resume') plus the resource ('un caso') and then enumerates exactly what the summary contains: counts by type, priority entities, isolated entities and quality indices. An agent can distinguish it from osint_get_timeline or osint_export_case by the content listed, 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?

The usage context (a summarising/overview read for one case) is implied by 'Resume un caso', but there is no explicit guidance on when to pick this over osint_list_cases, osint_get_entity, osint_get_timeline or osint_suggest_next_steps, and no prerequisites such as the case needing to exist.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds substantive content-level behavior: what the payload contains, that scores come with an explanation, and that provenance plus executed/pending transforms are included. Missing only edge behavior (entity not found, size limits).

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 whose enumerated return fields each carry information. Slightly run-on as an appended list, but 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?

With no output schema, the description must describe return content, and it does so concretely. For an idempotent read with 3 fully documented params and annotation coverage, only error/empty-result behavior is absent.

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 case_id, entity_id and response_format are already fully documented in the schema, including the enum and default. The description adds nothing about parameters, 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 ("Devuelve") and resource ("una entidad") and enumerates the returned facets: propiedades, notas, fuentes, puntuación explicada, procedencia, transforms ejecutados y pendientes. That detail distinguishes it from osint_search_entities and osint_get_neighbors, 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?

Usage is only implied: an agent can infer it should call this after obtaining an entity_id to inspect full detail, including pending transforms. There is no explicit when-to-use, no exclusions, and no reference to alternatives such as osint_search_entities or osint_expand_entity.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and closed-world, so safety is fully covered and the description does not contradict them. It adds the shape of the result (each relation carries type and direction) but says nothing about truncation, default page size behavior with limit=25, or what happens for an entity with no relations.

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 tight sentence with the resource front-loaded and zero filler. It is efficient rather than padded, though it is thin enough that it earns a 4 rather than a 5.

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 6-parameter graph-read tool with no output schema, the description gives the minimum: what the list contains. It leaves out pagination/limit semantics, direction semantics ('both' vs 'out'/'in'), and error behavior for unknown entities, which the agent must reconstruct from the schema 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 100%, so the baseline is 3. The description's mention of 'tipo y dirección' loosely maps to the edge_label and direction parameters but adds no semantics beyond the schema's own enum/default documentation.

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

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

States a specific verb and resource ('Lista las entidades relacionadas con una entidad') and even characterizes the payload (type and direction of each relation). It does not, however, contrast itself with sibling graph tools such as osint_expand_entity or osint_find_paths, 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?

Usage is only implied: fetch the immediate neighborhood of a known entity_id. There is no statement of when to prefer this over osint_expand_entity, osint_find_paths, or osint_get_entity, and no prerequisite that entity_id must first come from a search/get call (that hint lives only in the schema).

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description goes beyond them by naming the concrete data sources (whois.created, breach.date, github.created_at) and disclosing that subject mode computes temporal anomalies — genuinely useful behavioral context. It stops short of describing ordering, pagination or the shape of the returned events.

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 dense sentences, each front-loaded with its mode label, so an agent can scan for the mode it needs. No filler, though the second sentence packs several ideas (sources, timeline, anomaly detection) into one long clause.

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

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

For a read-only, six-parameter tool with full schema descriptions, the description conveys what each mode produces and where the dates come from. With no output schema defined, a short note on the returned event structure or ordering would have closed the remaining gap.

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

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

Schema description coverage is 100%, so every parameter including the mode enum, limit bounds, case_id format and entity_id scoping is already documented in the schema. The description only reiterates mode semantics and ties since_seq to the investigation mode, adding little beyond the structured fields — baseline 3.

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?

State clearly what each mode returns: procedural memory of executed steps versus a behavioral/vital timeline built from entity dates with anomaly (de-confliction) detection. The distinction between the two modes is explicit. It does not, however, differentiate itself from the nearest sibling, osint_get_case_summary, which an agent could plausibly confuse with the investigation mode.

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 mode semantics imply when each variant applies, and 'con since_seq' hints at incremental polling, but the description never states when to prefer this tool over osint_get_case_summary or osint_suggest_next_steps, nor any exclusions or prerequisites. Usage must be inferred rather than 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?

Annotations declare a non-destructive, idempotent write; the description reinforces this with merge semantics ("fusiona") and notes that Maltego memory is carried over when present. That is genuine behavioral context beyond the annotations, though it says nothing about conflict handling on duplicate entities.

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 dense sentences, front-loaded with the action and formats, followed by the file-location constraint. 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?

No output schema exists, and the description does not say what is returned after a merge (imported counts, skipped rows) or how duplicates are resolved. Against an annotation set that already covers the safety profile, this is a minor but real 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%, so case_id and file_name are already documented; the description still adds value by enumerating the two file types and the exact CSV column contract, which the schema does not convey.

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 (importa/fusiona) plus the resource (a .mtgx Maltego graph or a CSV) and the destination (a case). The import direction and both accepted formats make it unambiguously distinct from the export sibling.

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

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

Gives a clear precondition — the file must live in ~/.maltego-mcp/imports (or exports) — which is essential to calling it correctly. It does not explicitly say when not to use it or name an alternative workflow, so it stops short of full routing guidance.

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

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

Annotations already flag a non-read-only, open-world, non-idempotent operation, and the description usefully adds that it creates a case and returns an inline report. It still omits cost, latency, failure behavior when a Machine is unavailable, and what 'puntúa entidades' produces — relevant given the openWorldHint.

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 front-loaded sentence with the key qualifier ('Punto de entrada') first and no filler. It is a dense run-on list of clauses, but each clause names a real behavior rather than restating the name.

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

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

For an 8-parameter, open-world orchestration tool with no output schema, the description does state the end product ('informe en línea'), which is the most important missing piece. It still leaves unclear what the report contains, how the case persists, and what happens across max_rounds > 1.

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 eight parameters including case_id defaults, machine override and max_rounds. The description only reinforces the value/machine/case_id relationship, adding little syntax or constraint detail beyond the schema — 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?

Declares itself the entry point ('Punto de entrada') and enumerates the concrete pipeline: type detection, case creation, Machine execution, entity scoring, next-step proposal and inline report. This makes it clearly distinguishable from orchestrated siblings like osint_run_machine and osint_suggest_next_steps, though it never explicitly contrasts itself with 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?

'Punto de entrada' implies this is the first tool to reach for, and the mention of case_id hints at continuing an existing case. However, there is no explicit guidance on when to use osint_run_machine or osint_expand_entity instead, nor on when not to use this one (e.g., cheap single-transform lookups).

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

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

Annotations already cover the write/idempotent/safe profile, and the description adds genuinely new behavior: the 0.85 auto-link threshold for correlate (an automated mutation the agent would otherwise not expect) and the fact that correlate with an empty target compares against the whole case. Minor tension worth noting: unlink 'elimina la relación' while destructiveHint=false — the edge deletion is at least disclosed, so it is not a contradiction, but the reversal story (is the deleted edge recoverable?) is never 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?

A single semicolon-delimited sentence organized by action, front-loading the default mode first. Dense but zero waste — every clause carries a distinct behavioral fact.

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 12 parameters and no output schema, the description never indicates what analyze or correlate return (an inferred role/sentiment/weight? a probability score? whether a link was created at the threshold). For a multi-mode tool this leaves the agent guessing at results and at entity-existence prerequisites.

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 earns above that by mapping the optional HUMINT trio (rol, sentimiento, peso) to the link/analyze actions, which the schema only documents in isolation. It does not explain how source, edge_label, confidence or properties interact with each action.

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?

Enumerates all four modes with concrete semantics: link crea/refuerza la relación dirigida source->target, analyze infiere rol/sentimiento/peso, correlate calcula probabilidad de solapamiento y enlaza si >=0.85, unlink elimina la relación. An agent can pick the right mode without opening the schema, and no sibling (osint_upsert_entity, osint_get_neighbors, osint_find_paths) does the same job.

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?

Each action's effect is described, which implies when to use it, but there is no explicit guidance on choosing between analyze and correlate, nor any stated prerequisites (entities must already exist, likely via osint_upsert_entity). No exclusions or pointers to sibling tools are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely new behavioral context beyond that: results are ordered most-recent-first and the call is paginated, which the annotations do not convey.

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 that front-loads the resource, then ordering, then pagination, with no redundant or filler content. 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 output schema, the description does not say what a 'caso' record contains or what an empty result looks like, and it only obliquely covers response format. It is adequate for a simple paginated list with well-documented parameters, but leaves the agent guessing at the shape of returned data.

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 limit, offset and response_format are already documented with ranges, defaults and the markdown/json enum. The description only echoes that pagination exists and adds no format or semantics beyond the schema, matching the baseline 3.

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 ('Lista los casos de investigación') plus scope details (ordering, pagination), so an agent knows exactly what it returns. It does not explicitly name how it differs from siblings like osint_get_case_summary, 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?

Usage is only implied: the verb 'Lista' signals enumeration, but there is no statement of when to prefer this over osint_get_case_summary or osint_search_entities, and no exclusions or prerequisites. An agent must infer the routing 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered. The description adds genuine context beyond that: the catalog is a fixed, closed set combining Maltego standard types with the user's imported ones, and each entry carries a category and main property. It does not mention result volume or whether the catalog can be large.

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 no filler; the core purpose comes first and the cross-tool value note follows as the actionable takeaway. Nothing is restated redundantly.

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-required-parameter, read-only list tool with full schema coverage and annotations carrying the safety profile, the description covers what the tool is and roughly what comes back (types per category with a main property). Since there is no output schema, a brief hint at the returned record shape would have closed the remaining gap, but an agent can call this correctly as-is.

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 both parameters documented in-schema, including enum values for response_format. The description's 'por categoría' loosely points at the category filter but adds no syntax or semantics beyond what the schema already says, and response_format is not mentioned at all. Baseline 3.

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: lists supported entity types (Maltego standard plus imported ones) grouped by category, including each type's main property. It also clarifies that the maltego_type value is the entity_type other tools consume, which differentiates it from action-oriented siblings like osint_upsert_entity or osint_search_entities, though the alternative isn't 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 implied rather than stated: the note that maltego_type is the entity_type used by the other tools points an agent here to discover valid values before writing entities. There is no explicit 'use this when...' framing and no exclusions or alternatives (e.g., vs osint_search_entities) named.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context by explaining that the inventory includes integrated transforms without API keys, provider transforms with API keys, and TRX/iTDS servers, and that check_servers=true performs a connection check.

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 begins with 'Inventario' and packs the key scope, filters, and check_servers behavior without obvious filler. It is dense but appropriately sized for a list 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 read-only inventory tool with no output schema, the description covers the main content returned (transforms, Machines, provider/server status) and the optional connection check. It leaves return formatting details to the schema, which is acceptable given full parameter coverage.

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 all five parameters are already documented in the schema. The description reinforces category/entity_type filtering and check_servers behavior but does not add meaning beyond the schema for response_format or include_machines.

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

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

The description clearly states it is an inventory of transforms, Machines, and provider/server status, with filtering by input type or category. It implicitly distinguishes itself from run-oriented siblings like osint_run_transform and osint_run_machine by focusing on listing available resources rather than executing 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?

It explains that results can be filtered by input type or category and that check_servers=true verifies connections, which implies when to use the tool. However, it does not explicitly say when to choose this over osint_run_transform, osint_run_machine, or osint_list_entity_types, nor does it state exclusions.

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

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

Annotations already flag this as destructive and non-idempotent, and the description adds real context beyond them: merge uses optimistic locking via expected_version, and delete requires re-typing the case_id in confirm. It does not state whether delete is reversible or what permissions are needed, keeping it short of a 5.

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?

There is no filler, but five distinct operations are crammed into one long run-on Spanish sentence, making it hard to scan for a single action. The primary 'create or update' purpose is front-loaded, which helps.

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 8-parameter, 5-action destructive tool with no output schema, the action semantics are covered well, but nothing is said about what a call returns (created case id? version number? merge conflict payload) or what a failed optimistic-lock check looks like — information an agent needs since there is no output schema to consult.

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

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

Schema coverage is 100%, so the baseline is 3, but the description earns extra credit by explaining conditional applicability of parameters — which ones matter per action (sub_roles only for fork/delegate, source_case='all' only for merge, expected_version=0 means skip the lock). That is meaning the schema alone does not convey.

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

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

The description names the resource (case) and enumerates the concrete operations behind each action value: create, fork/delegate into sub-cases, merge with optimistic locking, delete. An agent can tell it apart from read-only siblings like osint_get_case_summary or osint_list_cases, though it never explicitly says so.

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

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

Usage is implied by mapping each action value to its companion parameters (sub_roles for fork/delegate, source_case or 'all' for merge, confirm for delete). There is no explicit 'use this instead of X' guidance and no statement of prerequisites or when not to pick a given action.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false; the description goes beyond them by disclosing that action=delete is a cascade removal ('borra la entidad y sus relaciones'), which is genuinely new behavioral information. It stops short of noting irreversibility, undo, or what analyze_behavior costs/produces.

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 parallel clauses, one per action, front-loaded with the 'action=' discriminator and zero filler. Every sentence maps directly to a decision the caller must make.

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 12-parameter, four-mode tool with no output schema, the description covers the action semantics but omits notable gaps: whether notes replace or append (only in schema), what analyze_behavior returns or costs, and whether delete is recoverable. Adequate but leaves the agent guessing on the riskier 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 coverage is 100%, so the baseline is 3, but the description adds real meaning to the action enum by mapping each value to a distinct set of parameters it drives — information the enum's flat value list does not convey. It does not clarify which params are ignored per action beyond that implicit mapping.

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 enumerates all four actions with specific effects (change confidence/notes/properties, set visual weight/color/size, run HUMINT behavioral profiling, delete entity plus relations). This is far more than restating the title, though it never contrasts with the close sibling osint_upsert_entity, so an agent must still infer which tool to pick for creation vs. modification.

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?

Each action's effect is stated, which implies when to use it, but there are no explicit exclusions, prerequisites, or routing hints (e.g. 'use update rather than upsert_entity to modify an existing node'). The agent must derive usage from the action semantics alone.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false and destructiveHint=false, so the safety profile is carried structurally. The description adds genuinely useful behavior beyond that: max_rounds re-expands over newly discovered entities and the budget parameters (soft_limit, max_total_entities, max_inputs_per_step) bound cost, which is the key operational trait of a recursive, open-world 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?

A single dense paragraph, front-loaded with the core action and the available machines, followed by the recursion and budget notes. The machine-name enumeration is long but earns its place by removing a discovery round-trip; the rest is efficient.

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

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

With 11 parameters, 100% schema coverage, and no output schema, the description covers the essential decision surface: machine vs. custom transform chain, recursion depth, and budget controls. It does not explain mutual exclusivity of 'machine' and 'transforms' explicitly or describe the response shape, but the schema fills those gaps adequately.

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 every parameter is already documented in the schema itself. The description adds only marginal semantics, clarifying that max_rounds repeats expansion 'sobre lo nuevo' and that transforms are applied in order, which slightly enriches the schema's terse 'Rondas de expansión recursiva'. Baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb ('Ejecuta') and resource ('Machine' or custom chain) and enumerates the concrete machine names available (DomainRecon, InfrastructureRecon, ThreatSweep, etc.), so the agent knows exactly what is being run. It does not explicitly contrast itself with close siblings like osint_run_transform or osint_expand_entity, which keeps it below 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 description implies usage ('una cadena propia (transforms en orden)' when you don't want a predefined machine) and explains that max_rounds repeats expansion while budgets cap cost, giving some operational context. However, it never states when to pick this over osint_run_transform, osint_expand_entity, or osint_investigate, nor any 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?

Annotations already declare a non-read-only, open-world, non-idempotent, non-destructive operation; the description adds the important consequence that save=true writes entity, results, relations AND the step into case memory — a side effect not captured by the hints. It omits what happens when save=false (results returned but not persisted) and whether the transform hits external servers/slow paths.

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 what the tool does and followed by the persistence behavior. No filler or repetition of parameter names already in the schema.

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

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

For a 9-parameter, open-world tool with no output schema, the description is thin: it never describes what is returned (result set shape, truncation via soft_limit, when save=false) or that external/TRX servers may be contacted and could fail or be slow. The schema carries most of the load, leaving behavioral completeness adequate but not full.

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 every parameter is already documented, including case_id being mandatory when save=true and the enum for response_format. The description only reinforces the save semantics; it adds no syntax or interaction detail (e.g., how properties interacts with the transform, or what soft_limit truncation means) 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?

States a specific verb ("Ejecuta") and resource ("transform") plus the three transform origins (integrado, proveedor, TRX/iTDS servers) applied to an entity. It does not explicitly differentiate from the close sibling osint_run_machine, which chains transforms, so the verb/resource is clear but sibling framing is left implicit.

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

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

Usage is implied: run a single transform on an entity, with save=true persisting to the case. There is no explicit when-to-use/when-not guidance versus osint_run_machine (single transform vs machine) or osint_expand_entity, and no stated prerequisite to first call osint_list_transforms beyond what the schema itself says.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds a non-obvious behavioral constraint (priority sorting only works with a case_id) and the cross-case correlation semantics of an empty case_id, which the agent could not infer from annotations.

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

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

A single dense sentence with the core search behavior front-loaded and the two constraints appended. No filler, no repetition of schema defaults.

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 read tool with full schema coverage and annotations, the description covers purpose, scope, and the key constraint. It does not mention pagination behavior or result shape, but with no output schema and limit/offset documented in the schema, that gap is minor.

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

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

Schema coverage is 100%, so baseline is 3; the description earns above that by documenting a cross-parameter dependency (sort=priority requires case_id) that the schema does not express. The case_id empty-means-all explanation largely duplicates the schema text.

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 ('Busca entidades') plus the search dimension (texto en valor y/o tipo) and scope (un caso o todos). It is clearly distinguishable from single-entity siblings like osint_get_entity, though it never names an alternative 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?

Gives concrete usage context: empty case_id means cross-case correlation, and sort=priority requires case_id. These are real decision rules, but there is no explicit 'use X instead when...' routing to siblings such as osint_get_entity or osint_list_entity_types.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), so the description's added value is the disclosure that recommendations are deterministic and explained, plus the scoring model (priority entity, unexecuted transforms, historical performance / learning from results). That tells the agent results are reproducible and justified, which annotations cannot convey. It does not say how suggestions are ordered or returned.

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 densely packed sentence with no filler, and the core recommendation logic is front-loaded. It is slightly jargon-heavy ('entidad prioritaria x transform aplicable'), which costs a little parsing effort but no wasted content.

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 still conveys the shape of the answer (ranked, explained next actions) and the inputs to that ranking, which is the essential context for a read-only advisory tool. Missing details: whether an empty result means 'exploration exhausted' and the ordering/confidence of suggestions.

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 limit, case_id, include_stats and response_format are fully documented in the schema; the description only loosely ties to include_stats via the mention of 'rendimiento histórico del transform'. Baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb ('Recomienda') and a well-defined output: prioritized pivots computed from entity priority x applicable-but-unrun transform x historical transform performance. That framing distinguishes it implicitly from the execution siblings like osint_run_transform or osint_expand_entity, though no sibling is named.

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 agent can infer this is the 'what should I do next' tool, but there is no explicit when-to-use statement, no prerequisite (e.g., a case with prior exploration), and no pointer to osint_run_transform as the follow-up action once a suggestion is chosen.

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

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

Annotations already declare idempotent=true and destructive=false, but the description earns credit by making idempotency concrete: reinsertion 'fusiona fuentes y propiedades' rather than failing or overwriting. It also discloses normalization and the deterministic entity_id return, adding real context beyond the structured hints.

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 compact sentences, front-loaded with the core operation before secondary use cases and source guidance. Minimal waste, though the parenthetical and alternation of languages is slightly dense.

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 8-param upsert tool with full schema coverage and no output schema, the description covers the operation, idempotent merge behavior, and the deterministic return (entity_id). Safety is covered by annotations; only explicit alternatives 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?

Schema coverage is 100%, so all eight parameters are already documented. The description only adds a passing reference to source=<origen>, which the schema already covers; baseline 3 is appropriate since the schema does the heavy lifting.

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

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

States a specific operation (upsert = save-or-create an entity in a case) plus the resource and side behaviors (normalization, deterministic entity_id). It is clearly distinguishable from read/search siblings like osint_get_entity or osint_search_entities, though it never explicitly names osint_manage_entity as the alternative for non-upsert 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?

Provides one concrete usage context: dumping graph data sourced from other MCPs (MISP, ATT&CK, TheHive) via source=<origen>, and notes that reinsertion merges. However, it gives no explicit exclusions and does not clarify when to choose this over osint_manage_entity.

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