Subastech — subastas judiciales de inmuebles (BOE)

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so safety and repeatability are covered. The description adds auth requirements ('cuenta verificada', scope `alertas:write`) and reinforces non-destructive behavior ('sin borrarla'), which is useful context beyond the structured fields.

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

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

Two short sentences with zero waste. The primary action is front-loaded before the auth requirement, making it easy to scan and act on.

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

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

The tool has only two simple parameters, an output schema, and rich annotations covering safety/idempotency. The description adds the necessary auth scope and non-delete clarification, leaving nothing important for an agent to guess.

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 documents both `id` and `activa`. The description adds no additional parameter meaning, which is acceptable given the complete schema, making the baseline 3 appropriate.

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

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

The description states a specific verb pair ('Activa o pausa') and resource ('una alerta tuya'), and explicitly clarifies that it does not delete ('sin borrarla'), which distinguishes it from the sibling alertas_eliminar. An agent can route this correctly without opening any schema.

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

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

It gives a prerequisite (verified account, scope `alertas:write`), which is useful context, but does not explain when to use this tool versus alternatives like alertas_editar or alertas_eliminar. The usage is implied from the verb but not contrasted with siblings.

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

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

Beyond the annotations (which only say it is a non-readonly, non-idempotent mutation), the description discloses an auth scope requirement, a concrete side effect (confirmation email), and plan-dependent quota limits referenced via `ajustes`. This is substantive behavioral context, though failure/idempotency behavior is left to 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?

Four short sentences, each carrying a distinct load (purpose, precondition, side effect, limits, alternative) with the core action front-loaded.

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-param mutation with nested objects and an output schema present, the description covers the essentials an agent needs: what it does, auth requirement, side effect, quota dependency, and the read-only alternative. Return values need not be explained given the output schema.

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 and nested criterion is already documented in the schema. The description only names the top-level fields and adds no syntax or format detail beyond that, matching the baseline-3 rule.

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 ('Crea') and resource ('alerta de subastas') and enumerates the defining fields (criterios, tipos, cadencia, canales), which cleanly separates it from alertas_editar, alertas_eliminar, and alertas_activar.

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 preconditions ('Requiere cuenta verificada', scope `alertas:write`) and points to the non-mutating alternative ('Los mismos criterios se pueden previsualizar sin crear nada'), which effectively routes the agent to alertas_previsualizar. It stops short of naming that sibling explicitly.

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

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

Annotations already declare readOnly=false, destructive=false and idempotent=true, so the safety profile is covered. The description adds value beyond them: the auth scope requirement and the clarification that no email is dispatched (i.e. editing does not fire a notification). It does not clarify that all six fields are required (full replacement rather than a patch), which is the remaining 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?

Three short sentences, front-loaded with the action and the editable fields, then the prerequisite, then the behavioral note. 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?

With an output schema, full annotation set, and 100%-documented nested parameters, the description only needs to cover intent, auth, and side effects — which it does. It stops just short of stating that the call replaces the whole alert definition rather than patching it.

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

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

Schema description coverage is 100% and the nested criterios/quiet_hours objects are richly documented in the schema itself, so the baseline is 3. The description only lists field names already enumerated in the schema and adds no format, default, or constraint detail beyond it.

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

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

States a specific verb and resource ("Modifica una alerta existente") and enumerates the editable surface (nombre, criterios, tipos, cadencia, canales, horas de silencio). The word "existente" implicitly separates it from alertas_crear, but it never names a sibling explicitly.

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

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

It gives a real prerequisite (verified account, scope `alertas:write`), which is genuine usage guidance, but there is no when-to-use vs alertas_crear/alertas_activar/alertas_previsualizar routing. Usage is inferred 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 destructiveHint=true and idempotentHint=true, so the bar is lower, but the description still adds two things they do not cover: the deletion is permanent/irreversible and it requires a verified account holding the `alertas:write` scope. That auth requirement is genuinely useful pre-call 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?

Two sentences with no filler; the destructive/permanent nature is front-loaded before the auth requirement, so the most decision-relevant fact lands first.

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

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

