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

With annotations present, the description adds real context: it discloses the required Adzuna API credentials and that data comes from an open-world source (Adzuna ads), matching openWorldHint. However, readOnlyHint=false is left unexplained, and the aktualisieren/refresh behavior is not described, so an agent cannot tell why this appears non-read-only. Useful but incomplete beyond the annotations.

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

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

Three tight sentences, front-loaded with what the tool returns, then the auth caveat, then the sibling alternative. No filler. Slightly compressed by the parenthetical key names, but every clause earns its place.

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

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

An output schema exists, so return values need no explanation, and the description covers purpose, credential requirement, and the get_salary alternative. The remaining gap is the unexplained refresh/aktualisieren semantics and the readOnlyHint=false discrepancy, which keeps it from 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?

Schema coverage is 60%, so the schema documents was, standort, and kategorie but leaves monate and aktualisieren undocumented. The description adds little beyond the schema — at most it hints that kategorie drives the Gehaltsverlauf. It does not compensate for the two undocumented parameters, so it sits at the baseline of 3.

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

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

The description names the resource specifically (Gehaltsverteilung/Histogramm, Top-Arbeitgeber, optional Gehaltsverlauf) and its source (Adzuna-Inseraten), so an agent knows exactly what data it returns. It also distinguishes itself from the sibling get_salary by referencing that tool's domain (amtliche Medianentgelte, Entgeltatlas). It lacks an explicit action verb, phrasing everything as a noun list, which keeps it just short of a 5.

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

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

It explicitly routes the agent to get_salary for official median wages by occupation, which is a clear when-to-use-alternative signal. It also surfaces the prerequisite (free Adzuna developer key via env vars). It does not spell out a full when-not-to-use matrix against the other siblings, so it stops at 4.

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 specify openWorldHint=true, idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description adds useful behavioral context: it checks all data sources from the local machine and reports HTTP status and latency per source. It does not explain timeout behavior or whether failures are aggregated, but it adds more than the structured fields alone.

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

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

The description is a single, front-loaded sentence with no redundant phrasing. It immediately states the action, scope, and measured outputs.

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, rich annotations, and an output schema, the description is nearly complete. It clearly describes the diagnostic scope and metrics, though it omits explicit guidance about when to invoke it or how failures are represented.

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 are zero parameters, so parameter semantics are not applicable; the baseline for zero parameters is 4. The description does not need to document any input arguments.

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: checking reachability of all data sources from this machine. It also specifies the returned diagnostics (HTTP status and latency per source), making the tool's purpose clear. It does not explicitly differentiate itself from sibling tools, but the diagnostic purpose is distinct.

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 phrase 'von diesem Rechner aus' implies connectivity diagnostics, so usage is inferable. However, there is no explicit guidance on when to use this tool versus alternatives, nor any exclusion or prerequisite details.

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 openWorldHint=true, idempotentHint=true and destructiveHint=false; the description adds that text fetching is optional and secondary to the index lookup. It does not disclose that text loading is capped at 5 hits, latency cost of fetching, or why readOnlyHint is false for an apparent search — those gaps matter since the non-read-only flag is surprising here.

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 compact sentence with the core action first and the optional side effect appended. No filler, though the example could be folded in more precisely.

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

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

With an output schema present, return values need no explanation, and the description covers both the index search and the optional text fetch. Minor misses: no note on crawl selection behavior or result limits, but nothing that would lead an agent to call it incorrectly.

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 75%, so the schema already documents crawl IDs, the URL pattern format, and the text-fetch count with bounds. The description only echoes the optional text loading, adding no syntax or default guidance (e.g. newest crawl default) 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?

Specific verb + resource: it searches the Common Crawl index for archived pages and optionally loads page text. The 'z. B. Karriereseiten' example clarifies the intended domain, distinguishing it from the job/occupation lookup siblings by virtue of the archive source, though it doesn't name a sibling explicitly.

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

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

The description implies when the tool is useful (finding archived versions of pages, e.g. career pages) but gives no explicit when-not conditions and never mentions siblings like search_jobs that might cover live job data. Usage must be inferred from the example.

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

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

