gettargetmarket: the Target Market door

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

Beyond the annotations, the description discloses validation checks, storage at the subject's home node, immutable versioning with supersession, signing behavior, and receipt semantics. This gives the agent substantial operational context for a non-idempotent write operation.

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

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

The purpose is front-loaded and there is no filler, but the main content is a dense single sentence with several clauses. It is concise, though the structure could be easier to parse.

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 mutation tool with no output schema, the description covers authentication, validation, storage/versioning, signing, and receipt behavior. An agent has enough information to call it correctly and understand the main side effects.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds useful constraints, notably that the manufacturer LEI must match the filer identity and the live subject's record, and that the filer value is passed as a Bearer token.

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: filing a target market statement for an ISIN by the manufacturer's agent under its filer identity. This clearly distinguishes it from sibling read/verify tools such as get_target_market and verify_target_market.

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

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

The description implies when to use it by specifying who files and under what identity, but it does not explicitly state when not to use it, prerequisites beyond the Bearer header, or which sibling to use for checking existing statements. Usage is inferable rather than guided.

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 establish the safe-read profile, and the description goes beyond them with real behavior: the result is either one ACM-68000 signal or an evidence_gaps list of pages checked, elements carry back-pointers to chapter/record fields, and output is signed (kid allooloo-eco-2026-10) and receipted at mcp.rco-records.ai. That is meaningful disclosure for a read tool, though the jargon reduces its practical value.

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 unbroken sentence stitched together with colons and em-dashes, and roughly half its tokens are opaque codenames and identifiers. The resource is front-loaded, but the signing/receipt clause and nested parentheticals make it hard to scan rather than economical.

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 steps in to describe both return branches (signal vs evidence_gaps), provenance of elements, and the signing/receipt envelope — enough to interpret a response. It stops short of explaining failure modes or how to obtain valid client categories in practice, which is a real gap given the strict enum-like matching requirement.

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 does add one linkage not in the schema — that the subject's home market determines which chapter supplies the valid client_category — but it adds nothing about subject formats or how the chapter's category list is discovered.

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?

It names a specific resource ('AIO-10060 orderability outcome') and scope (one security + one client category of the home-market chapter), and ties itself to get_record's subject resolution. But the core nouns — 'AIO-10060', 'chapter', 'node', 'apex', 'door' — are undefined internal jargon, so an agent that hasn't been primed cannot tell what domain object is actually returned without guessing.

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 statement of when to call this instead of get_record or get_signal; the only sibling reference ('as for get_record') is an analogy about subject resolution, not a routing rule. The distinction from get_signal, which sounds closest in output shape, is never addressed.

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, and closed-world behavior, so the safety profile is covered. The description adds a useful architectural trait — that the record is served by the owning node's regional door and never held at the apex — but says nothing about auth needs, error behavior, or what happens when the identifier is unknown.

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 begins with the verb and resource before adding nuance. It is appropriately sized, though the parenthetical about the apex is niche jargon that earns its place less clearly than the first half.

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

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

With no output schema and 0% parameter coverage, the description carries the full burden of explaining the return shape and how identifier/version resolve. It does neither, and the appeal to node topology does not tell the agent enough to call the tool correctly.

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

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

Schema description coverage is 0%, and the description mentions neither the required identifier nor the optional version. The word "full" hints that no projection is applied, but that does not compensate for two completely undocumented parameters.

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

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

States a specific verb ("Return") and resource ("the full Capital Markets Record"), which is enough to distinguish it from the list_* and resolve_issuer siblings. However, it never explicitly contrasts itself with those siblings, and the second clause about the "regional door" and "apex" is jargon that obscures rather than clarifies.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the sibling tools a caller might reach for instead. The agent must infer the usage context purely from the name.

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

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

Annotations already cover the read-only/idempotent/non-destructive profile, and the description adds genuine context beyond that: receipting at mcp.rco-records.ai with the door as writer, both manufacturer-side and node signatures returned, and a soft not_found status instead of an error. These are non-obvious behaviors an agent could not derive 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?

Front-loaded with the resource and its scope in the first clause, and the not_found contract is cleanly separated into a second sentence. The single long sentence is dense and carries some opaque internal jargon ('the door as writer'), but nothing is redundant.

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

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