For a one-parameter delete tool, an output schema exists (so return values need no explanation) and the schema fully documents the parameter. Combined with the permanence and auth-scope statements, an agent has what it needs, though a note on ownership limits or confirmation requirements would make it airtight.

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

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

Schema description coverage is 100% — the single `id` parameter is already documented in the schema, including its provenance from `alertas_listar`. The description adds no extra meaning about the identifier, 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 ('Elimina una alerta tuya'), scoped to the caller's own alerts, which cleanly separates it from alertas_listar, alertas_crear and alertas_editar. It stops short of naming any sibling explicitly, 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?

The description gives a precondition (verified account with `alertas:write` scope) but never states when to delete versus edit or otherwise manage an alert, nor any when-not guidance. Usage is implied rather than instructed.

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/openWorldHint=false, so safety is covered structurally. The description adds the auth scope requirement and the pagination contract (max 20 per page, response carries `total`, `paginas`, `hasMore`), which is genuine extra context beyond the annotations.

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

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

Three tight sentences, front-loaded with the purpose, then prerequisites, then pagination. Every sentence carries information, though the pagination/response details partly duplicate what the schema and output schema already state.

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, zero-required-param listing tool with an output schema and rich annotations, the description covers purpose, auth scope and pagination adequately. It omits only edge behavior (empty results, ordering of alerts) and any routing advice toward sibling read tools.

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 `limite`, `pagina` and `por_pagina` are already fully documented, including the alias precedence rule. The description repeats the page-size cap and names two of the three params but adds no semantics beyond the schema, 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 ('Lista') and resource ('tus alertas de subastas'), and enumerates the content returned (criterios, tipos de aviso, cadencia, canales, estado), which makes it unmistakable next to alertas_crear/editar/eliminar/activar/previsualizar. It does not explicitly name a sibling it could be confused with, so it stops short of the top band.

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 — 'Requiere cuenta (scope `alertas:read`)' — and the pagination context tells the agent this is a browsing call, not a lookup. However, it never states when to prefer it over the related read tools (favoritos_listar, notas_simples_listar) or when alertas_previsualizar would be the right call instead.

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 real behavioral context beyond that: auth scope requirement (`alertas:read`), and that advanced criteria are silently ignored on non-Pro plans but reported in `ajustes` – a non-obvious degradation path.

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 workflow purpose, then outputs, then auth, then the plan caveat. No filler; each sentence carries distinct information.

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

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

An output schema exists, so return-value detail is not required, and the description still names the key outputs (match count, sample, `ajustes` warnings). Auth scope and plan gating are covered. Nothing critical is missing for an agent to call it correctly.

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

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

Schema coverage is 100% and the nested `criterios` object is richly documented in-schema, including Pro gating and format hints. The description restates the Pro requirement for `scoreMin`/`discountMinPct` but adds no syntax or semantics beyond the schema, 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 action (preview an alert), what it returns (match count, sample, fix-applicable warnings), and positions it relative to siblings by opening with 'Antes de crear una alerta', clearly distinguishing it from alertas_crear.

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

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

Explicitly says when to use it ('Antes de crear una alerta') and ties it to the creation workflow. It also names the plan-gating condition for advanced criteria, giving the agent enough to decide when results will be limited.

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 read-only/idempotent safety profile, and the description adds genuinely new behavior: required auth scope, plan-tier gating with a `locked` fallback payload, and the notable fact that it does not consume quota. Those are exactly the operational facts an agent cannot get from annotations or schema.

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 what the tool returns before moving to access conditions. Every clause carries information — scope, tier, fallback, quota — with 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 single-parameter read tool with an output schema and full annotation coverage, the description supplies everything else an agent needs: access requirements, tier-gating behavior, the shape of the gated response, and the cost model. Nothing material is missing.

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

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

Schema description coverage is 100% and the single `id` parameter is documented in the schema with its 10-character pattern, so the baseline is 3. The description adds no further parameter detail, which is acceptable here since there is nothing left to clarify.

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

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