Annotations already declare idempotent, openWorld, non-destructive, and not read-only behavior. The description adds the useful multi-hop capability but does not explain what the non-read-only/open-world behavior entails, such as external lookup, caching, authentication, or 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?

The description is a single front-loaded sentence with no filler. It packs the verb, resource, supported systems, and multi-stage capability efficiently.

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

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

With an output schema present and annotations covering safety-related behavior, the description supplies the essential systems and multi-stage scope. It is nearly complete, though it could clarify usage conditions for conversion workflows.

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 75%, and the schema itself documents the code formats and the von/nach system enums. The description only restates the supported systems and does not add parameter-level meaning beyond that baseline.

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

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

The description uses a specific verb, 'Übersetzt', and a clear resource, 'Berufscodes', then enumerates the supported systems. It also notes multi-stage translation, making the tool's purpose distinct from the search/get siblings.

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

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

The description implies usage for occupational-code conversion and mentions multi-step translations, but it does not explicitly state when to use this tool versus alternatives or when not to use it. The guidance is therefore only implied.

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

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

Annotations already declare this is a non-destructive, idempotent, closed-world operation that is not read-only, so the safety profile is covered. The description adds that output is written to a file, which explains why readOnlyHint=false, but it does not say whether an existing file is overwritten, what permissions are needed, or how large graphs are handled. Adequate but not rich.

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 zero filler; the verb and resource lead, followed by the format enumeration. Nothing could be removed without losing information.

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

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

An output schema exists, so return values need not be explained, and the two parameters are fully documented in the schema. However, for a tool that writes files to disk, key operational details such as overwrite behavior and whether 'pfad' is a file or directory per format are missing.

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

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

Schema coverage is 100%, so both parameters, defaults and the enum semantics are already documented in the schema. The description restates the format options without adding syntax, path conventions or format-specific behavior beyond what the schema provides.

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

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

States a specific verb and resource ('Graph exportieren') and enumerates the four output formats, so the agent knows exactly what the tool produces. It does not explicitly differentiate from siblings such as search_knowledge or knowledge_stats, but no sibling overlaps with exporting, so confusion risk is low.

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

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

The description gives no indication of when to choose this tool over alternatives, nor any prerequisites or caveats. The format list only hints at possible use cases; there is no explicit when/when-not guidance.

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

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

Annotations declare readOnlyHint=false, openWorldHint=true and idempotentHint=true, so the agent knows this has side effects and reaches an external network, but the description never explains what those side effects are — nothing about caching/fetching from HN, persisting results, or linking to a task node via aufgabe_id. The one thing it does convey (external HN source) is already implied by openWorldHint.

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

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

A single well-formed sentence with no filler, front-loading the resource and its source. It is not padded, but its brevity is achieved by omitting information rather than by tight editing.

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

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

For a 6-parameter, non-read-only, open-world tool that can persist links to task nodes, one sentence is not enough. An output schema exists so return values need not be explained, but the write behavior, refresh semantics and parameter meanings are all 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 only 50%: suchbegriff and aufgabe_id are documented in the schema, but limit, aktualisieren, nur_kommentare and zeitraum_days carry titles only. The description compensates for none of these, so the agent is left guessing what 'aktualisieren' refreshes and how comment-only filtering interacts with the search.

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

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

The description names the resource (Automatisierungssignale) and its source (Hacker News), plus a clarifying gloss that these are reports of how activities were automated. That is specific enough for an agent to know what it retrieves, though it never explicitly says it is a keyword search nor differentiates itself from siblings like search_knowledge or commoncrawl_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?

There is no guidance on when to use this tool versus the many sibling search/lookup tools (search_jobs, search_knowledge, commoncrawl_lookup, search_arbeitnow). No exclusions, no prerequisites, no mention of when the refresh or comment-only modes should be chosen.

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

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

