Test

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

Goes well beyond the readOnly/openWorld annotations by disclosing the cost (1 credit), revealing that this call performs the base company lookup internally, and warning that employee figures come from a register interval that can lag reality by months. The data-freshness caveat and cost/overlap semantics are exactly the kind of 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?

Front-loaded with the output contents, then cost, then the sibling comparison — a sensible ordering. It is dense and somewhat run-on in the middle (employee counts, intervals, FTEs, tegningsregel in one clause), so it is efficient rather than elegant.

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

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

There is no output schema, so the description carries the return-value burden and discharges it by naming every returned field group, plus cost, freshness caveat, and when to prefer get_company. An agent has everything needed to call it and to anticipate the response.

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

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

Schema coverage is 100% (the single cvr param is already documented with pattern and format), so the baseline would be 3. The description adds real value on top by specifying how to obtain the identifier — CVR lookup only, route to search_companies when you merely have a name — which is not in the schema.

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

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

Opens with a specific plain-language statement of the operation — what one Danish company does and how big it is — then enumerates the exact fields returned (industry code, secondary industries, employee interval, FTEs, capital, tegningsregel, purpose). It is clearly distinct from siblings like get_contact_details, get_ownership, or get_company.

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 explicit routing for the two obvious forks: use search_companies first when you only have a name, and call get_company instead when the user wants more than this slice, since it costs the same. That is when-to-use, when-not, and the named alternative all in one place.

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 declare readOnly/openWorld/non-destructive; the description adds substantial operational context beyond them — oldest-first ordering, truncation to the most recent 20 with an explicit notice, a 2-credit cost model, and a no-cost tier_restricted refusal with remediation guidance.

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?

Content is front-loaded: what the section contains comes first, then ordering/truncation, then cost and alternatives, then error handling. It is on the long side for a single-parameter read tool, but nearly every clause carries actionable information rather than repetition.

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

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

With no output schema, the description must convey return characteristics, and it does: ordering, truncation behavior, and the substantive fields (events with subscription rate and implied valuation). Exact item structure isn't spelled out, a minor gap for a simple 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% and the single cvr parameter is fully documented with a pattern, so baseline is 3. The description adds modest value by framing the lookup as CVR-keyed and pointing to search_companies as the way to obtain a CVR when only a name is available.

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 (capital events of one Danish company) and enumerates what it contains: formation, increases and reductions, subscription rate and implied valuation. This clearly separates it from siblings like get_capital_overview and get_company without requiring the schema to be opened.

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 explicit routing rules: use search_companies first when only a name is known, and use one get_company call with `sections` when the profile or multiple sections are needed. It also covers the refusal path (tier_restricted) and tells the caller to report the limitation rather than imply missing data.

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

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

Beyond the readOnly and non-destructive annotations, the description discloses plan requirements, credit cost, currency handling, estimation caveats, the meaning of kursOplyst=false, that ownership changes have no public purchase price, ordering, and truncation to the most recent 20 rounds. These are valuable behavioral details not present in the 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?

The text is front-loaded with the core purpose and contains no filler, but it is a dense single paragraph with many semicolon-separated clauses. It is appropriately comprehensive for a complex due diligence tool, though it could be easier to scan if structured.

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

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

There is no output schema, so the description carries the full burden of explaining returned content. It covers the main outputs, estimation caveats, currency behavior, ownership-change limitations, history truncation, and access requirements, making it complete enough to call correctly.

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

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

The schema already fully documents the single cvr parameter with an 8-digit pattern, and the description adds no further parameter-specific syntax or constraints. With 100% schema description coverage, the baseline of 3 is appropriate.

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

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

The description states a specific resource (capital history of one Danish company) and enumerates exactly what is returned: formation, capital increases, reductions, ownership changes, cap tables and statistics. It also differentiates from the sibling get_capital_events, which is positioned as the lower-plan alternative for registered capital changes alone.

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

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

It gives explicit usage context: requires Pro plan or higher and costs 3 credits, and on a lower plan the agent should use get_capital_events instead. This names the alternative and the condition that selects it, leaving little 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?

Beyond the readOnly/destructive annotations, it discloses a non-obvious credit model (1 base + 1 per section vs 2 for section tools), added latency, plan gating with graceful degradation ('sections the plan does not cover are skipped... listed under warnings'), and a contractual restriction on realOwners that a paid plan alone does not unlock. It also characterizes creditRisk as an algorithmic SI-score rather than a credit rating and flags courtData as large.

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

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

