New Runtime public records

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

Beyond the read-only/non-destructive annotations, the description adds critical behavioral context: it states the tool is 'Free, no auth,' and enumerates the specific types of data returned (New Runtime records, patterns, source hub, etc.).

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 highly structured and front-loaded, addressing the primary use case and differentiating it from the tool's function in the first sentence.

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 high coverage and strong annotations, the description is exceptionally complete. It covers the 'what,' the 'why,' and the 'how' (cost/auth).

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?

Although schema coverage is 100%, the description adds semantic value by clarifying the 'task' parameter's purpose—specifying that it 'refines related records' and giving concrete examples of intent (e.g., 'who else covered this').

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 defines the tool's purpose: contextualizing external URLs (AI/software links found elsewhere). It distinguishes itself by focusing on identifying novelty and gathering related context (records, patterns, hubs).

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 provides explicit usage guidelines by instructing the agent to 'Use first when you found an AI or software URL elsewhere,' defining the exact trigger and domain for the tool's application.

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 read-only, idempotent, non-destructive behavior. The description adds useful context beyond them: free access with no auth, what the ledger contains, and that resolved forecasts carry grades and evidence. It does not discuss pagination or rate behavior, so a 4 is appropriate.

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 usage condition is front-loaded and every clause carries useful information. The first sentence is long and dense, but the example and free/no-auth note are efficient and do not waste space.

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-only tool with an output schema, the description is complete enough to call correctly. It explains the forecast content, status distinction, access model, and provides an example 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 description coverage is 0%, so the description should compensate. It provides an example using status and limit, and mentions resolved forecasts, but it does not explain the meaning of status=all, the limit maximum, or default behavior, leaving meaningful parameter semantics to the schema constraints.

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: reading New Runtime's dated forecast ledger and public scorecard. It explains the forecast contents (claim, probability, due date, source analysis) and distinguishes this from all sibling tools, none of which deal with forecasts.

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 a clear usage context: use when you need falsifiable predictions about AI engineering with a track record. The free/no-auth note is helpful, but there are no explicit exclusions or named alternatives, though no sibling is directly comparable.

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 significant behavioral context beyond the annotations by stating it is 'Free, no auth' and defining the output constraints (up to 12,000 characters, title, date, URL). This operational context is crucial for an AI agent planning its execution environment.

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 highly efficient, using one dense paragraph to convey the 'what,' 'why,' 'how much,' and 'cost/authentication' of the tool without any 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 that the tool accepts zero arguments, this definition is maximally complete. It specifies the exact content, format, and limitations of the resulting data, eliminating ambiguity for the invoking agent.

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?

Since the input schema has zero parameters, the description is fully responsible for defining the tool's scope and function. The baseline score of 4 applies as the description handles the entire operational definition.

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 function: providing a synthesis of the week in AI engineering. It specifies exactly what this 'metadox' contains (contradictions, forecasts) and its format (Markdown), making it immediately clear what the tool delivers.

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 tool explicitly tells the agent when to use it—'Use when you want one synthesis... instead of a list.' This guides the AI perfectly towards choosing this tool for high-level over lower-level retrieval tasks found in siblings like 'search_archive'.

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 read-only, idempotent, non-destructive and closed-world, so the extra burden is low; the description still adds value with 'Free, no auth', which annotations do not express. It omits what happens when a record is missing, and it doesn't reconcile the fact that the schema marks zero required parameters while the text implies at least one of url or kind+slug is needed.

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

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

One dense sentence leads with the precondition and the returned fields, followed by the addressing rule and a literal example. Nothing is redundant and the most decision-relevant clause is first.

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 spelled out, though the field list is a harmless convenience. The remaining gap is the missing-record path and the ambiguity between zero required parameters in the schema and the 'URL or kind + slug' prerequisite in the prose for a single-record fetch.

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 33% — url is documented, kind and slug are not — so the description has to compensate, and it does by explaining the two mutually exclusive addressing modes ('pass the URL you got, or kind + slug') with a worked example. It doesn't state that the two modes must not be mixed, nor that no parameter is strictly required, but the calling pattern is clear.

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 ('read one record in full') and enumerates the payload an agent gets back: title, dates, source URLs, topics and body text. It also positions itself against the sibling search/listing tools (search_archive, whats_new, what_changed), so the agent can tell fetch-one from find-many without opening a schema.

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

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