Goes meaningfully beyond the annotations by disclosing that only public, login-free endpoints are hit, that Personio returns XML, that Workday requires a URL, and that repeated calls yield a delta of new/closed postings since the last fetch — which explains the non-readOnly, idempotent annotation profile. Return-field hints (Abteilung, Seniority, Anstellungsart) are also useful, though rate limits and failure modes (unknown slug, unsupported ATS) are unaddressed.

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

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

Front-loads the core purpose in the first sentence, then the platform list, then the added-value details. The ATS enumeration is long but scannable; nothing is truly redundant, though it could be tightened.

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

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

With an output schema present, the description need not explain return values, and annotations cover the safety profile. What it does provide — login-free sourcing, format quirks, delta semantics — is the right kind of context for a 6-parameter fetch tool; only the meaning of 'aktualisieren' and the max_jobs semantics are left entirely to the schema.

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

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

Schema coverage is 67% and already documents ats auto-detection, ort, suchbegriff, and the company_slug URL/Workday requirement. The description adds essentially no parameter guidance — max_jobs and aktualisieren remain undocumented in both places, and the delta sentence only loosely implies what aktualisieren does.

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

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

States a specific verb+resource: fetching open job postings directly from an employer's applicant-tracking system via public, login-free job-board APIs, and enumerates the nine supported ATS platforms. It does not, however, distinguish itself from the sibling search_jobs or get_job_details, so an agent must infer the split.

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 phrase 'direkt aus dem Bewerbermanagement eines Arbeitgebers' implies the scenario (you know the employer/ATS slug and want their full board), and the delta note hints at polling. But there is no explicit when-to-use, when-not-to-use, or named alternative such as search_jobs for cross-employer keyword search.

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-only, idempotent operation, so the safety profile is covered. The description adds the domain-level behavior that the tool reports a change log across four change types, but this information largely duplicates the `ereignis` enum already present in the schema. With annotations carrying the operational traits, a 3 is appropriate: some added context, but no disclosure of ordering, pagination, or scope detail.

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 or repetition. It immediately tells the agent what the tool is about without wasting words.

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

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

The tool has five optional parameters, no required fields, and an output schema exists, so return-value explanation is not needed. However, the description provides no meaning for most parameters and no guidance on default behavior or scope. An agent still cannot confidently invoke this tool with the correct filters without guessing what `art` or `quelle` represent.

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 only 20% (only `seit` has any description), and the description does nothing to explain the five parameters. It neither defines what `art`, `quelle`, `limit`, or `ereignis` mean nor how to combine them. Because low coverage requires the description to compensate and it does not, this scores a 1.

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

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

The description clearly states the resource (a change log of the memory) and enumerates the kinds of changes it captures: newly added, changed, disappeared, or reappeared. This is specific enough that an agent can grasp what the tool returns. It does not, however, explicitly distinguish itself from sibling `get_history`, which likely overlaps in purpose, so a 4 rather than a 5.

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

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

The description contains no when-to-use guidance, no exclusions, and no mention of alternatives. It says nothing about when `get_changes` should be preferred over `get_history` or `search_knowledge`. An agent is left to infer the appropriate context from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint false, and openWorldHint false, covering the safety profile. The description adds that changes are field-accurate, which provides useful context about return granularity, but does not disclose ordering, pagination, or authentication requirements beyond what annotations 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 description is a single, front-loaded sentence with no wasted words. It directly conveys the core purpose without unnecessary elaboration.

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

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

Given that annotations cover safety and an output schema exists, the description provides sufficient context by stating what is returned (all versions with field-level changes). It could be more complete by mentioning usage scenarios or record identification, but the structured fields compensate.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (quelle, art, schluessel). The description does not elaborate on parameter meaning or format beyond the schema, which is acceptable given the high coverage.

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

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

The description clearly states that it returns all stored versions of a record with field-level changes, which is a specific resource and output. However, it does not name or distinguish itself from sibling tools like get_changes, leaving ambiguity about when to choose this tool over a similar one.

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 guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The description only implies usage by stating what is returned, but an agent must infer the appropriate context without direction.

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 description discloses meaningful behavior beyond the annotations: unavailable postings are marked 'disappeared' in memory and contact persons are stripped before saving (data minimization). This memory-write side effect is consistent with readOnlyHint=false and adds genuine context. Return format is not described, but an output schema exists to cover that.

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

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

