Loading ToolBench
The agent's web reader: a URL becomes clean, cached, searchable markdown (~90% smaller).
Scout demonstrates strong naming conventions (verb_noun pattern: scout_fetch, scout_search, scout_links) and comprehensive descriptions (avg 180 chars, well above 10-char minimum). All 8 tools have explicit input schemas with type definitions and parameter descriptions. Tool annotations are properly implemented (readOnlyHint, destructiveHint, idempotentHint, openWorldHint). However, some parameter descriptions lack actionable constraints (e.g., max_tokens lacks min/max bounds), and output schemas are not formally documented. Error handling guidance is minimal, tools return results but lack recovery hints for failure cases.
Fetch a web page and get back clean, readable markdown (headings, links, code, lists) instead of raw HTML — far cheaper in tokens. The page is cached, so fetching the same URL again is free (pass fresh:true to bypass). Big pages are truncated to a token budget; use scout_search to find within them.
Remove a page from the cache.
Extract the outbound links (absolute URLs + anchor text) from a page — use it to decide where to navigate or crawl next. Every result carries the response it was read from (status, content_type, html_bytes). If the URL answered with an HTTP error, or was not HTML, the result LEADS with an `error` field: the links are then the error page's own navigation, not that page's outbound links — do not crawl them, and do not read a count of 0 as "this page points nowhere". It also says how much of the page you are holding: `count` is how many outbound links the page has, `shown` is how many came back, and `truncated: true` means the list was CUT — by `limit` (default 100) or because only the start of an oversized page was fetched — with a `note` saying which. A truncated list is not everywhere the page points; raise `limit` (max 2000) before concluding you have seen them all.
List recently fetched pages (your reading history).
A digest of everything scout has read: how many tokens the raw HTML would have cost vs the clean markdown kept (and the tokens saved), the top hosts read from, reading volume per day, and the heaviest pages.
Output schemas not documented. Tools return results but LLMs cannot predict field structure (e.g., scout_fetch returns markdown but no schema specifies field names, types, or pagination). This forces LLMs to guess at response structure.
Numeric parameters lack bounds. max_tokens (default 6000) and limit (default 100) have no min/max constraints documented. LLMs could pass absurd values (0, 999999) that break behavior or cause timeouts.
scout_list and scout_stats descriptions are generic (60-65 chars). 'List recently fetched pages' and 'Cache statistics' lack context on when to call them or what structure they return. Descriptions should be 50-200 chars with actionable guidance.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | C | 66 | 2026-07-28+ | v2 |
Has a page changed since you last read it? Re-fetches a page you already have cached and returns the fresh markdown ALONG WITH a diff against your cached copy (lines added / removed). Use it to check whether docs, a spec, a changelog or a status page moved on before you rely on what you remember. Returns null if you never read the page — read it with scout_fetch first.
Search across every page you have already fetched — ranked, token-budgeted snippets. Recall something you read earlier without re-fetching it.
Cache statistics: pages cached, bytes stored, last fetch.
No error recovery guidance. Tools lack descriptions of failure modes (e.g., 'If URL is unreachable, scout_fetch returns error X. Try scout_search to find cached content instead.'). Agents cannot self-correct on failures.
scout_links description is verbose (500+ chars) and buries key details. The explanation of 'count', 'shown', 'truncated', and 'limit' should be in parameter descriptions or a separate output schema, not the tool description.