States a specific verb+resource (viability verdict plus axes for an auction) and enumerates the four axes returned, which is far more informative than the title alone. It never names the adjacent siblings (subasta, informe, recomendaciones), so an agent must infer which one to pick, keeping this at a 4.

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 clear preconditions: account required, `informes:read` scope, Pro plan or higher, and explicitly what happens on lower tiers (returns `locked` with `upgradeUrl`). That is effectively a when-not condition, but it never contrasts the tool with the similarly-named `informe` or `subasta` siblings.

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, yet the description adds real value: anonymous calls return only 'fichas vigentes' from the public catalog, while authenticated calls also surface archived records flagged archivada: true. That result-set difference based on auth is not derivable from the structured fields.

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 then the access caveat. Slight redundancy in 'Pública, sin cuenta; sin cuenta solo devuelve...', but nothing extraneous overall.

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?

An output schema exists, so return structure need not be described, and annotations cover the safety profile. The description fills the remaining gap (auth-dependent result scope) for a single-parameter lookup tool; only edge-case behavior such as invalid or partial codes is left unstated.

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

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

Schema coverage is 100% and the single parameter is fully documented, so the baseline is 3. The description lists the accepted code types and the 'hasta 5' cap, but both merely restate schema details (maxItems: 5, items described as the same identifier types) without adding format or validation nuance.

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 ('Localiza') and resource ('subastas del BOE') and enumerates the exact identifier types accepted (referencia catastral, CRU, IDUFIR, BOE). The 'a partir de códigos' framing distinguishes it from text-oriented siblings like buscar_subastas, though no alternative 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?

Conveys useful context about access level ('Pública, sin cuenta') and how results differ by account state, which helps an agent decide whether the caller's context supports this tool. However, it never states when to prefer this over buscar_subastas or other search siblings, so the routing guidance is only implied.

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

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

Annotations only cover the safety profile (readOnly, idempotent, non-destructive). The description adds substantial behavior beyond that: locked fields return `locked` with `upgradeUrl`, plan-gated ordering degrades with a `degradado` field, hard cap of 20 per page, alias precedence for `limite`/`por_pagina`, and rejection of undeclared parameters.

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?

Front-loads the capability and filter axes in the first sentence, then layers access model, plan gating and limits in short declarative sentences. Every clause carries actionable information with no filler or repetition.

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

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

For a 16-parameter tool with nested objects, enums and an output schema, the description covers the decision-critical behavior (free vs Pro, locked/degraded responses, pagination limits). Remaining detail such as coordinate semantics and the provenance of provincia/municipio keys is left entirely to the schema, which 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 description coverage is 100%, so the schema already documents all 16 parameters, including enum values, bbox/cerca structure and slug patterns. The description reinforces the page-size cap and the `limite` alias precedence but adds no syntax or format detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Busca subastas judiciales de inmuebles del BOE') and enumerates the exact filter axes: provincia, municipio, tipo, precio, superficie, texto, zona, estado. An agent can distinguish this from siblings like `subasta`, `buscar_por_codigo` or `estadisticas_publicas` without opening any schema.

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?

Clearly states the access context: public and account-free, with scoring/ROI/intervinientes gated behind Pro, plus the exact degradation rules when the plan is missing (`orden: score` falls back to `recent`, `solo_viables` ignored). It does not name alternative tools for related tasks (detail lookup, analysis, statistics), so it stops short of explicit when-not 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 declare readOnly, idempotent, non-destructive, and closed-world. The description adds genuinely non-redundant context: the tool is public with no account required (auth/permission info) and it discloses a scope limitation (no market/pricing data). What it omits beyond that is minor for a read-only stats call.

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 with no filler; the scope/content comes first and the exclusions and public-access note follow. Slightly compressed 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 an output schema present, return-value detail is unnecessary, and the description supplies the access model, the content scope, and the Pro-feature exclusion. For a 2-param tool with full schema coverage and existing annotations, it is essentially complete, missing only an explicit named alternative.

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: it warns that property-type filters must use EXACT values and documents the municipality key format (`provincia:municipio`) for municipio_q, which is not evident from the param name alone.

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 concretely enumerates what the tool returns (catalog totals, provinces with active/historical auctions, property types, municipality search) and explicitly carves itself apart from the market-statistics tool by stating prices and award rates are a Pro feature. An agent can distinguish this from siblings like mercado or buscar_subastas without opening a schema.

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

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