Front-loaded with purpose, then cost trade-off, then per-section bullets, so an agent can stop reading early. It is long, but nearly every bullet carries decision-relevant information; a slight trim of the repeated cost mentions would tighten it further.

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 explains what the base response returns, what each optional section yields, and how partial results surface via warnings. An agent has everything needed to call it correctly and to report withheld data to the user.

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 already 100%, but the description adds real meaning to each enum value that the schema only names: financials covers up to four years with report links, ownership uses banded percentages, realOwners is UBO/confidential, creditRisk is an SI-score 0-10 with flags, courtData spans 8 authorities plus Statstidende. This is substantive value above the enum list.

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 ('Get full details for one Danish company by CVR number') and immediately enumerates what the base response contains (name, status, address, industry, employees, capital, purpose, history). It explicitly separates itself from the single-section siblings (get_financials, get_management, get_ownership), so an agent can choose without opening either 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?

Gives a concrete decision rule backed by cost: 'Take it when the user wants the profile with one or more sections... while each section tool costs 2 on its own' and the inverse exclusion 'For one section alone, its section tool returns the same data in a smaller answer.' It also warns to request extra sections only when needed and to request courtData only for legal/regulatory history.

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, non-destructive, openWorld), yet the description adds real behavior: the cost is 1 credit and it is described as the cheapest call, and it explains the ophoert/ophoersDato trap for closed sole proprietorships. It stops short of error or rate-limit behavior, so it is strong rather than exhaustive.

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 longer than typical but front-loads the return contents, then the interpretation caveat, then the routing and cost. Nearly every sentence carries decision-relevant information; the closing cost/get_company sentences are dense but not 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 must describe return values and does: name entries and status entries with from/to dates, founding date, company form, plus the ophoert/ophoersDato fields. Nothing an agent needs to call it or read the result 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% and there is a single CVR parameter, so baseline is 3. The description still adds meaning: the lookup key is the CVR, CVR survives a rename so old and current names are the same legal entity, and it redirects to search_companies when only a name is known.

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 precise verb-and-resource: every name and every status a Danish company has carried, with date ranges, founding date and company form. It explicitly distinguishes itself from the sibling get_company ('returns the whole profile') and names the CVR key, so an agent can route 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?

Gives concrete when-to-use rules: use search_companies first when you only have a name, and use get_company instead when the user wants more than name/status history. It also warns which field answers the 'is it closed' question ('ophoert', not 'status' alone), which is guidance an agent cannot infer elsewhere.

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 annotation, the description discloses the credit cost, the marketing-protection flag and its legal implication, and that empty fields are filled from the provider's own contact data where the plan covers it. These are meaningful behavioral traits an agent needs.

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

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

The description is front-loaded with the returned fields, then adds usage and legal caveats. It is dense but every sentence carries useful information; minor tightening could improve flow.

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?

Because there is no output schema, the description appropriately explains what is returned, including the registered dates and the reklamebeskyttet flag. It also covers cost and sibling alternatives, making it complete for this 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?

There is a single required parameter and schema coverage is 100%, so the schema fully documents the CVR number format. The description reinforces lookup by CVR but adds no format or validation detail beyond the schema.

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

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

The description states a specific resource (phone, email, website and registered address for one Danish company) and its scope (one company, looked up by CVR). It distinguishes itself from siblings such as get_company 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 explicit when-to-use alternatives: use search_companies first when only a name is known, and use get_company instead when the user wants more than contact details. Cost equivalence with get_company is also 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 the safe read profile, and the description layers on what they cannot: the cost (2 credits), the expected result size ('Large'), and the exact failure mode — a tier_restricted refusal at no cost that must be reported to the user rather than as absent data. That last point is genuinely non-obvious agent guidance.

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 scope before the cost and alternatives, and every sentence carries actionable content. It runs five dense clauses in a single block, so cost, size and the section-bundling advice compete for attention, but nothing is padding.

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

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

With no output schema, the description still conveys enough to call correctly: source coverage, expected volume, cost, and failure behavior. Return shape (case identifiers, dates, court names) is left implicit, which is a minor gap for a data-retrieval tool with no schema to fall back on.

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 already documents the 8-digit CVR pattern, so the schema does the heavy lifting. The description still adds routing value by telling the caller how to obtain the CVR when only a company name is known, which is meaning beyond the schema.

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

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

