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

With no annotations, the description carries the full burden, and it does disclose the key trait ('Read-only') plus a summary of returned fields. It omits pagination behavior, result limits, and any auth/session prerequisites, which for a list tool with no annotations leaves meaningful gaps.

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

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

A single sentence with the verb and scope front-loaded and the field list appended; every clause earns its place and there is no 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?

For a simple read-only list with one optional parameter and no output schema, the description supplies the returned fields it would otherwise be missing. It could add pagination or scope notes, but nothing essential to invoking it correctly is absent.

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

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

Schema description coverage is 100% and the single 'year' parameter is documented in the schema as 'Only receipts for this tax year.' The description adds no filter syntax or semantics beyond that, so the baseline of 3 is appropriate.

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

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

States a specific verb+resource: 'Lists receipts in Meine Belege' and enumerates the returned fields (id, label, year, Belegart, recognised values, status). It is clearly distinguishable from the write-side sibling elster_beleg_upload, but does not explicitly name or differentiate itself from the other list tools (submissions_list, drafts_list).

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

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

Usage is implied by the resource ('Meine Belege' receipts, optional tax-year filter), so an agent can infer when it applies. However, there is no explicit when/when-not guidance and no routing to sibling list tools, leaving the selection context to inference.

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

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

With no annotations, the description carries full behavioral burden. It usefully discloses the accepted formats, the 10 MB cap, and crucially that it 'Stores a document in the account; submits nothing' – an important side-effect distinction given the sibling submission tools. However it omits session/auth requirements, duplicate-handling, and what is returned.

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

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

Front-loads the core action and constraints, then gives the belegart mapping examples. The example list is dense but earns its place by encoding the nested-key contract; nothing is gratuitously verbose.

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 tool with a nested object and no output schema, the description covers the central belegart/fields mapping well but leaves required 'year' and 'stichwoerter' unexplained, and never states what the call returns or whether a login is required.

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 43% (low), so the description must compensate. It does meaningfully, explaining the belegart path syntax ('N/Arbeitsmittel') and which field keys map to each line (Art_der_Arbeitsmittel, Betrag, etc.) plus the Betrag numeric format. It does not clarify year, stichwoerter, or label beyond the schema.

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

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

States a specific verb and resource ('Uploads one receipt file') plus the destination ('Meine Belege'), and its tagging purpose. An agent can distinguish it from the reading-oriented elster_belege_list sibling without opening either schema.

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

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

Gives usage context ('Receipts are optional for the ESt (Belegvorhaltepflicht) but can avoid queries'), which tells the agent why and when this tool is worth calling. It does not name alternative tools or explicit exclusions, but the 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?

The description discloses a key behavioral trait: secrets are redacted, which is important for an agent to know. Without annotations, this adds value. However, it does not detail whether the tool reads from files, environment, or cache, but for a display tool this is sufficient.

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 sentence that is perfectly concise with no wasted words. It front-loads the action and adds necessary context.

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

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

For a simple display tool with no parameters and no output schema, the description fully covers the purpose, output behavior (redacted secrets), and usage context (verification of env vars/config).

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 has zero parameters, so baseline is 4. The description adds no parameter info, but none is needed. It provides context about what is shown (config, secrets redacted) beyond the empty schema.

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

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

The description clearly states the tool shows the currently loaded ELSTER configuration with secrets redacted, specifying the action (show), resource (config), and a key detail (redaction). It distinguishes from sibling tools which are action-oriented (start, list, generate, etc.).

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

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

The description implies the tool is used to verify environment variables or config.json were picked up, but does not explicitly state when not to use it or mention alternatives. The purpose is clear enough for an agent to decide.

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?

No annotations provided, so the description carries the full burden. It usefully states 'Read-only' and 'without starting a filling session', covering the main behavioral trait. However, it omits details on permissions, rate limits, or other 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?

Two sentences, front-loaded with the core action and scoping constraint. Every sentence earns its place by guiding the agent to the downstream usage.

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

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

No output schema exists. The description implies the return contains an 'aufgabeId' or year, which is helpful, but does not fully describe the list's structure or pagination behavior. Adequate for a simple two-parameter list tool.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds the context that 'form' selects which form to inspect and 'year' is the tax year of the new form, but provides no syntax or format details beyond the schema.

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

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

States a specific verb (Lists), resource (earlier submissions ELSTER offers to carry over), and scope (for a given form and tax year). Explicitly distinguishes from the start tools by saying 'without starting a filling session', allowing an agent to identify it without opening schemas.

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

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