It gives clear context for use ('Pública, sin cuenta') and a strong when-not signal ('No incluye estadísticas de mercado ... plan Pro'), which implicitly routes market queries elsewhere. It does not name a specific alternative tool, so it falls just short of the explicit alternatives a 5 requires.

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 safety profile (readOnly, idempotent, non-destructive), but the description adds genuinely new context: it is a curated Subastech knowledge base sourced from BOE, requires no account, is not legal advice, and notably is 'sin modelo de lenguaje' (not an LLM). That last point meaningfully sets expectations about output style.

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

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

Two tight sentences, front-loaded with the core action and scope, then the sourcing/constraint caveats. 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?

With an output schema present and 100% parameter coverage, the description need not explain return values. It supplies the sourcing, access, and non-advisory context an agent needs. It could be slightly stronger by clarifying scope boundaries versus the sibling analysis/search tools.

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

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

Schema description coverage is 100% with a single required 'pregunta' parameter already documented with an example. The description's concept list marginally clarifies what kinds of inputs are expected but adds no syntax or constraint detail beyond the schema; baseline 3 is appropriate.

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

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

Specific verb+resource: 'Explica un concepto de las subastas judiciales en España', with concrete example domains (depósito, cargas, posesión, cesión de remate, tipos de subasta). It clearly reads as a conceptual/knowledge-base tool, distinguishing it from sibling data tools like buscar_subastas, analisis_subasta, or subasta.

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 framing ('Base de conocimiento... textos generales, no asesoramiento') implies when to use it, but no alternative is named and no explicit when/when-not routing is given. 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 non-destructive, idempotent mutation behavior. The description adds genuinely non-structured context: the required auth scope and tier-based restrictions on what can be favorited. It does not restate annotation data, though it says nothing about return behavior (output schema covers that).

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, with the core action front-loaded before the authorization and plan caveats. 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 one-parameter mutation with an output schema and full annotations, the description covers purpose, auth, and plan gating adequately. The only minor gap is that it doesn't mention behavior when the auction is already favorited, though idempotentHint already signals this.

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

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

Only one parameter, and the schema documents it fully (100% coverage including the 10-character public-ID pattern). The description adds nothing about the `id` argument, so the baseline of 3 applies — the schema does all the work here.

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

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

States a specific verb+resource combination ("Guarda una subasta en tus favoritos") in the very first sentence. The verb 'guardar' cleanly distinguishes it from siblings like favoritos_quitar and favoritos_listar without needing to name 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?

Gives concrete preconditions for use: an account is required with the `favoritos:write` scope, and plan limits determine which auctions can be saved (Radar/Starter active-only; `fav.historico` is Pro+). It doesn't explicitly route to an alternative tool, but the conditions of use are clear.

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

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

Annotations already cover the safe-read profile (readOnly, idempotent, non-destructive). Beyond that the description adds the auth scope, pagination limits, and notably the Pro-plan gating where closed fields return `locked` with an `upgradeUrl` — real behavioral context. It does not restate 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?

A single dense paragraph, but front-loaded with purpose then prerequisites then pagination then plan gating. Every clause carries information; no filler. Slightly overpacked for one sentence-structure, but 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 an output schema present, return fields need not be explained, and annotations carry the safety profile. The description still supplies the auth scope, pagination behavior, and plan-gating edge case an agent needs to call and interpret this correctly, leaving little 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 description coverage is 100%, so the schema already documents `pagina`, `por_pagina`, and the `limite` alias with precedence rules. The description reinforces the 20-per-page cap but adds no syntax or alias detail beyond the schema. Baseline 3 is appropriate.

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

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

The description identifies the resource precisely ("Subastas que has guardado como favoritas"), which an agent can distinguish from the mutation siblings favoritos_anadir/favoritos_quitar. It does not explicitly name or contrast with those siblings, so it stops 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?

It gives prerequisites (account plus `favoritos:read` scope) and plan requirements, which is useful context, but it never states when to call this versus favoritos_anadir/quitar or buscar_subastas. Usage is implied by the noun phrase rather than spelled out.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false, and openWorldHint=false. The description adds real value beyond that by naming the required auth scope (`favoritos:write`), which the annotations do not carry. It stops short of describing failure/error behavior for a non-favorited id, so a 3 reflects partial added 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?