States a specific resource (civil court cases, decisions, orders, recalls, notices from 8 Danish authorities plus the Statstidende gazette) for exactly one Danish company, including matching under earlier names. That scope cleanly separates it from every sibling in the list, which cover financials, ownership, management and profile.

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 an explicit inclusion rule ('call it only when the user asks about legal or regulatory history'), a prerequisite path ('use search_companies first when you only have a name'), and a named cheaper alternative ('one get_company call with `sections`'). Both when-to-use and when-not-to-use are covered with the sibling tool named.

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

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

Annotations already mark it read-only and non-destructive, but the description adds real behavioral context beyond them: a 2-credit cost, the tier-restriction refusal path with the exact error code, the zero-cost nature of that refusal, and the score's nature as an algorithmic rating. These are exactly the operational details 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?

Three sentences, front-loaded with what the value is, then cost and alternatives, then the failure mode. Every sentence carries distinct decision-relevant information with no waste.

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 no output schema, the description covers what is returned (score plus underlying warnings/flags), what it costs, when to prefer an alternative, and how a restricted plan manifests. Nothing needed 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 coverage is 100% and the sole parameter is already documented as an 8-digit CVR, so the schema does the heavy lifting. The description adds a useful lookup hint tying the parameter to the name-to-CVR workflow via search_companies, giving marginal meaning beyond the schema.

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

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

States a precise verb+resource: returns the SI-score (0-10) risk rating for one Danish company, including the warnings and critical flags behind it. It explicitly scopes the entity types (limited companies and foundations) and clarifies this is an algorithmic score, not a credit rating — a distinction an agent could otherwise get wrong when compared to get_company or get_financials.

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 the routing rule (use search_companies first when you only have a name) and an explicit alternative with its selection condition: one get_company call with `sections` is cheaper and faster when the user also needs the profile or multiple sections. It also tells the agent how to handle the tier_restricted outcome rather than reporting data as absent.

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 read-only annotations, the description discloses pricing (2 credits), ordering behavior (usually newest first, with late/corrected filings possibly out of order), fiscal-year identification, auditor fields, report source links, and no-cost tier restriction handling. This is unusually rich operational context for selecting and interpreting the tool.

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

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

The description is front-loaded with the purpose and key fields, and the remaining sentences carry operational details that matter. It is long and dense, especially around auditor/revisor semantics, so it would benefit from tighter structure, but there is little pure 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?

There is no output schema, so the description must explain return semantics, which it does thoroughly: time range, field set, ordering caveat, fiscal-year comparison key, auditor roles, report URLs, publication dates, and pricing/error behavior. An agent has enough information to call and interpret 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?

The schema already documents the sole CVR parameter and its 8-digit pattern at 100% coverage. The description adds useful acquisition guidance by saying to use search_companies first when only a name is known, though it does not add format or validation details beyond the schema.

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

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

The description names a specific resource (annual accounts for one Danish company) and enumerates the returned fields, including revenue, EBIT, EBITDA, profit, equity, balance sheet and key ratios. It also distinguishes itself from siblings by pointing to get_company for multi-section requests and search_companies for name-only lookup.

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 explicit lookup guidance: use the CVR number directly, and use search_companies first when only a name is available. It also tells the caller to prefer one get_company call with sections when multiple sections are needed, and explains how to handle tier_restricted refusals.

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/openWorld annotations, it discloses the cost model (2 credits: base lookup plus this section), the tier_restricted refusal behavior (refused at no cost, names the unlocking plan), and the temporal scoping of roles (listed only while the role lasts). This is context an agent cannot get 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?

Front-loaded with the resource and zero filler sentences, but the opening sentence is a dense run-on enumerating roles and fields that would read better split. Information remains valuable throughout, so only structural polish is lost.

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

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

With no output schema, the description carries the return-shape burden and does so: name, title examples (ADM. DIR., FORMAND), fraDato, enhedsNummer that get_person takes, and founder fields. Cost, prerequisites, and failure modes are all covered, leaving nothing an agent needs 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 there is a single required `cvr` param with pattern and description already documented. The description adds only that lookup is by CVR number and points to search_companies for name-based lookup, which is baseline-level added meaning.

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

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

States a precise verb+resource: directors, board members, founders and auditors of one Danish company as registered with CVR, plus liquidators and association representatives. It even carves out the boundary with get_financials (which names the signing auditor), so an agent can distinguish it from siblings without opening 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?