Three compact sentences: content first, then side effects. Front-loaded with the payload description, no filler. Reasonably tight for the information conveyed.

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

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

With an output schema present, return values need no elaboration, and the description still adds the memory/contact-handling behavior an agent should know. The only real gap is the undocumented aktualisieren flag, which is minor given the presence of the output schema.

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

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

The refnr parameter is documented in the schema with an example (derived from search_jobs). The 'aktualisieren' boolean has no documentation in either schema or description; the memory-marking sentence hints at refresh behavior but never ties it to the parameter, leaving the 50% coverage gap only partially bridged.

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: retrieves full text and details of a BA job posting, enumerating the returned fields (description, industry, skills, compensation). This clearly differentiates it as the detail-fetch counterpart to a search, though it never names search_jobs explicitly in the description itself.

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 focuses on outputs and side effects; it offers no explicit guidance on when to call this versus siblings or the fact that refnr must originate from search_jobs (that hint lives only in the schema). Usage is left to be inferred 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 declare openWorldHint, idempotentHint, and destructiveHint=false, so the bar is lower; the description usefully confirms the profile aggregates classification, tasks, skills, and links. However it says nothing about the unexplained `aktualisieren` (refresh/live network fetch) behavior, which is exactly the kind of trait the annotation set does not cover, and it sits oddly against readOnlyHint=false.

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

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

A single front-loaded sentence with no filler. It is efficient, though its brevity is part of why usage and parameter guidance are missing.

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

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

An output schema exists, so return-value structure needn't be described. Still, two of three parameters are opaque and the relationship to closely related siblings (get_tasks, get_skills, search_occupation) is unaddressed, leaving gaps for a tool in a crowded namespace.

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 only 33%: beruf_id is documented in the schema (berufenet/kldb/isco/onet/ESCO identifier forms), but `sprache` and `aktualisieren` are undocumented in both schema and description. The description does not compensate at all, so the agent cannot tell what language selection or refresh actually do.

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 (an occupation or occupational class profile) and enumerates what the profile contains: classification, tasks, skills, and links. It is clearly a single-record fetch rather than a search, though it never explicitly contrasts itself with the sibling search_occupation.

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 use this instead of search_occupation, get_role_context, get_tasks, or get_skills, nor any prerequisite or exclusion. An agent must infer from the name alone that this is the single-occupation entry point.

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 openWorldHint=true, idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description adds useful context beyond that by naming the concrete external sources (BERUFENET/O*NET, ESCO, Entgeltatlas, BA open positions) and noting that the result is an aggregate; it does not discuss latency, fallback, or missing-data behavior.

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; it front-loads the core purpose and then lists the included data domains. Nothing is repeated unnecessarily.

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 an output schema exists, the description need not explain return values. It adequately covers the aggregate nature and data sources, though it omits mention of the sprache parameter and does not clarify signal behavior beyond the schema parameter name.

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 75%: rolle, ort, and mit_signalen are documented in the schema. The description does not add parameter-level meaning, and the sprache parameter remains undocumented in both schema and description. Baseline 3 is appropriate given the schema carries most parameter semantics.

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

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

The description clearly identifies the resource: a consolidated role context returned in one call, enumerating mapping/classification, tasks, skills, salary, and labor-market signal. This distinguishes it from granular siblings such as get_tasks, get_skills, and get_salary, though it relies on the title for an explicit verb.

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 phrase 'in einem Aufruf' implies the tool should be used when the agent wants several role-related data points together instead of calling multiple granular tools. However, no alternatives are named explicitly and no when-not-to-use conditions are given.

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

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

The annotations declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful data-source context but does not explain the non-read-only behavior, any refresh/cache side effects, or how 'aktualisieren' affects execution.

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

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