Gives an explicit entry condition — 'use after search_archive, whats_new or what_changed' — which routes the agent from discovery to retrieval. It does not spell out the inverse case (when a caller should stay with the listing tools, or how to fetch many records), but the sequencing guidance is concrete rather than 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 read-only, idempotent, and non-destructive behavior, so the description only needs to add context. It does so by noting the query is scoped to the caller's submitted items and only exposes public moderation fields, preventing unrealistic expectations about internal details.

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 delivers the purpose first, then the required id format, then the output scope. There is no filler, repetition, or 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?

For a one-parameter read-only query with full schema coverage, the description provides everything an agent needs: what to pass, what kind of result to expect, and that only public moderation fields are returned. The examples of statuses add useful context despite the lack of an 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 schema already fully documents submission_id, including its format and origin ('returned by a submit tool'). The description does not add meaningful parameter semantics beyond what the schema provides, so the baseline 3 for full schema coverage 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 states a specific purpose: retrieving the moderation status of user-submitted sources, corrections, or usage receipts by as_ submission id. It clearly distinguishes this tool from siblings like get_record or search_archive by emphasizing the moderation-specific query and the 'you submitted' scope.

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 clear triggering context: after a submit tool returns an as_ id, call this to check the moderation outcome. It does not explicitly name alternatives or a when-not-to-use condition, so it falls just short of a 5.

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

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

Annotations already cover read-only, idempotent, non-destructive, closed-world, so the description correctly avoids restating safety. It instead adds genuinely new operational context: 'Free, no auth' (auth requirement an agent must otherwise discover) and a data-recency window ('last fortnight') that constrains result freshness.

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 'Use when' trigger, then payload contents, then the practical example and lookup URL. Dense but every clause carries information; only the redundant example object slightly duplicates the schema's examples field.

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 needn't document return shape, and with a single fully-described parameter plus annotations, the main gaps are closed. Nearly complete — it could mention an error case for an invalid slug, since the topic list URL implies failures are possible, but nothing critical 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 baseline is 3. The description goes beyond the schema by supplying the topic-list URL (https://newruntime.com/topics.json), which tells the agent how to resolve a valid slug — the schema only offers three examples and says 'slug or name'. The inline example call is marginal since examples already exist in the schema.

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

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

States a specific verb+resource ('get a brief on one AI-engineering topic') and enumerates exactly what the brief contains: summary, last-fortnight publications, related patterns/shifts/field notes/news signals with URLs. This is concrete enough to distinguish it from list/search siblings like search_archive or whats_new 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?

The opening 'Use when you need the background on one AI-engineering topic in one call' gives a clear activation context, reinforced by the 'one call' framing that implicitly argues against assembling the same data from search/archive tools. It does not explicitly name an alternative or state when-not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower. The description adds genuinely non-schema context: the operation is free, accepted evidence is credited publicly in the record's weekly update, and each task tells you the follow-up tool. The only gap is that it doesn't note pagination/limit 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?

Dense and front-loaded with the trigger condition and the core promise, with zero filler. The final example fragment is slightly awkward in placement but earns its place by demonstrating a real 'kind' value.

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 shape needn't be described, and the description covers task content, incentive, and the follow-up tool. Only the parameter semantics gap (unexplained limit and enum options) keeps it from being fully 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 0%, so the description must compensate. It shows an example of the 'kind' enum value, which helps, but the enum's three options are not explained and the 'limit' parameter (range 1-40, default 10) is never mentioned, leaving half the parameters undocumented.

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 (list) and a precise resource (open verification tasks on New Runtime patterns and shifts that are stale or below high confidence), and it characterizes the tasks as carrying the record, missing evidence, and the submit tool to use. Sibling tools like submit_source and get_record are clearly distinct from this discovery 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 an explicit trigger ('Use when you can contribute evidence') and explains the actionable payload of each task, including which submit tool to use, which routes the agent toward follow-up tools. It doesn't spell out when *not* to call it or contrast with alternatives, so not a 5.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so safety coverage is done. The description adds value the annotations cannot: free to call, when charges apply, and that payment works without an account — key facts for an agent deciding whether it can use paid endpoints.

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 front-loaded sentence with the trigger first and the itemized contents after. The parenthetical price list is dense but each item provides concrete cost information an agent needs; slightly long for a no-argument listing tool.

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 covering the return shape, the description only needs to convey scope, cost model, and access requirements — and it covers all three, including the accountless payment path. Nothing an agent needs to decide whether to call 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?