Explicit routing guidance: use search_companies first when you only have a name, and use one get_company call with `sections` when the profile or multiple sections are needed, since that is cheaper and faster. It also says what to do when refused due to plan restriction — tell the user rather than reporting data as absent.

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?

Goes well past the readOnly/openWorld annotations: it discloses the two-credit cost model, the tier_restricted refusal behavior (no charge, message names the upgrading plan, and a warning not to report the data as absent), and the precision ceiling of the returned percentages. That tier-refusal warning is exactly the kind of failure-mode context an agent cannot 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?

Front-loaded with purpose and scope, and every sentence carries actionable information (routing, cost, tier failure). It is a dense unbroken block though — cost and error-handling guidance are run together with the purpose statement, which slightly hurts scannability for an agent parsing quickly.

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

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

There is no output schema, and the description compensates by describing the return shape (banded percentages rather than exact figures, owner type, company owner CVR). With one well-documented parameter and read-only annotations, nothing an agent needs to call this correctly or interpret the response 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% and the sole parameter is fully documented in-schema, so the baseline would be 3. The description adds real routing value by saying the lookup key is the CVR number and that search_companies should be used first when only a name is available, which the schema does not say.

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 (direct legal owners of one Danish company from the public ownership register) and pins down the exact return granularity — ownership/voting bands like "25-33%", person-vs-company flag, and company owner's CVR. It explicitly distinguishes itself from the two nearest siblings, get_ultimate_owners and get_real_owners, so an agent can disambiguate 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?

Names both alternatives and the condition that selects each ('to follow holding companies to the people at the end, use get_ultimate_owners; for the confidential beneficial-owner register (UBO), get_real_owners'). Also gives the prerequisite path for name-only queries (search_companies first) and a cost-based routing rule to get_company with `sections` when multiple sections are needed.

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 read-only, non-destructive, open-world behavior. The description adds valuable operational context beyond the annotations: the 100 company-relation cap, the Starter plan requirement, and how legal-owner holdings appear as a LEGAL EJER role with ejerandel.

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

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

The description is compact and front-loaded: it identifies the resource, the required identifier, the returned relationship scope, and the main limitations within three efficient 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?

For a one-parameter read-only tool with no output schema, the description gives enough to call it correctly and understand the main result. It does not explain pagination or behavior beyond the 100-relation cap, but otherwise covers purpose, identifier source, scope, and plan 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 already 100%, so the schema documents the single id parameter. The description still adds meaning by clarifying that the id is an enhedsnummer, is CVR's person number, must come from search_persons, and is never a CPR number.

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: retrieving one person by unit number along with the companies they own, direct, or board. It clearly distinguishes this person-centric lookup from sibling tools such as search_persons and the company-centric ownership tools.

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

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

It tells the agent to use this tool to map a person's business network and that the id comes from search_persons, never a CPR number. It does not explicitly exclude edge cases or name alternative tools for similar network queries, but the intended 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?

Annotations only cover read-only/non-destructive safety; the description adds the material behavior: confidential register requiring a signed contract, two distinct refusal modes (contract_required, tier_restricted) both at no cost, and a 2-credit price. That is exactly the context an agent needs before calling.

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 purpose and return fields, then prerequisites, alternatives, cost, and error handling in a sensible order with no filler. It is long, but each sentence carries decision-relevant information for a paid, access-gated lookup.

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, yet the description enumerates the returned attributes and their ordering, and covers pricing, access preconditions, and failure modes. 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% for the single `cvr` parameter, so the baseline is 3, but the description adds real value by prescribing how to obtain the CVR (search_companies first) and by constraining the tool to exactly one company.

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 (beneficial owners / UBO of one Danish company) plus the source register, and explicitly distinguishes itself from get_ownership and get_ultimate_owners. The listed return fields (name, person/company, share percent, conditions, country, period, ordering) make the scope 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 explicit routing rules: use search_companies when you only have a name, use get_ownership/get_ultimate_owners when there is no contract, and use one get_company call with `sections` when several sections are needed. It also tells the agent what to do on refusal rather than implying absence of data.

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

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

Annotations already declare this as a safe read operation, but the description adds important behavior beyond them: it costs 2 credits, tier-restricted plans are refused at no cost with tier_restricted naming the unlocking plan, and the caller should relay that rather than report absent data.

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

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