The description is a single, front-loaded sentence with no wasted wording. It efficiently states the data type, statistics included, and source.

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

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

For a 7-parameter, open-world tool with a non-read-only annotation, the description is too sparse. Although an output schema exists and schema coverage is high, the description still lacks sibling routing and does not clarify the side-effect-related 'aktualisieren' parameter.

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 high at 86%, so most parameter meaning already comes from the schema. The description adds only 'nach Beruf', implicitly mapping to the kldb parameter, and says nothing about filters such as alter, niveau, region, branche, geschlecht, or the undocumented 'aktualisieren' boolean.

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

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

The description identifies a specific resource: official median salaries with quartiles by occupation from the BA Entgeltatlas. It is more specific than the name alone and implicitly distinguishes the source from commercial salary siblings like adzuna_salary, though it does not explicitly name 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?

The description gives no guidance on when to use this tool versus adzuna_salary or other occupation-related siblings. It also does not state prerequisites, expected use cases, or exclusions.

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

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

The description adds nothing beyond the retrieval subject: no note on where the BA frequency data comes from, how fresh it is, whether results are cached, or what happens when the occupation cannot be resolved. Annotations oddly set readOnlyHint=false despite a 'get_' tool, and the description neither confirms nor resolves that ambiguity, leaving the agent with more questions than answers about side effects.

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, opening directly on the resource and its two data sources. It is efficient, though it errs toward under-specification rather than excess.

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

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

An output schema exists, so return-value detail is legitimately omitted, and the one-line scope statement covers the core query. But for a four-parameter tool with only 50% schema coverage and ambiguous annotations, the description leaves too much unexplained — notably the limit/paging behavior and the meaning of 'sprache'.

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?

Coverage is 50%: 'beruf' and 'relation' are documented in the schema, and the description usefully surfaces the essential/optional distinction that maps to the relation enum. However, 'limit' (default 40, max 200) and 'sprache' (nullable, default null) are undocumented in both places, and the description does not explain how free text in 'beruf' is resolved against the ESCO/kldb/berufenet identifier formats.

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

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

The description names the resource and the operation precisely: skills for an occupation, combining ESCO essential/optional relations with frequencies derived from stored BA job postings. That is specific enough to distinguish it from get_tasks or get_occupation at a glance. What is missing is any explicit naming of the sibling it should be chosen over.

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 use this versus search_occupation, get_occupation, get_tasks, or get_role_context, all of which sit in adjacent territory. The only implied usage cue is the required 'beruf' lookup key and the mention of ESCO relations. An agent must infer the routing decision entirely.

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 real value beyond the annotations by disclosing the data-resolution chain (BERUFENET→KldB→ISCO→ESCO→O*NET) and the hard prerequisite that crosswalks be imported. It does not say what happens when crosswalks are missing or when the chain breaks, which is the key failure mode for a resolution-dependent tool. Note readOnlyHint=false while the tool is a read/lookup operation — the description does not contradict this, but does not explain it either.

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; the core purpose is front-loaded before the technical resolution chain. The parenthetical about crosswalks is dense but earns its place as a prerequisite.

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

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

An output schema exists, so return values need no explanation, and the resolution chain is described. Still missing: behavior on unresolvable occupations, what partial results look like when only one source resolves, and any note on the `sprache` parameter — relevant gaps for a 5-parameter crosswalk-dependent 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?

At 60% schema coverage the schema carries the required `beruf` formats and defaults, so baseline applies. The description implicitly maps to two parameters — `quellen` (onet vs. berufenet are both named) and `nur_kern` ('Core') — but says nothing about `sprache` or `limit`, leaving those purely schema-driven.

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 (canonical task list for an occupation) and enumerates the two underlying data sources (O*NET task statements Core/Supplemental, BERUFENET activities). An agent can separate it from get_skills or get_occupation on substance, though the description never explicitly contrasts with them.

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

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