With no output schema, the description does the necessary work of describing the return (the statement, both signatures, not_found status) and the side effect (receipting). It leaves the shape/format of the returned statement unspecified, a modest gap for a read tool.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by tying the three parameters into a coherent mutually-exclusive selection model (current vs explicit version vs last-filed-at-or-before as_of). It adds little on the subject/ISIN format, which the schema already documents.

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 (read) and resource (the manufacturer's target market statement for an ISIN) with its home-node location, and the version-selection semantics clearly separate it from write/verify siblings. It stops short of naming siblings such as verify_target_market or list_target_market_versions, so the routing is inferred rather than spelled out.

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

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

Use context is clear: fetch the current, a specific, or an as-of version of a statement, with the no-statement case explicitly answered as status not_found rather than an error. No exclusion or alternative-tool routing is given, so an agent must infer that file_target_market is the write path.

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, and openWorldHint=false, so the safety profile is covered. The description adds content-level context — that it reads nodes.json, flags which nodes are live, and includes regional doors and Agent Cards — but says nothing about size, ordering, or caching.

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 no filler, front-loading the resource and then the payload. Some jargon ('regional doors') is left undefined, which costs a point.

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, so the description carries the burden of describing returns; it does name the four content types an agent will receive. It stops short of framing the response shape (array? keyed by region?), leaving a modest gap for a no-param list 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?

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline of 4 applies. The description correctly implies no filtering inputs are needed.

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

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

States the resource (market nodes) and enumerates the contents returned: roster entries from nodes.json, live status, regional doors, and Agent Cards. That distinguishes it from get_eco, get_signal, and resolve_issuer, though the verb is implied rather than stated ('Every market node on the roster...').

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

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

No statement of when to call this versus the siblings (get_eco, get_signal, resolve_issuer), nor any preconditions. Usage is only inferable from the noun phrase 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, so the safety profile is covered; the description adds genuine value by stating retention behavior ('nothing is deleted') and the exact fields returned, which annotations cannot express. Minor gap: no ordering or pagination behavior for a potentially long version list.

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 dense sentence with zero filler, front-loading the scope ('every version ... for an ISIN') before the returned fields. Slightly telegraphic phrasing ('its path under tm/') but nothing is wasted.

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

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

For a one-parameter read with no output schema, the description covers scope, retention semantics, and the returned field set — enough to call it correctly. Ordering/limit behavior is the only meaningful omission.

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 subject parameter is fully documented in-schema, including the TEST namespace convention. The description only restates 'for an ISIN', adding nothing 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?

Names a specific resource (target market statement versions) scoped to an ISIN and even enumerates the returned fields (filed_at, supersedes, tm/ path, sha256). It doesn't explicitly contrast with the singular get_target_market sibling, 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?

'Every version' and 'nothing is deleted' imply the historical/audit use case, letting an agent infer this is the versioned counterpart to get_target_market. There is no explicit when-to-use or when-not-to-use statement naming 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 readOnly, idempotent, non-destructive and closed-world behavior. The description adds genuinely new behavioral context — that the apex node resolves ownership and forwards to a regional node for the summary — but says nothing about failure modes (unknown identifier), latency, or what the summary contains.

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

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

A single sentence, front-loaded with the purpose before the routing detail, with no filler. The trailing architecture jargon ('apex names the owning node and forwards to that node's regional door') is dense and slightly obscures rather than clarifies.

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

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

With no output schema and no annotations covering the return value, the description carries the burden of explaining results, yet only says 'the record summary' without defining it. For a single-parameter lookup the input side is well covered, but the output side and the internal routing metaphor remain under-specified.

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

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

Schema coverage is 100% and the parameter description already spells out ticker formats, ISIN, LEI, exact legal name and sourced alias. The description adds little beyond repeating 'ticker, ISIN or LEI', and in fact omits the legal-name and alias forms the schema supports, so it is baseline at best.

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 concrete verb ('Find') and resource ('listed company') and enumerates the identifier kinds (ticker, ISIN, LEI), so an agent can tell what the tool does. However, it never contrasts itself with the nearby sibling get_record, even though it also mentions returning 'the record summary', leaving some ambiguity about which tool to pick.

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

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

The description implies the tool is for looking up a company from an identifier, but offers no explicit when-to-use guidance, no when-not-to-use, and no comparison to siblings like get_record or list_nodes. The agent must infer that resolution is the entry point to the record summary.

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, but the description adds real context: verification is public (no auth), fully offline/deterministic, and the keys come back in the answer plus a published JWKS URL. It also clarifies that supplying a statement performs no read. The shape of the returned verdict itself is only implied, not 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?

The core question is front-loaded in the first clause, followed by the signature/key specifics and then the input alternatives. It is dense with domain jargon ('the door's signature', 'home node') but no sentence is filler.

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

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

With no output schema, the description still manages to say the keys are included in the answer and where to get them offline. What is missing is an explicit statement of the return verdict (valid/invalid per signature) and error behavior when a signature fails, which for a verification tool is the one lingering 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 67% and 'version' has no description at all, but the text adds meaning the schema cannot: with zero required params, it tells the agent the two valid input shapes (statement alone, or subject+version) and that supplying the statement avoids any read. It does not explain what version means semantically beyond the pairing.

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 ('whether a stored statement's two signatures verify against the published keys') and immediately names the two artifacts checked (sig, node_sig) with their key ids. This is clearly distinguishable from the sibling read tools (get_target_market, get_record) which fetch rather than verify.

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?

'Give the statement itself (nothing is read) or subject and version' gives concrete invocation patterns and clarifies a non-obvious mutual alternative. It stops short of naming when to prefer this over a sibling or when verification is required, so it is clear context without explicit exclusions.

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