Provides clear context: use this to find carry-over data before starting a filling session. Names the downstream tools (elster_ustva_start / elster_eur_start / elster_est_start) and the argument ('takeover') to pass results into. No explicit when-not-to-use, but the alternative path is evident.

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?

With no annotations, the description carries the full burden and does add real behavioral context: it discloses the persistent engine session, including that it logs in on first use and then stays logged in, which tells the agent about a side effect and session state. It omits failure modes and what happens on session expiry.

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

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

Two tight sentences, front-loaded with what the tool returns and scoped by the UI path before the session detail. No 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?

For a zero-param, no-output-schema read tool, the description covers scope, a returned identifier, ordering and session behavior, which is most of what an agent needs. It does not enumerate the full shape of a draft record, leaving some return-value uncertainty with no output schema to fall back on.

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

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

Zero parameters, so the baseline is 4. The description still adds value by naming a returned field (aufgabeId) and the sort order (newest first), which is more than the empty schema conveys.

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

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

States a specific verb and resource ('Lists saved drafts') and pins down scope with the UI path 'Meine Formulare → Entwürfe', which separates it from submission- and Beleg-listing siblings. It does not explicitly name an alternative, 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?

Usage is only implied: an agent can infer this is the read path for retrieving draft forms rather than submissions, but the description never states when to use it, when not to, or which sibling to prefer (e.g. elster_submissions_list). Adequate but with a clear gap.

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?

With no annotations, the description carries the full burden and does so well: it discloses that the form is left unsaved, no draft is kept, ELSTER may offer it for recovery at next login, and nothing is ever transmitted. It still doesn't state session/login prerequisites or expected runtime, so it is not fully complete.

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

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

Front-loaded with the resource and its German name, then the mechanism, then the side-effect caveats. Every sentence earns its place and 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 two-parameter read operation with no output schema and no annotations, the description covers purpose, mechanism, side effects, and the categories of data returned. It does not sketch the exact return shape or error conditions, but it is close to 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 both parameters (year, anlagen) are already documented in the schema, including the default anlagen set and id examples. The description adds no parameter-level meaning beyond that, 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 gives a specific verb (retrieves), a precisely named resource (pre-filled tax data / vorausgefüllte Steuererklärung / eDaten), and enumerates the exact data categories returned (Lohnsteuerbescheinigung, Vorsorgeaufwendungen, Lohnersatzleistungen, Riester/Rürup). It is clearly distinguishable from siblings like elster_drafts_list or elster_datenuebernahme_list.

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 explains when this tool is needed by describing the constraint that forces it: ELSTER only exposes eDaten from inside the ESt form, so the tool walks the form to the import step. It gives clear context but never explicitly names an alternative tool or a when-not-to-use condition, 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?

With no annotations, the description carries the full load, and it does disclose meaningful behavior: it fills the new-row template and COMMITS the row ('Eintrag übernehmen'), signalling a persistent mutation rather than a local draft. However, it omits permission/auth needs, what happens on duplicate rows or missing groups, and any return/error behavior, leaving gaps for a mutation tool with zero annotation coverage.

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 action ('Adds one row...'), then the mechanism, then the input sourcing. Dense and mostly earns its space, though the parenthetical German/English pairs add minor noise that a purely normative reader doesn't need.

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 3-parameter, nested-object, no-output-schema, no-annotation tool, the description covers the commit semantics and input sourcing but leaves 'rid' unaddressed and says nothing about failure modes or persistence details. Adequate but not complete for the complexity involved.

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 0%, so the description must compensate. It adds real meaning for 'group' (an inline repeat group / Mzb, with an example) and implies 'values' follows the same key and money rules as elster_form_set, but it never explains the shape of 'values' or the 'rid' parameter at all, leaving two of three parameters under-specified.

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: 'Adds one row to an inline repeat group', with a concrete domain example (Mzb / Arbeitsmittel 'AufwendungenArbeitsmittel'). It is clearly distinguishable from siblings like elster_form_delete_row, elster_form_set, and elster_form_save by naming the exact mutation it performs.

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?

Tells the agent where inputs come from ('Group names and template keys come from elster_form_page → groups') and routes validation/format rules to elster_form_set. It stops short of stating explicit when-not-to-use conditions or contrasting with elster_form_set as an alternative action, so it's clear context rather than full routing.

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

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