The description is front-loaded with what the tool returns, then immediately covers lookup prerequisites, cost, cheaper alternatives, and refusal behavior. Every sentence adds actionable information with no wasted text.

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

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

For a single-parameter read tool with no output schema and annotations that already cover safety, the description supplies the remaining important context: cost, alternative tool routing, and tier-restriction handling. Nothing essential for correct invocation 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 CVR parameter is already well documented with its 8-digit pattern. The description adds useful lookup semantics by stating that the tool is looked up by CVR number and that search_companies should be used first when only a name is known.

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 resource and result: companies owned by one Danish company, including the ownership band for each. It distinguishes itself from siblings by naming search_companies for name-only lookups and get_company for multi-section needs.

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 explicit when-to-use guidance: look up by CVR, use search_companies first when only a name is available, and use get_company with `sections` when the caller needs the profile or multiple sections. These alternatives and conditions are stated directly.

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, so the description adds substantial extra context: credit cost model (3 + 2 per holding company), depth and 12-company caps, the 'uafklaret' unresolved bucket, truncation at '_truncated', foundation and sole-proprietorship edge cases, and plan-gated refusal. This is far beyond what the annotations convey.

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

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

It is dense and long, with some run-on clauses, but the purpose is front-loaded and nearly every sentence carries operational information (cost, limits, edge cases). Minor trimming of overlapping limit statements would improve it.

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

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

There is no output schema, and the description compensates thoroughly by describing the return structure: per-person routes, ownership bands per link, director status flags, and the 'uafklaret' and '_truncated' keys. Nothing material for correct invocation or interpretation 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 schema documents both parameters; the description still adds meaning by explaining that max_depth controls chain expansion, that the default of 3 covers nearly every Danish group, and that deeper traversal costs credits per holding company. That links the parameter to cost and limits, not just shape.

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 precise verb and resource ('Follows the legal ownership chain... until it reaches people') and names what the output contains, distinguishing it from siblings like get_ownership and get_real_owners. An agent can tell what this tool uniquely delivers 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?

Explicitly says to use search_companies first when only a name is known, that the Pro plan or higher is required, and that this uses the public ownership register rather than the confidential beneficial-owner register. Those conditions effectively route the agent away from the sibling that covers real owners.

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 the read-only annotations: the two output fields and their critical difference, why 'momsregistreret' is never false (joint registrations under another SE number), the 'forbehold' caveat, plan/credit cost, and error-not-guess semantics on register failure.

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

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

Front-loaded with the core purpose, and every sentence carries operational value (field semantics, caveat, cost, error handling). It is dense and some clauses are long, but little 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?

With no output schema, the description correctly takes on explaining the return fields and their interpretation. Combined with cost, source, and failure-mode guidance, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100% and the single parameter is fully documented there, so baseline 3 applies. The description restates that the checked VAT number is DK plus the CVR number, adding only marginal clarification over the schema.

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

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

States a specific verb and resource: checks whether DK + CVR is a valid, active VAT number and returns the register's name/address. It also explicitly distinguishes itself from every sibling by noting the VAT data comes from a different source than the other tools.

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

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