Two short sentences, front-loaded with the action and followed by the required precondition. Nothing is wasted and there is no boilerplate.

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 an output schema present, return values need no explanation, and the auth scope plus destructive/idempotent annotations cover the behavioral essentials. A minor gap remains around error cases (e.g., id not in favorites), but nothing blocking 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% and the single `id` parameter is fully documented with format and pattern in the schema. The description adds no format or semantic detail beyond what the schema provides, so the 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?

States a specific verb+resource: 'Quita una subasta de tus favoritos', which is unambiguous and easily separated from favoritos_anadir and favoritos_listar. It omits any explicit sibling reference, but the action itself is precise enough to route correctly.

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 the name and the removal verb, and it discloses the precondition of an authenticated account with the `favoritos:write` scope. However, it never states when to prefer this over alternatives or what happens if the auction isn't currently favorited.

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 read-only, idempotent, non-destructive, closed-world behavior. The description adds important behavioral detail beyond annotations: authentication/plan gating for premium fields and a specific fallback response ('locked' with 'upgradeUrl') when content is restricted.

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 tightly written sentences, front-loaded with what the tool does, followed by access and gating information. 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?

Given a simple one-parameter fetch, full schema coverage, an output schema, and annotations covering safety, the description adds the crucial missing pieces: public vs premium access and the locked-response behavior. Nothing an agent needs to call it correctly 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%, and the single parameter 'id' is fully documented in the schema (including that it comes from 'search' or a URL). The description adds no new parameter-level syntax or constraints, so the baseline of 3 applies.

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

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

States a specific verb ('Lee') and resource ('ficha de subasta') and the lookup key ('por id'), which distinguishes it from search-oriented siblings. It also enumerates the returned fields, making the tool's scope clear without opening the schema.

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 clear context: public read with no account, but premium fields require an account and Pro plan or higher. It does not explicitly name alternative tools or state when not to use it, but the id-based retrieval context is sufficient for correct selection.

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

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

Adds substantial behavior beyond the annotations (which already declare it read-only and idempotent): it never consumes quota or charges, requires a specific OAuth scope, returns `unlock_required` with an unlock URL plus an optional `compra.paymentLink`, and discloses that part of the output is AI-generated. That is exactly the extra context an agent needs to handle failures gracefully.

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?

Front-loads the purpose and packs auth, tier, quota, and disclosure facts into one dense but readable paragraph with no filler sentences. Slightly long, but every clause earns its place.

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

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

Given a rich output schema (so return shapes need no explanation) and full annotation coverage, the description still supplies auth scope, tier gating, the unlock fallback, quota/cost guarantees, and AI-content disclosure. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% and the enum already documents `web`/`basic`/`completo` and the unlocked-only condition, so the description largely repeats the schema. It adds only the behavioral consequence (the `unlock_required` fallback), which is not strictly parameter meaning, so baseline 3 fits.

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

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

States a specific verb+resource: it produces a viability report (`informe de viabilidad`) for an auction and enumerates exactly which sections it can contain. It does not explicitly differentiate itself from close siblings such as `subasta` or `analisis_subasta`, so an agent must infer the boundary, but the purpose itself is unmistakable.

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 real preconditions: verified account with scope `informes:read`, and that `basic`/`completo` are only served if already unlocked, otherwise it returns `unlock_required`. It stops short of an explicit when-to-use-this-vs-siblings statement, but the situational context is clear.

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

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

Beyond the readOnly/idempotent annotations, the description discloses the auth scope needed, the subscription-tier prerequisite, and the exact error contract (`plan_required` with `locked`) when the tier is insufficient. That is precisely the operational context annotations cannot carry.

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: the first defines the resource and dimensions, the second covers prerequisites and failure behavior. No filler, and the core purpose is front-loaded.

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?

An output schema exists, so return values need not be described. With both params fully documented in the schema and the entitlement/error path spelled out, nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the combinatorics the schema does not state: the filters are optional and may be used together ('por provincia y/o tipo de inmueble'), clarifying that neither is required.

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

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