With no annotations, the description carries the full burden and does substantial work: it names accepted formats (PDF or XML), per-file size (max 10 MB), file-count cap (20), the side effect (one row per file), and explicitly states it submits nothing — a useful non-terminal mutation signal. Gaps remain around failure behavior (partial upload of a batch) and whether attached files can be removed afterward.

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 action and scope, then constraints, then the crucial "Submits nothing" caveat last. Dense with facts and free of filler.

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

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

For a 3-parameter mutation with no annotations and no output schema, the description covers purpose, accepted inputs, limits, and side effects, which is most of what an agent needs to call it safely. It falls short on error/partial-failure semantics and on confirming what the created rows look like afterward.

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 baseline is 3; the schema already documents rid, files, and group with matching examples. The description adds only the format/size/count constraints on `files`, which is real but modest added meaning.

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

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

"Attaches local files to a form's upload group" states a specific verb and resource, and the concrete example (Einspruch page "5 - Anhänge", group "anhang_mzb") removes ambiguity. An agent can distinguish this from row-manipulation siblings like elster_form_add_row or elster_beleg_upload without opening the schema.

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

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

Usage is implied by "a form's upload group" and by the closing note "Submits nothing", which tells the agent this is a step within a form workflow rather than a final action. However, no explicit when-to-use or when-not-to-use guidance is given, and the nearest alternative (elster_beleg_upload) is never named or contrasted.

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?

With no annotations, the description carries the full burden, and it delivers the key behavioral fact that the operation is non-mutating ('Never sends') plus the shape of the return value (ok, headline, error panel with causing pages). It omits any mention of auth/session requirements or latency, keeping it short of 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?

Three tightly packed clauses covering action, return shape, and the critical no-send guarantee, with no filler and the primary action front-loaded.

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

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

Because there is no output schema, the description usefully enumerates what comes back and flags the non-mutating behavior, which is exactly what an agent needs. It could add a note about what 'ok' vs an error panel implies for next steps, but it is otherwise 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?

Zero parameters, so there is nothing to disambiguate; baseline for a no-parameter tool is 4.

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

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

