oqda Business-OS

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: the exact subject matter compared and an explicit NOT-a-fit list (no patient records, LIMS, SMS, payroll), which tells the agent what the answer will and won't address. No return format or length/pagination notes, but those matter little for a static informational 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 core function is front-loaded in the first clause, with the comparison dimensions and exclusions compactly listed and the usage trigger placed last. It is dense but every element (replaces/interplay/cost/non-fit) earns its place; only the packed colon list slightly reduces readability.

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

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

For a zero-parameter, read-only informational tool with no output schema, the description supplies what an agent needs: what the comparison contains, who it's for, and what it explicitly does not cover. The only omission is disambiguation from the cost-oriented get_pricing sibling, which keeps it short of a 5.

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 nothing for the description to clarify beyond the schema; the baseline for a no-param 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?

The description opens with a specific verb and scope ('Explains how oqda differs from running separate tools') and enumerates what the comparison covers: feature replacements, module interplay, cost, and non-fit areas. It is clearly distinguishable from informational siblings like list_modules, though the 'what it costs' coverage overlaps with get_pricing without acknowledging that sibling.

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

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

It gives an explicit trigger: 'Use it when a user asks for alternatives or whether oqda suits them,' which is concrete and actionable. It does not name or exclude any sibling tool (e.g., when to prefer get_pricing over this), so routing is clear but not fully disambiguated.

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 and openWorldHint=false, so safety is covered. The description adds the return format (Markdown), which is useful since no output schema exists, but says nothing about pagination, caching, or error behavior for a missing 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?

Front-loaded with the core behavior in the first sentence, with supporting guidance second. The extended list of example paths is slightly padded but serves as concrete illustration, so waste is minimal.

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?

A simple single-parameter read tool with annotations covering its safety profile and no output schema; the description supplies the return format and a routing hint to sibling discovery tools, which is adequate. Only error/pagination behavior is unaddressed.

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 'path' parameter is fully documented in the schema, including the same example-path format. The description's example list adds no syntax or constraint information beyond what the schema provides, so baseline 3 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?

States a specific verb and resource: returns one oqda.de page rendered as Markdown. The closing sentence implicitly differentiates it from list_modules/search_oqda by positioning those as path-discovery tools, though it never says so outright.

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 operational context: pass a path or URL, and obtain valid paths from list_modules and search_oqda. Example paths reinforce intended usage. No explicit 'when not to use this' statement, so it falls short of a 5.

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 and openWorldHint=false, so the safety profile is covered. The description adds domain constraints the annotations cannot convey — currency (EUR), VAT exclusion, business-only audience, and the enumerated returned content — which meaningfully reduces invocation ambiguity despite no output 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?

A single front-loaded sentence opening with verb and resource, with no filler. It is a dense enumerated list, but each listed item (packages, module prices, conditions, usage costs) carries distinct information, so 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 parameters and no output schema, the description must carry the return-value burden, and it does describe what comes back plus key business qualifiers (EUR, ex-VAT, businesses only). Minor gaps remain around freshness or caching of pricing data, but nothing essential for calling a zero-arg read tool 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 per the rubric the baseline is 4. The schema is trivially complete, and the description appropriately adds no parameter discussion, instead clarifying that location and month are dimensions of the returned data rather than inputs.

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 ('Returns') and resource ('oqda pricing') and enumerates the exact contents: packages, module prices, conditions, usage-based costs. That is far more specific than a sibling like get_page, though it never names an alternative to distinguish it from list_modules or compare_alternatives.

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

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

Usage is only implied — an agent can infer this answers pricing questions — and the description supplies useful scope qualifiers (per location and month, EUR, excluding VAT, businesses only). However, it gives no explicit when-to-use rule and never points to compare_alternatives or list_modules as the tool to pick for adjacent questions.

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 (write, idempotent, non-destructive), it discloses that the waitlist is free and non-binding, that oqda contacts the person personally, and that the person decides afterward. It also corroborates idempotency explicitly ('Calling again with the same e-mail has no further effect'), adding context the annotations only imply.

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 and the strongest constraint (consent gate) are front-loaded, and each sentence carries a distinct rule or piece of behavioral context. It is dense but contains no filler; a small readability cost is the only deduction.

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 4-parameter write tool with an output schema (so return values need no explanation) and full annotation coverage, the description supplies everything needed: consent wording, invocation preconditions, and idempotency behavior. Nothing an agent must know to call 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%, so the baseline is 3, but the description adds real meaning: it supplies the exact German consent statement that consent_confirmed must confirm and warns against inventing the email. That goes beyond the schema, which only points back at the description.

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

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