No explicit when-to-use / when-not-to-use statement and no sibling is named as an alternative. The only operational guidance is the prerequisite that crosswalks must be imported, which implies usage conditions without stating 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds useful domain context by listing the entity types that exist in the graph, but says nothing about traversal depth, how the limit interacts with node degree, or whether results are ordered or deduplicated.

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 well-formed sentence with the core operation front-loaded and no filler. It is efficient, though its brevity is part of why the guidance gaps exist.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. However, for a graph traversal with direction and edge-type filters, the description leaves the agent without any model of what a traversal returns or how 'richtung' changes the result — a meaningful gap for a 4-parameter 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 description coverage is only 50%: 'knoten' and 'kantentyp' have descriptions, while 'limit' and 'richtung' (the direction enum, arguably the most consequential parameter for a traversal tool) are undocumented in both schema and description. The description's list of node types loosely clarifies what 'knoten' can refer to but adds nothing on direction or edge-type semantics, so it does not compensate for the gap.

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 operation on a specific resource: neighbors of a node in the job graph. The parenthetical enumeration of node types (occupations, tasks, skills, jobs, industries, regions) makes the graph's scope concrete. It does not explicitly contrast itself with graph-adjacent siblings like search_knowledge or crosswalk, but the traversal semantics are distinctive enough to identify it.

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 use this tool versus alternatives such as search_occupation or get_role_context, nor any prerequisites (e.g., needing a known node ID). The agent must infer from the word 'Nachbarn' that this is for graph exploration rather than search.

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 idempotentHint=true and destructiveHint=false; the description earns credit by explaining why — repeat runs merge and tombstone rather than wipe, which is the key behavioral fact for a write tool. It does not cover auth, permissions, or runtime/network cost despite openWorldHint=true.

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

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

Two short sentences, front-loaded with the action and then the important re-import semantics; nothing is wasted. Minor deduction for the awkward line break and the missing explicit dataset/source hint.

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

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

With an output schema present, rich annotations, and full param coverage, the description only needs to add the import semantics — which it does. It leaves out error/precondition behavior (e.g. what happens if the source URL is unreachable) for an open-world tool, so not quite complete.

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

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

Schema description coverage is 100%, so the enum values and the optional 'quelle' behavior are already fully documented. The description adds no parameter-level guidance beyond the schema, which is the correct baseline when the schema does the work.

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 pair (import/update) and resource (reference data), and adds that imports are incremental across releases. Sibling tools are all query-oriented, so confusion is unlikely, though it never explicitly distinguishes itself from them.

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

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

The sentence about repeated imports adding new/changed entries and marking removed ones implicitly tells the agent this is safe to re-run and how to refresh data, but there is no explicit when-to-use, when-not-to-use, or prerequisite (e.g. which dataset to pick, source requirements).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description contributes the scope of the aggregates it returns, which is genuine added context, but says nothing about result volume or formatting (though an output schema exists).

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 short, front-loaded sentence that lists exactly what the overview contains, with no filler or redundancy. Every clause names a concrete piece of returned data.

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-argument, read-only statistics tool with annotations and an output schema, the description covers what is reported. It stops short of explaining how the counts are scoped (all time? per workspace?), which would fully close the loop.

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 disambiguate; the baseline for a no-param tool applies. No parameter semantics are needed or missing.

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

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

The description clearly states the tool returns an overview of the memory store, enumerating concrete contents (records per source, versions, graph nodes/edges, last retrievals). That is enough to tell it apart from typical search/read siblings, but it never names which sibling to prefer for detail (e.g. get_history, get_changes, graph_neighbors).

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 about when to call this versus alternatives such as get_history, get_changes, or graph_neighbors, and no prerequisites or cost context. The agent must infer from the name that this is an inventory/summary call rather than a detail call.

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 safety profile (not read-only, idempotent, non-destructive, closed-world), so the bar is lower. The description adds real behavioural context beyond them: writes are versioned in the graph, and the call returns canonical-task suggestions used for deduplication. It does not say how conflicts or duplicates are merged, which keeps it from a 5.

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

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