States a specific verb and resource ('Runs ELSTER's "Prüfen" on the open form'), which is unambiguous and clearly distinct from siblings like elster_form_save, elster_form_press, or the submission tools.

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

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

The phrase 'on the open form' implies a prerequisite (a form must already be open), and 'Never sends' hints this is the pre-submission validation step. However, it never explicitly says when to use this versus elster_form_save, elster_form_review, or elster_form_press, leaving the agent to infer.

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?

With no annotations, the description carries the full burden, and it does disclose read-only status, breadth-first ordering, and that it is intended as a one-time discovery pass. It omits cost/truncation behavior (what happens at the default maxPages=60), pagination, and any error handling for an operationally heavy crawl.

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

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

Two tight sentences, front-loaded with the core action and finishing with the usage cue. No filler.

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

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

No output schema and no annotations, so the description must cover behavior and returns. It names what is returned (fields, repeat groups) but leaves the maxPages cap and truncation semantics unexplained for what is a potentially expensive crawl.

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 0% and neither parameter is documented in the schema. 'Below a RID' gives partial meaning to rootRid, but maxPages (default 60) is never explained — an agent cannot tell what the page cap means or how it affects results.

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 ('Walks every page below a RID') plus the traversal order (breadth-first, read-only) and the return content (fields and repeat groups). It implicitly contrasts with single-page siblings like elster_form_page by emphasizing 'every page', but it never names a sibling, so it stops short of full discrimination.

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

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

'Use it once per form/Anlage to learn which Kennzahl lives on which page' gives a clear context and even a quantity hint ('once'). However, it does not name alternatives (e.g., elster_kennziffern_list, elster_form_page) or state when not to crawl.

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?

No annotations are provided, so the description carries the full burden. It implies a destructive mutation but does not disclose whether deletion is reversible, whether subsequent row indices shift, permission requirements, or what is returned. The '0-based' note is the only behavioral 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. It is tight, though the brevity edges toward under-specification rather than genuine conciseness.

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 three-parameter mutation tool with no annotations, no output schema, and zero schema description coverage, the description is too thin. Key details an agent needs to call it correctly, such as the meaning of `rid` and post-delete behavior, 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 0%, so the description must document all three parameters. It explains `index` ('0-based') and hints at `group`, but leaves `rid` entirely unexplained, so it only partially compensates for the coverage 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?

States a specific verb ('Deletes') and resource ('row index of an inline repeat group'), which is enough to distinguish it from most siblings. However, it does not explicitly contrast with the obvious sibling elster_form_add_row or clarify its role in the form-editing workflow.

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 when-to-use guidance, prerequisites, or alternatives are given. The description never mentions the related add/set page tools or when deleting a repeat-group row is appropriate versus other form mutations.

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?

With no annotations, the description carries the full burden and does so: it discloses that the form is saved, that a separate visible browser window with its own login is opened, that 'Prüfen' runs and a clean result advances to 'Formular absenden', and that the MCP then loses the ability to act in that window. It also warns about the blocking side effect on sibling tools, which is exactly the kind of hidden behavior an agent needs.

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

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

Four sentences, front-loaded with the outcome (hand off to the user), then mechanics, then the critical constraint, then the follow-up call. Every sentence contributes a distinct fact with no repetition.

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

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

For a one-optional-parameter tool with no annotations and no output schema, the description covers the whole lifecycle: preconditions, what is opened and validated, where control is lost, the blocking window, and which tool to call next. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so aufgabeId is already documented including its 'newest draft' default. The description corroborates the conditional role by saying it saves the open form or takes the given draft, but adds no format, id-source, or error semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a specific verb+resource: hands a finished form to the USER for sending, and immediately scopes it against the surrounding automation tools by saying the MCP detaches and cannot click in that window. That makes it clearly distinguishable from siblings like elster_form_press, elster_form_check, and elster_form_handoff_wait.

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 exactly when this applies (a finished form ready to send), what it does with an open form versus a supplied draft, and explicitly names the follow-up tool elster_form_handoff_wait. It also gives a hard usage constraint: until the window is closed, the other elster_form_* tools refuse to run.

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?

With no annotations, the description carries the burden well: it discloses that the call blocks, that a timeout applies, that files are written to disk, what the response contains, and how to handle a non-terminal result. The one soft spot is the "Read-only" label sitting next to a side effect that writes HTML + PDF files, which could confuse an agent about disk mutations even though no annotation is contradicted.

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

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

Three tight sentences, front-loaded with the sequencing constraint, then the outcome, then the retry rule. No filler and every clause carries actionable 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?

There is no output schema, and the description compensates by naming the returned Transferticket, file paths, and the closed flag. It stays slightly short of a full return-shape description (e.g. whether closed:true also returns paths), but it is complete enough to invoke and interpret 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 archiveDir and timeoutMinutes are already fully documented in the schema; the description only alludes to them ("timeout passes", "saves ... as HTML + PDF"). Baseline 3 is correct when structured fields do 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?

The description states a specific action (block until the handoff window closes, then archive the Übertragungsprotokoll as HTML + PDF) and ties it to a named sibling, elster_form_handoff, making the tool unambiguous against the form_* family.

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

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

It gives explicit sequencing ("Call right after elster_form_handoff") and a concrete retry rule ("If it returns closed:false, call it again"), which is exactly the when/when-again guidance an agent needs for a blocking tool.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: Datenübernahme is 'none by default', the run halts at the form's Startseite (i.e., it does not persist or submit), and the return mirrors elster_form_page. It still omits session/auth prerequisites and what failure states look like.

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

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

Two tight sentences, front-loaded with the core action and ending on the next-step routing. Zero filler; every clause conveys new 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?

For a multi-step initialization tool with no output schema and no annotations, the description covers the main stages, the stopping point, the return type by reference, and the required follow-up. Only the authentication/session preconditions are left unstated.

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

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

Schema coverage is 80%, so the schema already explains form, anlagen, takeover, and importEdaten. The description only reinforces defaults ('none by default') and does not add format or syntax detail beyond the schema, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Starts a NEW form') and enumerates the concrete flow it performs (year, Datenübernahme, Anlagenauswahl, eDaten import). The capitalized NEW implicitly separates it from elster_form_open, but it never names that sibling, so differentiation relies on inference.

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 forward guidance ('Follow with elster_form_save to persist it as a draft') and notes defaults, but says nothing about when to choose this over the other start tools (elster_form_open, elster_est_start, elster_ustva_start) or which situations it is not suited for.

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?

With no annotations, the description carries the full burden and discloses several important behaviors: it returns the Startseite contents, falls back to the newest draft, re-enters an already-open form instead of failing, and enforces a one-form-open constraint. It does not cover error handling, permissions, or session prerequisites.

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 tightly written sentences with the core action and return value front-loaded, followed by fallback and state-management details. Every sentence adds distinct information and none is wasted.

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

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

For a one-parameter tool with no annotations and no output schema, the description is nearly complete: it explains the action, the optional-parameter fallback, re-entry behavior, and the one-open-form constraint, and it sketches the return payload. Minor gaps remain around error cases and session prerequisites, but nothing critical for calling 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. The description adds meaningful semantics beyond the schema by explaining what happens when aufgabeId is omitted (the newest draft is opened), which is not evident from the parameter definition alone.

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

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

States a specific verb ('Opens') and resource ('saved draft in the engine session'), and even summarizes the return payload (Startseite fields, repeat groups, navigation RIDs). It implicitly distinguishes itself from elster_form_new (new form) and elster_drafts_list (listing drafts), but does not explicitly name any 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?

Provides clear context for the optional aufgabeId parameter (newest draft opened when omitted) and explains the re-entry behavior when a form is already open. It does not explicitly state when to prefer this tool over alternatives like elster_form_new, but the saved-draft focus and the parameter description 'From elster_drafts_list' make the intended usage 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?

No annotations are provided, so the description carries the full burden. It does disclose the key safety trait ('Read-only.') and describes the return shape in useful detail, but omits pagination semantics, authentication/prerequisite state, and any limits or 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?

Front-loaded with the core action, then the RID mechanic, then the return contents in a single dense paragraph. Every clause carries information, though the parenthetical RID example is long and slightly heavy.

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

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

With no output schema and no annotations, the description does the heavy lifting by enumerating what is returned (plain fields, repeat groups, non-navigation commands, validation errors, nav RIDs), which is sufficient for an agent to invoke and interpret the call.

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 0% and the single rid parameter is undocumented in the schema, but the description compensates well: it gives a concrete RID example, explains the format ('FormData://...'), notes the source ('the nav list of any page'), and implies rid is optional ('jumps there first').

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: 'Reads a page of the open form,' and elaborates on the exact payload (fields, repeat groups, commands, validation errors, nav RIDs). It does not explicitly differentiate itself from siblings like elster_form_crawl or elster_form_check, 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 description implies usage ('a page of the open form') and explains that passing rid jumps there first, but never states when to prefer this tool over elster_form_crawl, elster_form_check, or elster_form_review. Usage is inferable rather than explicit, and no when-not conditions or alternatives are named.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the refusal policy (no sending, draft deletion, or logout) and that it mutates form state via commands. It omits auth requirements, idempotency, error behavior, and what the response looks like for a mutation 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?

A single dense sentence, but it is front-loaded with the core concept, then examples, then refusals. Each clause earns its place, with minimal waste.

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

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

For a 3-parameter, no-annotation, no-output-schema tool, the description covers identity, examples, and exclusions, but leaves gaps on return behavior, error handling, and when this outranks the sibling form tools. Adequate but not fully complete for a low-level escape hatch.

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 the schema documents most parameters. The description adds real value by giving concrete command examples (AddMzbItem, FillInProfile) and clarifying buttonId vs. raw command usage. The 'rid' parameter ('Jump here first') remains opaque in both schema and 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?

States a specific verb+resource ('presses a button by id or posts a raw reqCmd JSON'), and the 'escape hatch' framing distinguishes it from structured siblings like elster_form_set or elster_form_add_row. The purpose is clear, though the description leans on internal jargon (reqCmd, EditDetachedMzbSemIndex) that assumes domain knowledge.

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 'Escape hatch' label implies this is for cases the normal form tools can't handle, and the refusal list ('Sending, deleting drafts and logging out are refused') gives explicit when-not boundaries. However, it never names which sibling to prefer for standard edits, leaving the routing to inference.

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

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

With no annotations, the description carries the full burden and delivers: state-machine behavior (returns to edit mode in the same call), safety guarantees ("Absenden" stays refused, never transmits), and accepted-command constraints (only EINGABE/PRUEFEN while on the overview). It even discloses the return shape, which is far beyond what any structured field provides.

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?

Purpose and the pre-submit context are front-loaded, and the dense sentence still avoids filler. It is lengthy and information-packed rather than trimmed, but every clause adds a distinct behavioral fact.

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

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

No output schema exists, and the description compensates by describing the returned structure as sections of rows with (Zeile, label, value, Kennzahl, source). Combined with the conditional flow and safety constraints, an agent has everything needed to invoke and interpret this correctly.

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

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

The tool takes zero parameters, so per the baseline there is nothing to document; the schema is empty and closed. No parameter meaning is 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?

States a specific composite action: runs "Prüfen", then conditionally reads ELSTER's "Formular absenden" overview, exposing exactly what would be transmitted. This clearly separates it from the submission tools in the sibling set (e.g. elster_form_press) by declaring it never transmits, so an agent can tell its role apart 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?

Gives clear context: this is the final check performed before the user submits, and the overview read is gated on "Prüfen" being clean. It does not explicitly name an alternative tool (e.g. elster_form_check) or spell out when to prefer that instead, so it stops short of full when/when-not routing.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the form is saved as a draft, that it closes the form, and that the server session times out after ~30 minutes idle with unsaved work left only in ELSTER's auto-recovery. This is meaningful behavioral context beyond a bare mutation statement.

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 action and immediately followed by the reopen path and the time-sensitive warning. Every sentence adds distinct value, and nothing is repeated or wasted.

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

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

For a zero-parameter, no-annotation, no-output-schema tool, the description covers the essential behavior: what it does, how to reopen, and the session timeout risk. It does not mention return value or error handling, but those are secondary for a simple save-and-close operation.

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

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

The tool takes zero parameters, so there is no parameter semantics to document. Per the rubric, a 0-parameter tool earns a baseline of 4; the empty schema is fully consistent with 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?

States a specific verb (saves) and resource (open form as a draft) and notes that it closes the form. It also distinguishes the follow-up action by naming elster_form_open for reopening, so an agent can separate it from open/new tools.

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

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

Provides clear context: use it to save the open form before long pauses, and reopen with elster_form_open. It does not explicitly state when not to use it or name alternatives like elster_form_new, but the intended usage is unambiguous.

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?

With no annotations, the description carries the full behavioral burden and does so well: it discloses that validation errors return in `errors` while HTTP is always 200, defines exact value semantics per widget type, and covers money rounding/format rules. It omits auth/permission needs and whether a partial set is atomic or what happens to untouched fields, but the error-handling disclosure is unusually valuable.

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

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

Every sentence carries operational content: purpose, key format, widget value rules, money formatting, error channel, and repeat-group edge case. It is dense but front-loaded and free of filler, and the money rules genuinely change how an agent formats input.

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 two-parameter mutation tool with no annotations and no output schema, the description covers keys, value types, money formatting, error surface, and nested repeat-group sub-pages. It stops short of stating whether the whole form saves or only supplied fields, and there is no success-response detail, but an agent has enough to call it correctly.

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

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

Schema coverage is 50% (only `rid` is documented in the schema). The description compensates heavily for the undocumented `values` object by explaining that keys are a Kennzahl or field name, must match exactly one field, and what value types each widget expects. It materially exceeds the schema for the most important parameter.

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: setting plain fields on a page and saving them server-side. It distinguishes itself by covering plain fields, checkboxes, radios, selects, and detached repeat-group sub-pages, which implicitly separates it from siblings like elster_form_add_row or elster_form_press. However, it never names an alternative tool, so sibling differentiation is inferred rather than stated.

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 strong how-to guidance (key formats, checkbox/radio value conventions, repeat-group sub-page handling), but says nothing about when to reach for this tool versus elster_form_save, elster_form_press, or elster_form_add_row. Usage is strongly implied by scope statements rather than explicitly routed, landing at minimum-viable.

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?

No annotations provided, so description must carry the burden. It states the return content but does not disclose side effects, authentication requirements, or idempotency. Minimal but sufficient for a simple list query.

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?

Single sentence, includes specific examples and categorization. No extraneous content.

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 zero parameters and no output schema, description adequately explains what is returned. Lacks mention of prerequisites like authentication, but for a simple list of codes it is largely 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?

No parameters, so baseline is 4 per guidelines. Description adds no parameter info because none exist.

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?

Description clearly states verb 'returns' and resource 'list of supported UStVA Kennziffern', includes examples and type distinction (NET/TAX). No sibling tool serves a similar purpose.

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 or when-not-to-use guidance. Usage is implied by the tool's name and description, but no alternatives or exclusions are mentioned.

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?

Without annotations, the description must disclose behavioral traits. It states returns success/final URL or error, which covers basic behavior. However, could provide more detail on side effects (likely none) or error format.

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 purpose. Every sentence provides value: first states what it does, second gives usage guidance. No wasted 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?

Given the tool's low complexity (no params, no output schema), the description covers purpose, return behavior, and usage guidance adequately. A bit more detail on error cases could improve completeness.

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?

No parameters exist, and schema coverage is trivially 100%. The description adds no param info, but with zero params, the baseline 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 clearly states the tool verifies login ability with certificate+password, specifying both verb and resource. It distinguishes from siblings like elster_ustva_start which are for actual submissions.

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 explicitly says 'Use this once before submitting anything', providing clear context for when to use. Does not mention exclusions but given the tool's simplicity, the guidance is adequate.

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?

With no annotations, the description carries the full burden, and it does disclose the artifact contents (Transferticket, server receipt time, full content incl. attachment names) and the default destination folder. However, "Read-only" is ambiguous for a tool that writes files to disk — it never states whether existing files are overwritten or how they are named, which is the side effect an agent most needs to know.

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

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

A single dense sentence that front-loads the action and output format before selection mechanics. The parenthetical clause listing receipt fields is packed but each element is informative; no sentence is wasted.

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

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

With no output schema, the description correctly describes the produced artifacts and their default location, which is what an agent needs to know. The remaining gap is file naming and overwrite/collision behavior on repeat calls, which matters for a tool that persists files.

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%, and the description compensates for the undocumented parameters by giving the default limit of 1, the newest-first ordering for years, and the default dir of <downloadDir>/nachweise. It repeats the nachrichtId provenance already in the schema, so it is additive rather than fully compensating.

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?

"Saves the Übertragungsprotokoll of submitted forms as HTML and PDF" states a concrete verb, resource, and output format, plus the reason ("as proof of what was sent"). It is clearly distinguishable from siblings elster_submissions_list (listing) and elster_submission_protocol (protocol retrieval).

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 explains the two selection paths — by nachrichtId sourced from elster_submissions_list, or by formFilter/years — and notes ordering and the default limit, which is real routing guidance. It stops short of saying when to prefer one path over the other or when not to use this tool at all.

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?

With no annotations, the description carries the burden and does well: it declares 'Read-only' and warns that results contain 'real personal tax data'. The parameter note about each protocol being a round-trip with a default of 3 also discloses cost behavior. Missing only permission/auth specifics.

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 what is read, then the selection modes and safety note. Dense but every clause carries information; only mildly long-winded.

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

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

No output schema or annotations exist, so the description must cover returns and safety, and it does: it describes the returned fields, the sensitivity of the data, and the read-only nature. An agent has enough to invoke it correctly, though pagination/ordering behavior is unstated.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds the either/or grouping semantics (nachrichtId OR formFilter/years) that the flat schema does not express, which is meaningful selection guidance.

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 (reads the Übertragungsprotokoll of already-submitted returns) and enumerates the returned content (Zeile number, label, value, ELSTER field id). It also distinguishes itself from the sibling elster_submissions_list by naming it as the source for nachrichtId.

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

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

Gives the two selection modes explicitly — by nachrichtId (obtained from elster_submissions_list) or by formFilter/years — and states the purpose (earlier years as context). No explicit when-not guidance, but the routing is unambiguous.

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?

With no annotations present, the description carries the burden and does reasonably well: it declares the operation read-only and describes exactly what the listing returns. It omits pagination/scope limits, permission requirements, or ordering behavior, so it stops short of full disclosure.

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

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

One dense, front-loaded sentence that lists scope then return payload then downstream consumers, with no filler. The German UI-path notation is heavy but earns its place as the exact locator.

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

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

No output schema exists, and the description compensates by enumerating the returned fields (filing, date, Ordnungskriterium, aufgabeId, nachrichtId), and the sole parameter is covered by the schema. Adequate for a simple list tool, though read-only behavior and any result limits are only lightly covered.

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

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

Schema description coverage is 100% and the single formFilter parameter is fully documented in the schema with an example. The description adds nothing about the filter, so the baseline of 3 applies — the schema does all 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 and resource (lists filed submissions under 'Meine Formulare' → 'Übermittelte Formulare') and enumerates the returned fields, so an agent can distinguish it from siblings like elster_drafts_list or elster_belege_list without opening a schema.

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

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

It explains downstream use cases explicitly — the aufgabeId is for reuse as a Datenübernahme source and the nachrichtId is consumed by elster_submission_protocol — giving clear context. It does not, however, say when to prefer this over elster_drafts_list or state any exclusion conditions.

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?

No annotations provided, so description must carry full burden. It indicates a read operation with optional download, but does not disclose side effects, permission requirements, or whether downloading modifies state. Minimal transparency beyond the obvious.

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?

Description is concise (one sentence) but sacrifices detail. It is front-loaded with the main action, but could usefully add more information without becoming verbose.

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 2 parameters, no output schema, and no annotations, the description is incomplete. It does not explain years, return format, or prerequisites (e.g., valid session). Among many sibling tools, more context would help.

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 describes two parameters (years, downloadPdfs) with 0% description coverage. The tool description hints at 'downloads PDFs' but does not explain the years parameter or its purpose. No parameter-level documentation provided.

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 it reads transmission history from ELSTER and optionally downloads PDFs. The verb 'reads' and resource 'transmission history' are specific. However, it does not explicitly differentiate from sibling tools like elster_sync_inbox, though the name suggests history vs inbox.

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 guidance on when to use this tool vs alternatives. Does not mention prerequisites, ideal scenarios, or when to avoid using it. Sibling tools are listed but not addressed.

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

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

With no annotations, the description must disclose behavioral traits but only states two actions: reading and optionally downloading PDFs. It fails to mention authentication requirements, side effects (e.g., state changes from downloads), pagination behavior, or error handling, which are critical for safe invocation.

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 concise sentence, properly front-loaded with the primary action. However, it could benefit from slightly more structure to separate reading from downloading, though overall it remains efficient.

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

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

Given no output schema and only two parameters, the description lacks detail on the return format (e.g., message list with metadata), prerequisites, and edge cases. While the tool appears simple, the description omits information needed for reliable invocation.

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

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

Schema coverage is 0%, so the description must explain parameters. It only hints at 'downloadPdfs' via 'Optionally downloads each message as PDF', but provides no meaning for 'maxPages'. The parameter semantics for half the parameters are entirely unaddressed.

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 specifies the verb 'Reads' and the resource 'ELSTER inbox messages', with an optional action 'downloads each message as PDF'. It differentiates from sibling tools which cover config, sessions, forms, etc., making the purpose unambiguous.

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 guidance is provided on when to use this tool versus alternatives (e.g., for specific inbox filtering or batch operations). The description does not mention prerequisites or when not to use it, leaving the agent to infer context.

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

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

No annotations provided, so the description must cover behavior. It mentions returns but omits side effects, required permissions, error cases, or whether the tool is read-only. The phrase 'based on the configured supplier patterns' hints at external configuration not explained.

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 sentence with no unnecessary words. It front-loads the action ('Tests whether...') and quickly states output. However, it sacrifices completeness for brevity.

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 the domain-specific tax context, lack of output schema, and zero parameter explanations, the description fails to equip an agent for correct invocation. Essential details about input fields, configuration, and error conditions 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 0% and the description does not explain the parameters contactName and description. Agents cannot determine what values to provide or how these relate to the voucher being tested. This is a critical 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 clearly states the tool tests reverse-charge detection based on supplier patterns and specifies the output (matched supplier and region or null). It distinguishes from sibling tools like elster_ustva_confirm or elster_ustva_generate_xml by focusing on detection.

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 guidance on when to use this tool vs. alternatives. The description only states what it does, without clarifying prerequisites, scenarios, or exclusions. Agents must infer context from the tool 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?

With no annotations provided, the description carries the burden of disclosure. It clarifies the non-submitting nature and archiving purpose, which is helpful, but lacks details on side effects, performance, or permissions. It does not contradict any 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?

The description is extremely concise, consisting of two sentences that front-load the purpose and key differentiator. Every sentence adds value without unnecessary detail.

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 the tool's complexity (3 parameters with a nested object) and lack of output schema, the description adequately explains its primary function and distinction from siblings. However, it could be more complete by briefly mentioning what the output is (e.g., returned XML string or file), but overall it is sufficient for an expert user.

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

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

The input schema has 100% coverage, so parameters are well described in the schema. The description adds no additional information about the parameters beyond what the schema already provides, so it meets the baseline for high schema 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 uses a specific verb ('generates') and resource ('ELSTER UStVA XML snapshot'), clearly stating its archiving purpose and distinguishing itself from the sibling 'elster_ustva_start' by explicitly noting it does NOT submit.

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 states when to use the tool ('for archiving', 'useful for audit trails') and when not to ('does NOT submit'), pointing to the correct sibling tool ('submission goes via elster_ustva_start').

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