The description opens with a specific verb+resource ('Puts a person on the oqda waitlist') and immediately scopes it as free and non-binding. No sibling tool does anything similar, so the agent can distinguish it without inspecting 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 states explicit preconditions: only call when the person asked for it, only with their own e-mail, and only after they explicitly agreed to the given consent statement. It also adds a negative constraint ('Never guess or invent an e-mail address'), which is a clear when-not rule.

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 declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuine value by specifying what the result contains (features, prices, page URLs, plus the shared platform core), compensating for the absent output schema; it does not add auth or rate-limit details, but none apply to a static read.

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 with no filler; the enumerated module list and return contents each earn their place and are compactly parenthesized.

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 parameterless read tool with no output schema, the description adequately covers both what the tool is and what it returns. The only missing piece is guidance relative to the pricing-overlapping 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?

The tool takes zero parameters, so there is nothing to document and the baseline applies. The description correctly implies no input is 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?

Specific verb (Lists) plus a precisely scoped resource (the eight oqda modules), and it enumerates each by name so the agent knows exactly what it covers. This is far more discriminating than the sibling tools like get_pricing or search_oqda.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and the description never names an alternative. This matters because the stated 'individual prices' overlap with the get_pricing sibling, but the description offers no routing rule to disambiguate them.

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 (readOnlyHint=true, openWorldHint=false), so the bar is lower. The description still adds real context: the scope of the index, the fact that content is German, and the return shape (URL + snippet). It doesn't mention result ranking or empty-result behavior, but that's a minor 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?

Two tight sentences with the corpus scope front-loaded, followed by the follow-up action and query-language tip. The parenthetical section list is dense but informative; nothing is wasted, though it is slightly packed.

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 explains the return (matching pages with URL and snippet) and points to get_page for the full content, which is everything an agent needs to use the result set 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 both parameters are already documented, and the description mostly echoes the schema's 'preferably German' note. The added German example terms are mildly helpful but don't extend the semantics of query or limit.

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 (full-text search over oqda.de) and enumerates the covered content areas, so the agent knows exactly what corpus is searched. It also distinguishes itself from the sibling get_page, which is the read-in-full counterpart.

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 routes the agent: search here, then 'read a page in full with get_page', and advises German query terms with examples. No explicit exclusions or comparisons against the other siblings, but the workflow 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 already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false, so the mutation and safety profile is covered. The description adds real context beyond that: the reply is asynchronous and human ('The team replies personally by e-mail'), and sends must be authorized by the person using their own address. It omits failure behavior and rate limits.

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

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

Three sentences, front-loaded with the core action and followed by the qualifying examples and the consent constraint. The parenthetical example list is slightly long but each item earns its place by clarifying eligible requests; 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?

For a non-read-only tool with no output schema, the description covers the important unknowns: the request is delivered to a human team with an asynchronous e-mail reply, and the send must be on behalf of the person. Remaining gaps (error handling, rate limits, whether the message persists) are minor for this tool's complexity.

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

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

Schema description coverage is 100%, so all three parameters (name, email, message) are already documented in the schema, including format and length limits. The description reinforces the email parameter's meaning ('with their own e-mail address') but adds no format, syntax, or content guidance 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?

The description opens with a specific verb+resource ('Forwards a question or request ... to the oqda team') and enumerates concrete qualifying cases (business fit, Enterprise for 11+ locations, data protection request). This is clearly distinguishable from siblings like join_waitlist, get_pricing, and compare_alternatives 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 concrete when-to-use examples and an explicit constraint ('Only send on behalf of the person, with their own e-mail address'), which tells the agent the delegation precondition. It stops short of naming an alternative tool or a when-not-to-use condition, so it is strong but not complete routing guidance.

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