Two short sentences, no filler. The write action and its versioned nature come first, and the return-value side effect follows. Every clause carries information an agent cannot get from the structured fields.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile; the description supplies the remaining essentials (what is stored, that it is versioned, provenance via quelle, dedup suggestions). A brief note on how re-recording the same extraction is handled (beyond idempotentHint) would make it complete.

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

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

Schema description coverage is 100%, so the schema already documents bezug, quelle, skills, aufgaben and automatisierungen in detail. The description adds no extra semantics about parameter formats or interactions (e.g. how a kanonisch ID affects deduplication). Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (versioniert im Graphen speichern) and enumerates the exact resources written: Aufgaben, Skills, Automatisierungsbewertungen. It also names a secondary effect (returning canonical task suggestions for deduplication), which makes the tool's role distinct. It does not explicitly contrast itself with near neighbours like remember or import_reference_data, 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?

The phrase 'vom Modell oder von Fachexperten extrahiert' implies the usage context (recording an extraction result, with the quelle parameter distinguishing LLM vs expert provenance), but there is no explicit when-to-use/when-not statement and no pointer to alternatives such as remember or import_reference_data. Usage is inferable but not spelled out.

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

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

Annotations already establish that this is a non-read-only, non-destructive, idempotent, closed-world write operation, so the description's bar is lower. It adds that storage is 'versioniert' and can 'speichern oder ergänzen', but it does not explain versioning semantics, overwrite/append behavior, permissions, or how repeated writes are handled.

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

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

The description is a single front-loaded sentence with no filler, stating the core action before the parenthetical examples. Every element earns its place.

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

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

Because an output schema exists and the annotations richly describe safety and idempotency, the description does not need to explain return values or the safety profile. It gives enough purpose for a write/upsert tool, though it omits sibling-routing guidance and precise versioning/upsert semantics.

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 80%, so most parameter meaning is already supplied by the schema. The description does not add format, constraints, or semantics for parameters such as art, schluessel, daten, or quelle; the role-profile/feedback examples only loosely suggest possible 'art' values.

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 action (versioned storing or supplementing in memory) and a specific resource (own data, internal role profiles, expert feedback). It is much clearer than the bare name 'remember', but it does not explicitly distinguish itself from sibling knowledge-ingestion tools such as record_extraction or import_reference_data.

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 examples 'interne Rollenprofile' and 'Expertenfeedback' imply that this tool is for capturing internal/personal knowledge, which gives some usage context. However, it never states when to use it instead of sibling tools like search_knowledge, record_extraction, or import_reference_data, and it gives no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds important context beyond that: filtering is local over fetched pages, and all fetched jobs are stored, which explains the non-read-only side effect and the fetch-then-filter mechanics. It does not mention rate limits or response shape, but explains the key behavioral trait.

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

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

Two sentences, front-loaded with the source and access model, then the filtering/storage behavior. The parenthetical is information-dense but not wasteful, and no sentence is superfluous.

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

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

An output schema exists, so return values need not be explained; annotations cover the safety profile; the description adds the storage side effect and local filtering caveat. The main remaining gap is routing guidance versus sibling search tools and the meaning of the aktualisieren parameter.

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 high (83%), so the schema already documents most parameters such as ort, was, seiten, remote_only, and visa_sponsorship. The description adds the meaningful caveat that filtering is local over fetched pages, which clarifies how seiten interacts with filters, but it does not explain the undocumented aktualisieren flag.

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 (Stellen von Arbeitnow) and source behavior (aggregiert ATS-Feeds wie Greenhouse, Personio, Recruitee). It is clearly a job search against a named aggregator, though it does not explicitly contrast itself with the sibling search_jobs tool.

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 useful context — free, no key, ATS aggregation — which implies when this source is attractive, but it never states when to use this instead of search_jobs or get_ats_jobs, nor any exclusions. Usage is implied rather than explicitly 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?

Discloses the non-obvious side effect that every listing is persisted to memory and that repeat searches return a comparison against the previous identical search — this is precisely what explains readOnlyHint=false on a search tool. Combined with the 'aktualisieren' escape hatch for a fresh fetch instead of cache, the agent understands the stateful behavior annotations alone could not convey.

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

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