States a concrete verb+resource: statistics on resolved auctions, enumerating the metrics (award rate, real discount, prices) and the breakdown dimensions (province and/or property type). It does not differentiate itself from plausible siblings such as `estadisticas_publicas`, `informe`, or `analisis_subasta`, which is the main gap.

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

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

It gives entitlement context (requires an account with `informes:read` and a Pro plan or above) and the failure mode, which implies when the call will succeed. However, it never says when to pick this tool over `estadisticas_publicas` or `informe`, so the routing guidance is only implied.

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 openWorldHint=false, so the safety profile is covered. The description adds important behavioral context beyond annotations: it requires an authenticated account and the cuenta:read scope, and it lists the categories of data 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?

It is a single compact sentence that front-loads the returned data and follows with the access requirement. No words are wasted.

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

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

For a no-parameter, read-only account introspection tool with an existing output schema and full annotation coverage, the description supplies everything needed: what data is returned and the required account/scope. Return-value formatting is rightly left to the output schema.

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 takes zero parameters, so there are no parameter semantics to explain. Per the rubric, zero parameters establish a baseline of 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 names a specific resource (account information) and enumerates exactly what it exposes: plan, report quota, available functions, token scopes, usage limits, and useful URLs. It is far more specific than a tautology, but it does not explicitly state a verb like 'retrieve' and does not differentiate itself from siblings such as planes or informe.

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 prerequisite ('Requiere cuenta', scope cuenta:read) but no guidance on when to choose this tool over alternatives. There is no explicit when/when-not statement and no sibling tool is named as an alternative.

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

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

Annotations already declare this is a non-destructive, idempotent, read-only check. The description adds real value beyond them by disclosing the required auth scope (`notas:read`) and the conditional nature of the return (URL only appears once the PDF is ready), which the annotations do not cover.

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

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

A single compact sentence, front-loaded with the outcome and followed by the auth constraint. Every clause carries information; nothing is padded, though it is terse enough to border on under-specification.

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 100% schema coverage, an output schema that carries the return shape, and annotations covering the safety profile, the description only needs to add the auth scope and readiness condition, which it does. Nothing materially required to invoke it correctly is missing.

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

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

Schema description coverage is 100% and the single `pedido_id` parameter is already fully documented in the schema, including that it comes from `nota_simple_pedir`. The description adds no extra parameter meaning, so the baseline of 3 applies.

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

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

The description states a specific verb-and-resource: it returns the status of a nota simple request plus the URL to view or download the PDF once ready. It is clearly distinguishable from the sibling nota_simple_pedir (which creates the request), though it does not name those siblings 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 agent must infer this is the tool to poll after calling nota_simple_pedir. It does surface the precondition of an account with scope `notas:read`, but gives no explicit when-to-use/when-not guidance or alternative routing.

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

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

Adds substantial context beyond annotations: price and retention model, required auth scope, failure conditions, returned pedido_id/url, paymentLink behavior, the fact that payment is never completed here, idempotency semantics, and a daily limit. This is rich and consistent with readOnlyHint=false, idempotentHint=true, and destructiveHint=false.

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?

Information is front-loaded with the action, price, and prerequisites before return behavior and limits. It is dense but appropriately sized for a tool with several operational constraints, though the single semicolon-heavy sentence is not maximally readable.

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?

Covers cost, auth, prerequisites, failure modes, return identifiers, payment flow, idempotency, and rate limits. With an output schema present, no essential agent-facing behavior is missing.

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

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

Schema description coverage is 100%, so the single id parameter is already documented in the schema. The description mentions auction CRU/IDUFIR requirements but does not add syntax or format guidance beyond what the schema provides.

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

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

States a specific verb and resource: initiating the order for a registral nota simple of an auction. It is clear in isolation, but does not explicitly differentiate itself from siblings such as nota_simple_estado or notas_simples_listar.

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 clear preconditions: verified account with scope notas:write and auction with CRU/IDUFIR, plus the not_orderable failure condition. It does not explicitly name alternative tools or when another sibling should be used instead.

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, so the safety profile is covered. The description adds value beyond them: the required auth scope, the pagination regime with a hard cap of 20 per page, and the shape of the paging envelope (total, paginas, hasMore).

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 tight semicolon-separated clauses with no filler: what it returns first, then the auth requirement, then pagination. Dense but well front-loaded and cheap to read.

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?