Explains the situation (verifying a counterparty's VAT status, comparing against the CVR name) and gives strong when-not guidance: don't declare a company non-registered on an invalid number, treat errors as 'unknown' and retry. It doesn't name a specific alternative tool, but the source distinction from siblings supplies the routing context.

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?

Goes well beyond the readOnly/openWorld annotations: it discloses the deduplication rule (one row per bankruptcy, newest notice wins), the ingestion latency (two days after printing, usually within a week, so the past week is still filling in), coverage boundaries (complete only from January 2026), null cvr rows, and the credit cost per page. These are exactly the operational facts an agent needs before trusting the result.

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?

Dense but waste-free: identity first, then filters, dedup, coverage limits, latency, the Statistics Denmark reconciliation, output shape, and cost. Every sentence carries an operational fact and the caveats are front-loaded rather than buried.

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

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

With eight optional parameters, no output schema, and rich annotations, the description covers what is missing elsewhere: freshness, completeness horizon, dedup semantics, null handling, and cost. Nothing an agent needs to call or interpret this tool 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 schema itself already documents each filter, including spelling pitfalls for city and industry. The description reinforces 'total' as the match count and explains the cvr/virksomhedsform shape, but adds little parameter-level detail the schema does not already carry, 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?

Opens with a specific verb and resource ('Bankruptcy decrees ... for Danish companies') and immediately scopes it against the sibling tools by noting that get_company and the section tools consume the returned cvr. An agent can distinguish this from search_companies or list_new_companies 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?

States explicitly that no CVR number is needed, lists the filter axes (decree date, court, industry, city, name), and excludes personal bankruptcies and sole proprietorships. It also warns not to use it for pre-2026 counts and explains why its monthly totals differ from Statistics Denmark's.

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, openWorldHint and destructiveHint=false, so safety is covered; the description still adds real operational context: fresh-nightly sync, 24-month window, active-only filtering, 1 credit per page on every plan, and that 'total' avoids paging. Return field caveats (kommunekode can be null, postnummer is the reliable location field) are genuine behavioral disclosures beyond 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?

Front-loaded with the definition and the 24-month window before any field notes, and nearly every clause carries decision-relevant information. It is dense and slightly crowded in the middle (industry/legal-form/location notes packed into one run), 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 tells the agent what a row contains, how results are ordered, that 'total' is the full match count, minimum cost implications, and where to go for fields not present. For a 9-parameter, open-ended list tool this leaves nothing an agent needs unknown before calling.

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 met by the schema alone; the description nonetheless adds non-obvious meaning, notably that 'virksomhedsform' is the full legal-form name while 'virksomhedstype' is CVR's short code, and that location should key off postnummer rather than kommunekode. It does not restate syntax or format constraints already in the schema, which is correct.

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 and scope: 'active companies founded within the last 24 months, newest founding date first', plus the fields returned and the nightly CVR sync. Explicitly distinguishes itself from search_companies ('to find one particular company by name or CVR number') so an agent can route 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?

States when to use it (browsing new registrations, 'which companies were founded', counting via 'total') and when not to, naming three alternatives: search_companies for a specific company, get_contact_details and get_financials for address/contact/accounts. Exclusion of inactive companies is also stated.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, but the description adds useful behavioral detail: it lists the returned identity fields and explains that an 8-digit query is an exact CVR lookup yielding at most one result. It does not mention auth or rate limits, but it goes meaningfully beyond the annotations.

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

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

Four sentences, front-loaded with purpose, scope, alternative, and usage priority. Every sentence carries useful information with no noticeable waste.

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, but the description enumerates the identity and registration fields returned and explains the CVR exact-match behavior. Combined with the full schema coverage for pagination and query, it is complete for an agent to call this 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 coverage is 100%, so the schema already defines the parameters well; baseline is 3. The description adds meaning by clarifying that an 8-digit query triggers exact CVR lookup with at most one result, which is not obvious from the schema 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?

States a specific verb and resource ('Search Danish companies'), the search key ('by name or CVR number'), and the returned data scope. It explicitly distinguishes itself from get_company by saying it returns identity and registration details only.

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 explicit routing guidance: 'call get_company for financials, ownership or risk data' and 'Use this first when the user names a company but gives no CVR number.' It also explains exact CVR lookup behavior, leaving little ambiguity about when to choose this tool.

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

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

Annotations already declare readOnly/openWorld/non-destructive, so the description's job is added context, and it delivers: Starter plan or higher is required, matching is fuzzy and homonym-prone, and each result carries role counts plus up to three current companies. It does not discuss result ordering or cost of broad queries, but the added behavioral context is well above the annotation baseline.

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, each carrying distinct load: what it searches, what it returns and how to disambiguate, and the plan requirement. Front-loaded with the core action and no filler.

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

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

No output schema exists, and the description compensates by describing the return shape (enhedsnummer, current/former role counts, up to three current companies). With fuzzy matching, homonym risk, and plan gating all covered, an agent has what it needs to call this correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real meaning to `query` that the schema lacks: partial names are accepted and small misspellings are tolerated. The `limit`/no-paging behavior is left entirely to the schema, which already documents 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 (search people in the Danish company register) and scopes it to name-based lookup, which cleanly separates it from get_person (single-record fetch) and search_companies (company lookup) among the siblings. The chaining hint that results carry the enhedsnummer get_person needs further pins down its role in the toolset.

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

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

Explains the search semantics (partial names work, small misspellings tolerated) and gives concrete guidance on ambiguity: compare the listed companies before concluding two hits are the same person. It also names the downstream tool (get_person) and the plan prerequisite. It stops short of explicitly saying when NOT to use it (e.g. exact single-person lookup), which keeps it from a 5.

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