Three short sentences: what it searches, how it behaves across calls, and where details live. Front-loaded with the source, zero filler, nothing redundant with the schema.

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

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

For a 13-parameter, zero-required search tool with an output schema and full schema coverage, the description covers the remaining gaps an agent would trip on: persistence, delta semantics, the refresh flag, and the handoff to get_job_details. Return-value shape is delegated to the output schema as expected.

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 baseline is 3. The description adds meaning the schema cannot: that results are cached per identical query, that deltas are reported relative to that query, and that refnr (an output field) is the key for get_job_details — useful cross-parameter context.

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

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

Names a specific verb and resource ('Stellensuche in der Jobbörse der Bundesagentur für Arbeit') and pins down the source, which is exactly what separates it from siblings like search_arbeitnow and get_ats_jobs. It also routes detail lookups to get_job_details(refnr), so an agent knows the division of labor immediately.

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 states that repeated identical searches yield a delta of new/changed/removed listings and that details belong to get_job_details. It stops short of stating when to prefer this over search_arbeitnow or the other job siblings, so the choice across sources is still inferred.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, destructiveHint=false, so the safety profile is fully covered. The description's 'Offline' wording is consistent with openWorldHint=false but adds little beyond it, and says nothing about result ordering or limits.

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

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

A single tightly packed sentence with the primary purpose front-loaded. It is efficiently sized, though the heavy parenthetical makes the alternative use case read as an afterthought rather than structured guidance.

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

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

An output schema exists, so return values needn't be explained, and annotations cover safety. However, for a 4-parameter search tool with an untyped filter ('art', 'quelle') and no pagination/limit note, the description leaves the agent to infer filtering behavior entirely from the schema.

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

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

Schema description coverage is 75%: 'art', 'quelle' and 'suchbegriff' carry schema-level examples and the full-text semantics. The description adds no parameter meaning beyond that, and 'limit' is undocumented in both places, so the baseline 3 applies.

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

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

States a specific verb+resource ('Offline-Suche im Gedächtnis') and adds a concrete secondary use case (mapping free task texts to canonical tasks). It does not explicitly distinguish itself from siblings like search_jobs or search_occupation, so it falls 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?

The parenthetical gives one implied trigger (canonicalizing free-text tasks) and 'Offline' hints at local-only scope, but there is no explicit when-to-use vs. alternatives (e.g. search_occupation, remember) guidance or exclusions.

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

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

Annotations already cover the safety profile (destructiveHint=false, idempotentHint=true, openWorldHint=true), and the description's source list is consistent with the openWorld flag. However, it never explains that readOnlyHint=false despite being a 'find' operation — plausibly because the 'aktualisieren' (refresh) parameter writes to a cache — and discloses nothing about cost, latency, or refresh semantics.

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 fragment with zero padding — efficient, but so terse that it stops short of carrying the behavioral and routing information the description should provide. No waste, yet also little substance.

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 six parameters, an output schema, and annotations already present, the description needn't explain return values or safety. It is still incomplete on the two highest-risk gaps: no when-to-use guidance against a crowded sibling set and no explanation of the caching/refresh behavior implied by readOnlyHint=false.

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%, so most parameters are documented structurally. The description's enumeration of the four sources maps directly onto the 'quellen' enum and thereby clarifies that parameter, but it adds no meaning for 'sprache', 'kldb_code', 'limit', or 'aktualisieren', whose semantics (especially the refresh flag) remain opaque outside 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 concrete verb ("Berufe finden") plus the resource and enumerates the four underlying sources (BERUFENET, ESCO, KldB, O*NET), so an agent knows this is a multi-source occupation lookup. It does not explicitly contrast with siblings like get_occupation or search_jobs, but the verb 'finden' vs 'get' carries implicit differentiation.

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 use this tool versus get_occupation, search_jobs, crosswalk, or get_role_context, all of which live in the same space. The source list hints at coverage but gives no conditions or exclusions, leaving routing entirely to inference.

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