Zero parameters, so there is nothing to disambiguate; baseline is 4. The description does not need to describe inputs and correctly doesn't invent any.

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 New Runtime's x402 tools') and enumerates the concrete contents (endpoint, USDC price, input example, charge timing, payment path). No sibling in the list does anything similar, so it is distinguishable 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?

Gives an explicit trigger ('Use when the free tools left a question open and you can pay per call') and a counter-signal that the tool itself is free, so the agent knows both when to reach for it and that calling it carries no cost.

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

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

Beyond the annotations, which already establish read-only, idempotent, non-destructive, non-open-world behavior, the description adds cost and auth context ('Free, no auth'), result volume ('up to 10 hits'), returned fields, and the next-step retrieval path via get_record.

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

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

The description is front-loaded with the use condition, then concisely covers sources, return shape, auth/cost, an example, and the follow-up tool. Every sentence earns its place with 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?

Given the existing output schema and annotations, the description provides everything needed to call the tool correctly: when to use it, what it searches, what it returns, cost/auth, an example, and how to get full text 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 67%, so the schema already documents the query, kind enum, and limit constraints. The description adds an example call and clarifies that results are capped at 10, but it does not meaningfully explain the kind parameter or add syntax 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?

The description states a specific verb and resource: searching New Runtime's Field Notes, Raw Signals and Analyses for dated, source-linked AI-engineering coverage. It distinguishes itself from the sibling get_record by explicitly positioning itself as the search step before full-text 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 gives a clear use condition ('Use when you need dated, source-linked coverage ... without crawling the web') and names the follow-up tool get_record for full text. It does not explicitly state when not to use it versus sibling tools like get_topic_brief or what_changed, so it falls short of full 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 provide no meaningful behavioral signals, so the description carries the burden. It discloses key non-obvious effects: submissions are not published, review happens weekly on Monday, accepted items are credited in the record's weekly update, and the service is free. It does not cover response behavior or duplicate handling, but the process details go well beyond annotation defaults.

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

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

The description is compact and front-loaded: purpose first, then policy details, then a schema link. Every sentence adds distinct information, with no redundancy or 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?

The tool has 7 parameters, a nested agent object, and no output schema or annotations. The description explains the review process and links a schema, but stops short of describing what a caller should expect after submission, how to format record values, or how to fill optional fields. It is adequate but not fully 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 only 43%, and the description compensates minimally by naming 'outdated, unsupported or contradicted' (mirroring the problem enum) and 'with evidence' (pointing toward evidence_url). It adds no meaning for note, confidence, the agent object, or the accepted record formats, leaving the agent dependent on the linked 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 action ('Report a claim in a published record'), the target resource, and the problem categories (outdated, unsupported, contradicted). The title and description clearly distinguish this from siblings like submit_source and submit_usage_receipt by focusing on corrections to existing claims.

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

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

The description implies when to use the tool: when a claim in a published record needs correction, and it adds policy context (free, weekly review). However, it does not explicitly provide when-not-to-use guidance or compare with alternatives, so the agent must infer the boundary relative to sibling tools.

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 are minimal (readOnlyHint=false, etc.), so the description must carry the behavioral burden. It transparently explains that submissions are not published, reviewed weekly, accepted items credited, and it returns a submission id and status URL. This goes beyond what annotations provide, disclosing the review workflow and non-immediate outcome.

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 concise sentences: first states purpose, second covers constraints and process, third states return value and schema link. No fluff, front-loaded, and each sentence 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?

For a submission tool with a nested agent object and no output schema, the description adequately covers the workflow (propose, review, credit) and return type (submission id, status URL). It does not detail error handling or edge cases, but those are largely covered by the schema, making it sufficiently complete for an agent to call correctly.

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

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

Schema coverage is 75%, with all parameters already having descriptive text. The tool description adds no extra meaning for url, reason, agent, or related_record; it merely references a schema URL. It does not compensate for the coverage gap or clarify parameter usage beyond the schema, so a 2 is appropriate.

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

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