Auth, pagination limits and page-size constraint are all present, and an output schema exists so return values need no further explanation. The only real omission is routing relative to sibling tools, which is minor for a simple paginated list.

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 pagina, por_pagina and the limite alias are already documented, including bounds and precedence. The description reinforces the max of 20 per page but does not document the limite alias, so it adds little beyond the schema. Baseline 3 is appropriate.

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

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

States a concrete verb (listar) applied to a concrete resource (pedidos de nota simple registral) and adds useful framing (price of 20 €, includes status). It is clearly distinguishable from nota_simple_pedir and nota_simple_estado by resource plurality, though it never names those siblings 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 one real precondition – an account with scope `notas:read` – which is genuine usage guidance. However it never states when to prefer this over sibling tools such as nota_simple_estado (single request status) or alertas_listar, so the agent must infer the boundary itself.

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 the auth-relevant fact that the resource is public and requires no account, which the annotations do not state, making it a useful 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?

A single dense sentence that front-loads the resource and lists the scope without any filler. 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?

An output schema exists, so return values need not be explained. The description covers the resource, scope, and access model adequately; only a hint about when an agent should prefer it over other informational siblings is missing.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond what the empty schema already conveys.

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 resource (Subastech pricing plans) and enumerates the tiers covered, plus the content returned (precios y comparativa de funciones). It is clearly distinguishable from the auction/search siblings, though it does not explicitly name any sibling it differs from.

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?

"Pública, sin cuenta" implies the context (consult pricing without authentication), but there is no explicit when-to-use or when-not-to-use guidance and no alternatives are named. Usage is left to inference.

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 real value beyond that: an auth requirement (scope `cuenta:read`) and the fact that output differs by plan (scoring-based for Pro+, profile + end-date ordering otherwise) — behavior an agent could not infer from structured fields.

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 tight sentences, front-loaded with what the tool returns, then the access requirement, then the behavioral nuance. Each sentence adds distinct information with no repetition or filler.

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

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

An output schema exists, so return shape need not be described, and annotations carry the safety profile. With auth scope and plan-dependent behavior documented, an agent has everything needed to decide to call it and predict the result set.

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 takes zero parameters and the schema is trivially complete, so there is nothing for the description to clarify. Baseline for a parameterless tool is 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?

States a specific verb+resource ('Subastas recomendadas') and the personalization basis ('según tu historial'), with the fields it draws on (tipo, precio, provincias) and the web equivalent ('para ti'). Clear enough to distinguish from generic search, though it never names a sibling like 'similares' or 'buscar_subastas' to sharpen 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?

Gives a prerequisite (account with scope `cuenta:read`) and explains the plan-dependent ranking, which implies when the tool is applicable. However, it never states when to prefer this over alternatives such as 'similares' or 'buscar_subastas', so selection guidance remains 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed world), so the bar is lower. The description still adds real context: no account required, results are official BOE data, the returned discount is computed by BOE arithmetic, and the result set is capped at 15.

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 plus two short fragments ('Pública, sin cuenta. Máximo 15.'), front-loaded with the resource and its key qualifier. Minor redundancy in repeating 'Máximo 15' from the schema, but no wasted sentences.

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

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

With an output schema present, return-value documentation is unnecessary, and the description covers what matters: data source, official-result filter, optional province scoping, public/no-account access, and the 15-item cap. Complete enough for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already explains both parameters, and the description mainly restates that provincia filtering is optional and that the cap is 15. Baseline 3 is appropriate since it adds little beyond what the schema provides.

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

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

States a specific resource and scope: latest BOE auctions that have an official result (adjudicadas), optionally filtered by province, returning the hammer price and the real discount over the appraisal. An agent can distinguish this result-set from general search tools, 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 implied by 'Últimas subastas ... con resultado oficial (adjudicadas)' — use it when you want closed/finished auctions rather than open listings — and 'Pública, sin cuenta' tells the agent no auth is needed. However, no alternative tool (e.g. buscar_subastas, estadisticas_publicas) is named or excluded, leaving routing to inference.

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 behavior. The description usefully adds the auth posture ('Pública, sin cuenta'), but the returned field list is redundant with the existing output schema, so the net addition beyond structured data is modest.

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?

Compact and front-loaded: the core action and scope come first, then access requirements and the follow-up pattern. No filler sentences, though it is dense and mixes return-shape detail that the output schema already covers.

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 an output schema present, rich annotations, and a single fully documented parameter, the description only needs to add scope, access, and chaining. It covers all three, though it omits any differentiation from the overlapping search siblings.

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?

One parameter at 100% schema coverage, and the schema already documents it as 'Búsqueda en lenguaje natural'. The description repeats that phrasing without adding format, length (maxLength 200), or query-construction guidance, so it is 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?

States a specific verb and resource: natural-language search over BOE judicial auctions, plus the ChatGPT deep-search compatibility. However, it does not distinguish itself from the very similar sibling `buscar_subastas` (or `buscar_por_codigo`), leaving the agent to guess which search entry point applies.

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

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

It implies usage context ('Pública, sin cuenta') and hints at a follow-up path ('Cada resultado se lee completo por su id'), which routes toward a detail/fetch tool. But it never says when to choose this over `buscar_subastas` or `similares`, so the selection guidance is only implied.

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 readOnly/idempotent/safe. The description adds real behavioral context beyond them: it requires an account with scope `informes:read`, and the result ordering depends on plan tier (scoring for Pro+, end-date otherwise). The mention of `metodo:` values is slightly ambiguous since no such input parameter exists, but the auth and ordering disclosures are valuable.

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

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

Three sentences, front-loaded with the core purpose and similarity criteria, then auth and ordering. Reasonably efficient, though the plan/ordering sentence is the most detail-heavy and slightly tangential.

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 an output schema present, return values need not be explained, and the description covers the key non-obvious facts an agent needs: auth scope and tier-dependent ordering. It is close to complete for this simple two-parameter read tool, with only the misleading `metodo` reference as a minor blemish.

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 `id` (with pattern) and `limite` (1-10). The description adds no syntax or format detail beyond it, and the `metodo` tokens it references are not actual parameters, 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+resource ('Subastas parecidas a una dada') and even enumerates the similarity dimensions (mismo tipo de inmueble, banda de precio, cercanía), so the agent understands the operation without opening the schema. It does not explicitly differentiate itself from siblings like buscar_subastas or subasta, keeping it short of a 5.

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

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

Usage is only implied: the tool finds auctions similar to a given one. There is no explicit when-to-use vs when-not guidance nor any named alternative (e.g. buscar_subastas for general search), so the agent must infer the routing.

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

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

Annotations cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds genuinely useful behavior beyond them: the tool is public with no account, several sections (scoring, veredicto, cargas, ROI, valoración, intervinientes) are tier-gated behind Pro, and gated content is signaled via 'locked' plus 'upgradeUrl' rather than erroring. That partial-result contract is exactly the kind of detail annotations cannot express.

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 that lead with the resource and lookup keys before the access/tier caveat. Every clause carries information (fields returned, public access, Pro gating, locked contract), with no filler. It is packed but 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?

With an output schema present and annotations covering safety, the description only needs to add access, identification and gating context — and it does all three. An agent knows how to identify the auction, what it may get back, and what a gated response looks like, so nothing material is missing.

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

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

Schema description coverage is 100%, so the meaning, pattern and max length of id, url and boe_id are already documented — including that boe_id 'devuelve todos los lotes'. The description restates the 10-character id form and lists the same lookup modes without adding format, precedence, or whether at least one parameter must be supplied. 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 concrete resource (ficha pública de una subasta del BOE) and the three ways to identify it (10-char id, app.subastech.com URL, SUB- BOE id), then enumerates the returned fields. It implicitly separates itself from paid siblings like analisis_subasta by declaring 'pública, sin cuenta' versus the Pro-only scoring/veredicto. No sibling is named outright, but an agent can distinguish it without opening other schemas.

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 real usage context: no account required, lookup by id/url/boe_id, and the behavior when a section is gated ('se devuelve locked con upgradeUrl'). However it never states when to prefer this over buscar_subastas, buscar_por_codigo or analisis_subasta, so routing between siblings is left to inference.

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