The description states a clear verb ('Propose') and resource ('a source ... for a New Runtime record or topic'), and specifies the source types (primary page, paper, repo, docs). It is distinct from siblings like submit_correction and submit_usage_receipt, though it does not explicitly name them, so it earns a 4 rather than 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 provides context (free, weekly review, not published) but gives no explicit guidance on when to use this tool versus alternatives like submit_correction or submit_usage_receipt. There is no 'use this when' or 'instead of' statement, leaving the agent to infer selection criteria.

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 provide no meaningful behavioral signal (all false), so the description carries the disclosure burden. It transparently states that submissions are not published, are reviewed weekly on Monday, and accepted items are credited in the record's weekly update. This goes beyond the annotation fields and gives the agent a clear picture of side effects and post-submission handling.

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 four sentences long, with the core purpose front-loaded in the first sentence. The subsequent sentences add useful process context and a schema link, with no significant filler. Minor items like 'Free;' are arguably unnecessary, but the overall structure is efficient and well-ordered.

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 tool with no output schema and a nested agent object, the description explains the entire post-submission lifecycle: not published, reviewed weekly, credited if accepted. It also links to a full schema for parameter details. It does not describe the immediate response or error behavior, but that is a minor gap for a simple submission 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 75%, so the schema already documents most parameters in detail, including accepted URL formats for record and the meaning of public_url. The description only loosely maps to parameters ('used a record and for what... where it can be seen') and adds little beyond the schema. The agent object's purpose is also left to its nested schema descriptions, 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?

The description opens with a specific verb and resource: 'Record that you used a New Runtime record and for what (optionally where it can be seen).' This clearly distinguishes the tool from sibling submission tools like submit_correction and submit_source by focusing on usage receipts. The added context about helping the weekly desk further clarifies the tool's intent.

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 should be used when an agent has used a New Runtime record and wants it credited, and it explains the review process. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or when-not-to-use guidance. The usage context is present but left 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?

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the description's job is additive — and it does add: 'Free, no auth' and the promise that it saves re-reading and re-deduplicating the web. It also enumerates the shape of the returned delta (stronger/weaker, obsolete, resolved, new-fact vs new-angle, still-holds), which goes beyond the hints.

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 usage trigger and ends with a compact call example, so the important part is read first. The middle is a long comma-chained enumeration that could be trimmed, but it is all substantive content rather than filler.

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

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

With only two optional parameters, full schema coverage, a rich annotation set, and an output schema that documents return values, the description covers everything an agent needs: when to reach for it, what category of answer it produces, and that no auth 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 description coverage is 100%, including the default (7 days ago) and the 90-day lookback bound, so the schema already carries parameter meaning. The description only restates the date concept ('since a date') and adds an inline example that duplicates the schema's own examples, so 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: it returns the delta since a date across AI-engineering patterns, obsolete items, resolved forecasts, and known-vs-new stories. The scope is precise enough to separate it from a general 'what's new' feed, though it never names the sibling `whats_new` or `get_topic_brief` for explicit contrast.

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?

Opens with a clear when-to-use trigger ('when you already know a topic and need only what changed since a date'), and gives concrete anchor examples (last run, report date). It lacks explicit when-NOT-to-use guidance or a named alternative for the case where the user does not already know the topic.

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

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

The annotations already establish that this is a non-destructive, read-only, idempotent, closed-world operation. The description adds useful behavioral context beyond that: free access with no authentication, newest-first ordering, a maximum of 40 items, and the fields 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?

The description is short and front-loaded: it starts with the use case, then adds scope, example, and alternative-tool routing. Every sentence carries useful selection or invocation 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?

This is a simple read-only feed with only two optional parameters, full schema coverage, annotations, and an output schema. The description supplies the remaining practical context an agent needs: auth cost, ordering, item cap, and when to prefer what_changed.

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 input schema already documents both parameters thoroughly. The description still adds value by giving a concrete JSON example and illustrating the intended kind filters ('signal', 'analysis'), though it does not explain every enum value.

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: a quick feed of what New Runtime published. It also gives scope (1-14 days, content kinds, newest first, max 40 items) and explicitly distinguishes itself from the sibling tool what_changed.

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 says when to use this tool ('quick feed') and names the alternative for a different need: 'For what changed against what you already knew, use what_changed.' That leaves little ambiguity for an agent choosing between the two.

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