@guardbee/mcp-security-proxy
OfficialProvides a KVKK/GDPR-compliant database gateway with a MySQL adapter, supporting PII masking, RBAC, rate limiting, and audit logging for LLM-to-database access.
Scans npm dependencies for known CVEs using OSV, helping identify vulnerable packages in npm projects.
Provides a KVKK/GDPR-compliant database gateway with a Prisma adapter, supporting PII masking, RBAC, rate limiting, and audit logging for LLM-to-database access.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@guardbee/mcp-security-proxyguard this MCP session against leaked secrets and PII"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
GuardBee MCP
🇬🇧 English | 🇹🇷 Türkçe | 🇨🇳 䏿–‡ | 🇯🇵 日本語 | 🇰🇷 한êµì–´ | 🇧🇷 Português | 🇪🇸 Español | 🇩🇪 Deutsch
Security for AI agents and MCP. GuardBee puts a gateway between your agents and their tools and models that masks personal data and secrets, blocks prompt injection and toxic data flows, asks before risky calls and keeps a tamper-evident audit log, plus scanners that check your code and configs against the OWASP MCP Top 10. Open source (MIT), runs on your machine, no account needed.
The gateway and every server speak MCP 2026-07-28 and 2025-11-25 (MCP TypeScript SDK v2), so they work with clients and servers on either revision.
# Put your existing MCP servers behind the gateway (backs up your client config first)
npx -y @guardbee/mcp-security-proxy@^1 init --client claude-desktop # or cursor, claude-code
# Check a codebase against the OWASP MCP Top 10
npx -y @guardbee/mcp-owasp-scan scan . --fail-on=high
Run it yourself: examples/demo (npm install && npm start).
Install anywhere: npm, a signed multi-arch container image (ghcr.io/guardbee/mcp-security-proxy), a Helm chart, coding-agent hooks (Claude Code, Cursor, Codex, Gemini CLI, Windsurf), a GitHub Action and IDEs: see INSTALL.md.
Which package should I use?
You want to… | Install | How |
Protect agents at runtime: mask personal data, block injection and toxic flows, approve risky calls, keep an audit log | Put it in front of your MCP servers ( | |
Check a codebase against the OWASP MCP Top 10 in one pass, in CI |
| |
Give an agent many GuardBee checks from one MCP server |
| |
Find leaked keys in files, git history or agent transcripts |
| |
Audit the MCP servers configured on developer machines |
| |
Let an agent query a database without seeing raw personal data | Point it at your database with a policy | |
Use the detectors in your own code |
|
Every other package is a single check (one OWASP risk, one protocol, one file type); each is in security-suite too. npx @guardbee/security-suite list shows them with what they check.
Related MCP server: MCP Agent Firewall
Benchmarks
Detection is measured, not claimed: packages/pii-bench is a reproducible benchmark for Turkish and international personal data, with bootstrap 95% intervals and the datasets in the repo.
Benchmark | Result |
Identifiers (TC Kimlik, IBAN, card, phone, e-mail, …), 400 documents + 160 clean | F1 97.1, recall 100%, false alarms on clean documents 8.1%, 0.04 ms per document |
Person names with the optional NER model, same set | F1 99.5 |
Hand-written hard cases for names (tr-names-challenge) | F1 97.1, 0 false alarms |
KVKK Art. 6 special categories with NER (tr-special-challenge) | F1 97.5, 0 false alarms |
Bypass suite: 5 identifiers × 16 disguises (base64, hex, URL/HTML/ | 80 / 80 masked, 0 of 16 look-alike strings changed |
The identifier detectors were tuned after reading this set's misses, so the challenge sets are the fairer measure; the pii-bench README lists the limits. Any other detector can be run on the same data through its System interface.
MCP attacks: packages/mcp-bench is a public dataset (CC BY 4.0) of poisoned and benign tool definitions, injected and benign tool results, toxic and safe tool catalogs, and rug-pull sequences, in English and Turkish. Third-party baselines run on the same data, and CI fails if GuardBee's scores drop. The leaderboard covers the held-out split:
Task (test split) | GuardBee rules | GuardBee + local judge | mcp-guardian 2.4.0 | Cisco MCP Scanner YARA 4.8.7 |
Tool poisoning, F1 | 0.50 | 0.75 | 0.61 | 0.42 |
Indirect injection in tool results, F1 | 0.47 | 0.83 | 0.59 | 0.27 |
Toxic flows (lethal trifecta), F1 | 0.91 | — | — | — |
Rug pulls (drift + content checks), F1 | 0.89 | — | — | — |
GuardBee's rules alone trail mcp-guardian on tool poisoning: no Turkish patterns yet, and narrower phrasing. The README has the per-class numbers, the settings and the limitations.
Prompt injection and jailbreaks, Turkish + English: packages/injection-bench has 2,394 samples: Turkish 576 attacks / 569 benign, English 653 / 596. They come from public datasets (Gandalf, deepset, jackhhao, OpenAssistant) and from hand-written Turkish cases, and the provenance is documented. The leaderboard covers the held-out split:
F1 (test split) | Turkish | English |
GuardBee rules (what the proxy blocks) | 28.6 (0% false positives) | 20.4 (0%) |
GuardBee rules + local LLM judge (qwen2.5:7b, ~1 s) | 89.6 | 90.8 |
ProtectAI DeBERTa-v3 prompt-injection v2 | 70.2 | 89.1 |
GuardBee rules + local classifier ( | 93.7 | 91.6 |
The rules are precise but catch only 11–19% of attacks. GuardBee's optional classifier closes most of that gap in both languages. The English-trained ProtectAI model loses 19 F1 points in Turkish. The README explains both.
Examples
Ready-to-copy proxy policies (minimal, KVKK, coding agent, LLM gateway), client configs for Claude Desktop, Claude Code, Cursor and VS Code, and CI templates for GitHub Actions and GitLab: examples/.
Packages
Package | npm | Description |
| Scans a codebase for insecure LLM/AI integration patterns (client-exposed keys, unsafe output handling, excessive agency, PII→prompt, prompt injection) | |
| KVKK/GDPR/CCPA compliance checks | |
| CVE scanning for npm/pip/cargo dependencies (OSV) | |
| DNS record enumeration, misconfiguration and dangling-subdomain detection | |
| KVKK/GDPR-compliant gateway between an LLM and a database (PII masking, RBAC, rate limiting, queryable audit log; Prisma/Postgres/MySQL/SQLite/MongoDB adapters; optional insert/update/delete support) | |
| Scans other MCP servers' tool definitions for insecure patterns (excessive agency, shell/eval/SQL/SSRF sinks, loose schemas, hardcoded secrets, wildcard CORS) | |
| Scans RAG content/scraped pages for indirect prompt injection (instruction override, spoofed role/chat-template tokens, hidden text, "Dear AI" direct address, data-exfiltration instructions) | |
| Actively red-teams a live LLM endpoint/chatbot with canary-based jailbreak/extraction/obfuscation probes (OpenAI/Anthropic/webhook targets) | |
| Scans ML model files (PyTorch, pickle, safetensors, Keras/H5, ONNX) for supply-chain risks — dangerous pickle deserialization globals, disguised/malformed safetensors headers, Keras Lambda-layer RCE, ONNX external-data path traversal | |
| The defensive side of reverse-engineering MCPs: audits a shipped web build or live site, Electron app, Android APK/AAB, iOS IPA, Unity/PyInstaller/Java build or native/.NET binary for what an analyst gets for free — exposed source maps, missing minification/R8/.NET obfuscation, debug info and symbols, debuggable flags, Electron fuses, missing code signing, embedded keys; A–F grade, build-config fix diffs and CI baselines | |
| Probes vector-database endpoints (Weaviate, Qdrant, Chroma, Elasticsearch/OpenSearch, Redis, Postgres/pgvector) for unauthenticated exposure of embeddings and RAG data | |
| Catches leaked credentials and PII (API keys, TC Kimlik No, credit cards, IBANs) in outbound LLM prompts — as MCP scan tools, and as a live reverse proxy in front of a real LLM API | |
| Finds PII and credentials inside PDFs, screenshots and scanned documents — PDF text layer plus optional OCR (Turkish and English) — before they reach an LLM | |
| Builds a reachability graph across multi-agent orchestration configs (LangGraph, CrewAI, AutoGen/ag2) to find transitive excessive agency — an agent that reaches a dangerous tool only through delegation to another agent | |
| Scans MCP server tool definitions for tool poisoning (hidden instructions embedded in a tool's description) and confused-deputy mismatches (a read-only-sounding tool whose handler has a shell/eval/file-write/env-dump sink) | |
| Connects live to another MCP server (stdio/HTTP), baselines its tools/list response, and detects an "MCP rug pull" — a tool's description/schema/annotations silently changing after it was already approved | |
| Scans agent code for memory poisoning — untrusted input written into persistent, cross-session memory (MemGPT-style archival/core memory, or a long-term vector store) that later gets recalled and trusted as context | |
| Scans an MCP server's own authorization code for OAuth 2.1 anti-patterns named in the MCP spec's Security Considerations — token passthrough, missing audience validation, OAuth/OIDC discovery SSRF, missing PKCE, loose redirect_uri validation, hardcoded client secrets | |
| Scans MCP server code for elicitation anti-patterns in the 2026-07-28 spec — form mode asking for secrets or payment data, URL mode pointed straight at a third-party authorize endpoint, credentials or PII embedded in the elicitation URL | |
| Audits an MCP tool catalog for toxic flows (Simon Willison's lethal trifecta) — untrusted content + sensitive/private data + exfiltration or destruction on the same server; A–F grade, KVKK-aware heuristics, OWASP MCP10:2025 | |
| Audits MCP server source for OWASP MCP08:2025 (Lack of Audit and Telemetry) — missing tool-call trails, raw args/results in logs, hard-disabled audit, silent catches, audit events without correlation ids | |
| Audits agent/MCP source for OWASP MCP10:2025 context oversharing — full conversation dumps, unscoped memory tools, shared global session stores, system-prompt leaks via tools, cross-session tool-result bleed, unfiltered vector queries (complements toxic-flow’s catalog trifecta) | |
| Unified OWASP MCP Top 10 meta-scanner — path orchestration of GuardBee auditors + live/catalog | |
| Audits MCP client configs (Cursor/Claude/Windsurf/VS Code) and agent | |
| MCP bridge to Agent Threat Rules (ATR) — runtime detection for prompt injection, tool poisoning, and MCP attacks, with GuardBee follow-up scanner hints | |
| Scans an agent's Agent2Agent (A2A) protocol implementation (TypeScript and Python) for anti-patterns found in the reference SDKs' own source — unauthenticated push-notification webhook fetches (SSRF), Agent Cards with no authentication requirement, credentials embedded in publicly-served Agent Card metadata | |
| Checks every dependency declared in a project's own manifest (package.json, requirements.txt, pyproject.toml) against the real npm/PyPI registry — flags names that don't exist at all (likely LLM-hallucinated, i.e. slopsquatting) and names that exist but were only very recently published | |
| Scans LLM/agent application code for Unbounded Consumption ("denial of wallet", OWASP LLM Top 10 2026 #6) — missing output token limits, missing timeouts on hand-rolled LLM HTTP calls, unbounded agent tool-calling/retry loops, explicitly disabled framework safety limits (LangChain max_iterations, openai-agents max_turns), and MCP tool handlers with no visible rate limiting | |
| Scans files for leaked secrets and API keys | |
| MCP security gateway: several MCP servers behind one policy, with toxic-flow (lethal trifecta) blocking, approvals, PII masking and a hash-chained audit log | |
| Every scanner and auditor below from one install: one MCP server with the groups you pick, and a CLI that runs any package | |
| TLS certificate/cipher/protocol inspection | |
| Triggers GuardBee scans, queries findings, AI-assisted remediation guidance | |
| (internal) Shared detector library — PII/secret masking, prompt injection rules, tool classification; not an MCP server on its own | |
| (internal) Shared usage-telemetry client — not an MCP server on its own |
Security
Found a vulnerability? Report it privately: see SECURITY.md. Contributions are welcome: CONTRIBUTING.md.
Telemetry
Packages can send usage telemetry to GuardBee via @guardbee/mcp-telemetry: which tool is called, how often, and how long it takes. It is off by default (opt-in); nothing is sent unless you set GUARDBEE_TELEMETRY=1. When it is on, a one-time notice is printed to stderr on first use.
To enable:
GUARDBEE_TELEMETRY=1(ortrue/on/yes); unset it to turn telemetry off againWhat's sent: tool name, short (≤40 character) parameter values (e.g.
table: "users",limit: 50), success/failure, durationWhat's NEVER sent: values under keys like
content/text/data/filter/password/email/apiKey/token, and any string longer than 40 characters — all replaced with"[redacted: ...]"byredactParams()inpackages/telemetry/src/redact.ts. So the full content of scanned files/code, or the real row data from aninsert_row/update_rowcall, is never sent.
Details: packages/telemetry/README.md.
Development
pnpm install
pnpm build # turbo run build — all packages, in dependency order
pnpm test # turbo run testTo work on a single package:
pnpm --filter @guardbee/mcp-ssl-inspector devVersioning and publishing
Packages are versioned independently (Changesets). If you changed something in a PR:
pnpm changesetAfter merging to main, CI automatically opens a version PR; merging that PR publishes the changed packages to npm (see .github/workflows/release.yml).
Stability
Packages at 1.0 or later follow semantic versioning: a breaking change to the CLI, the MCP tool names and parameters, the config format or the exported API comes only with a new major version, and is listed in the package's CHANGELOG.md. New rules and detectors arrive in minor versions; they can report findings an earlier version did not. Packages still at 0.x may change between minor versions.
Package | Stable since |
| 1.0 |
| 1.0 |
| 1.0 |
| 1.0 |
| 1.0 |
| 1.0 |
Structure
pnpm workspaces —
packages/*, realworkspace:*dependencies (e.g.security-suitedepends on the other packages directly from the workspace, not a registry version)Turborepo —
build/test/type-checkpipeline, dependency-graph-aware ordering and cachingShared config —
tsconfig.base.jsonandvitest.shared.tsat the root; each package layers its own settings on top
Project history
The monorepo's earlier write-ups are in CHANGELOG.md; each package's release notes are in its own CHANGELOG.md and on GitHub Releases.
Available Tools
130 toolsa2a_auditor__list_patternsB
List every A2A (Agent2Agent) protocol pattern this auditor detects, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the safety burden, but 'list' strongly implies a read-only operation. It adds one real behavioral fact beyond the name: results are grouped by category. It does not state that no scanning occurs or whether patterns can be enabled/disabled.
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 padding. Slightly self-referential ('this auditor detects') where 'detects' alone would carry the same 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 no annotations, so the description is the only source of return-value information. Saying results are grouped by category is helpful, but it never indicates what a pattern entry contains (identifier, severity, description) or roughly how many to expect, leaving the agent guessing at the response shape.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for zero-param tools 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 and resource (list every A2A protocol pattern this auditor detects) and expands the acronym, which distinguishes it from the many other *_list_patterns siblings by domain. It stops short of naming the specific scan_text/scan_file siblings it complements.
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 and no reference to the alternatives. An agent must infer that this is a discovery/introspection call to run before or after a2a_auditor__scan_text/scan_file, rather than being told so.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
a2a_auditor__scan_directoryC
Recursively scan a directory of A2A agent source for protocol anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Recursively scan' implies a read-only walk, but it never confirms non-destructiveness, whether results are aggregated per file, how large trees are handled (maxFiles is only visible in the schema), or what the scan actually reports.
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 eleven-word sentence with no filler and the core action front-loaded. It is efficient, though its brevity contributes to the gaps in usage and behavioral 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?
Inputs are fully specified by the schema and the purpose is unambiguous, so the definition is minimally viable. However, with no annotations and no output schema, the agent gets no signal about what a scan returns (findings list, severities, file locations) or how expensive a recursive scan may be.
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 path, exclude, include, and maxFiles are all documented in the schema itself. The description adds only the notion of recursion, which loosely relates to maxFiles/exclude behavior but gives no extra syntax or default detail. 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+target: 'recursively scan a directory of A2A agent source for protocol anti-patterns'. The word 'directory' implicitly separates it from a2a_auditor__scan_file and a2a_auditor__scan_text, though it never names them. Clear enough for an agent to know what it does, but sibling differentiation is left to 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?
No guidance on when to choose this over a2a_auditor__scan_file, a2a_auditor__scan_text, or a2a_auditor__list_patterns, and no prerequisites (e.g. whether the directory must contain agent manifests). Only the word 'directory' hints at the applicable scope.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
a2a_auditor__scan_fileB
Scan a single file for A2A (Agent2Agent) protocol anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
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 says nothing about whether the scan is read-only, what 'anti-patterns' it detects, what the output looks like, or any permissions/limits — for a scanner with zero annotation coverage this is a substantial gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single compact sentence with the core action and scope front-loaded. Efficient, though it is perhaps too terse to be maximally informative.
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 one-param scan with no output schema, the essentials are covered by schema and description. However, an agent can't tell what patterns are detected, what findings look like, or how it differs from the sibling list_patterns tool — some gaps remain.
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?
Only one parameter, and the schema fully documents it (100% coverage, 'Absolute or relative path to the file to scan'). The description reinforces that it operates on a single file, which aligns with the schema; no further param detail is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Scan') and resource ('a single file') scoped to A2A protocol anti-patterns. The 'single file' phrasing implicitly distinguishes it from scan_text and scan_directory siblings, though it doesn't name them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: 'single file' suggests the alternative is a directory or text variant, and siblings scan_text/scan_directory/scan_file exist. But the description names no alternative or when-to-use condition explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
a2a_auditor__scan_textA
Scan Agent2Agent (A2A) protocol implementation code for anti-patterns found in the reference SDKs and sample agents: an Agent Card fetching a client-supplied push-notification webhook URL with no host allowlist (SSRF), a request handler wired up with no authentication at all, and a literal credential embedded directly in Agent Card metadata (which is served publicly).
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the disclosure burden. It names the exact anti-pattern classes checked, including SSRF via client-supplied webhook URLs, missing authentication, and literal credentials in public Agent Card metadata. It does not describe return format or whether scanning is purely local/read-only, but the operation is clearly an analysis scan.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no wasted clauses. Every part, including the named anti-patterns and the note that Agent Card metadata is public, supports the scan's purpose.
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 two-parameter text scanner with full schema coverage, the description provides enough context to understand what to submit and what will be checked. It lacks explicit information about the shape of findings, but no output schema exists and the tool's scope is otherwise clear.
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 both parameters are documented in the schema itself. The description does not add meaning beyond the schema for content or label, so the baseline score 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 specific verb and resource: scan A2A protocol implementation code. It also enumerates three concrete anti-patterns, making the tool's focus clear. It does not explicitly distinguish scan_text from sibling a2a_auditor__scan_file or scan_directory, so it is clear but not fully differentiated.
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 use on A2A implementation code when checking for specific security anti-patterns. However, it does not explicitly say when to use this versus scanning a file, directory, or listing patterns. No exclusions 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.
agent_graph_auditor__list_patternsA
List every dangerous-capability rule this auditor looks for at the end of a delegation path, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses one behavioral trait beyond the name: results are 'grouped by category', which hints at return structure. It does not state that this is a non-mutating read with no inputs, nor anything about result size or pagination, for a 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?
A single sentence that front-loads the verb and the scope, with zero padding. Every clause ('dangerous-capability', 'end of a delegation path', 'grouped by category') adds distinct 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?
With no output schema and no annotations, the description covers what is listed, the domain it applies to, and the grouping of results — enough for an agent to call it correctly. Minor gaps remain around whether the listing is static/read-only and roughly how large the response is, given 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?
The tool takes zero parameters, so there is nothing for the description to document; the baseline for a no-arg tool is 4. Nothing in the description misrepresents or adds confusion about inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb 'List' plus a well-scoped resource: the dangerous-capability rules this specific auditor (agent graph / delegation path) checks. The phrase 'at the end of a delegation path' uniquely anchors it to the agent-graph auditor, distinguishing it from the many generic list_patterns siblings. It stops short of naming a specific sibling tool to contrast with.
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 — an agent would call this to learn what the auditor detects before or after scanning — but there is no explicit 'use this when' statement, no mention of pairing with agent_graph_auditor__scan_text/scan_file/scan_directory, and no exclusions. Adequate but leaves the workflow to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
agent_graph_auditor__scan_directoryA
Recursively scan a directory of Python files and report excessive-agency paths found in each. Each file's agent/tool graph is analyzed independently — variable references don't resolve across files, so a Crew/GroupChat whose members are defined in a different file than the assembling call won't be connected.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 2000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the burden — and it delivers a genuinely non-obvious behavioral trait: variable references do not resolve across files, so Crew/GroupChat members defined elsewhere will not be linked. That prevents misinterpretation of results. It omits safety profile (read-only) and any cost/limit context beyond the schema default.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with zero filler; the scanning scope is front-loaded and the caveat follows immediately.
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, but the description indicates the return is per-file excessive-agency paths and warns about the main analysis limitation. It leaves the exact finding shape and behavior on very large trees (beyond maxFiles) unstated — a minor gap, not a blocking one.
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 path, exclude, include, and maxFiles are already fully documented. The description adds no syntax, format, or interaction detail for these parameters, 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 (recursively scan) and resource (a directory of Python files) plus the output (excessive-agency paths per file). It does not explicitly name scan_file/scan_text as the narrower alternatives, so sibling differentiation is only implied by the word 'directory'.
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 operating context: use this when you want whole-tree coverage, and expect per-file isolation rather than cross-file resolution. It stops short of explicit 'use X instead' routing or exclusions, so it is good context without 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.
agent_graph_auditor__scan_fileA
Scan a single Python file for excessive-agency paths across LangGraph/CrewAI/AutoGen orchestration constructs
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the .py file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It usefully discloses the analysis domain (orchestration constructs in three agent frameworks), but says nothing about whether the file is only read, what happens on a non-Python or missing file, or what kind of result is returned. For a low-risk read-only scanner this is acceptable but thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the scope ('single Python file') and the target findings come before the framework qualifier.
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 scanner with a fully documented schema and no output schema, the description covers what is scanned and what is looked for. The only meaningful gap is how findings are shaped and how this differs operationally from the text/directory variants.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is one parameter with 100% schema description coverage ('Absolute or relative path to the .py file to scan'), so the schema fully documents it. The description adds no additional constraint such as extension enforcement or size limits, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (scan), a specific resource (a single Python file), and the exact class of findings (excessive-agency paths) scoped to named frameworks (LangGraph/CrewAI/AutoGen). The 'single file' framing implicitly separates it from the sibling scan_text, scan_directory, and list_patterns 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 'single Python file' scope implies when to pick this over agent_graph_auditor__scan_text or scan_directory, but no alternative is named and no preconditions (file must exist, must be Python, encoding) are stated. Usage is inferable but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
agent_graph_auditor__scan_textA
Scan a Python snippet defining a multi-agent orchestration (LangGraph, CrewAI, or AutoGen/ag2) for excessive agency reachable through delegation or group membership — an agent with no dangerous tool of its own that can still reach one (shell/code-exec/file-write/network/credentials) through another agent it can hand off to.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The Python source to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full behavioral burden. It does add real value by enumerating the dangerous tool classes it traces (shell/code-exec/file-write/network/credentials) and the delegation/group-membership propagation path. However, it says nothing about whether the scan is read-only, how findings are shaped or severity-ranked, or any limits on snippet size or supported syntax versions.
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 starting with the verb and resource, followed by the clarifying em-dash gloss on what 'excessive agency' means. The parenthetical framework list and tool-class enumeration earn their space, though the sentence is long and could be split for scanning.
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 scanner with no output schema and no annotations, the description should say what comes back (findings list, severity, agent-to-agent paths). It describes the detection target well but leaves the result shape entirely unknown, which is a meaningful gap for a tool whose whole value is its findings.
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% with only two parameters (content and an optional label), both documented in the schema, so the schema already handles parameter semantics. The description adds no constraints on content (size, encoding, partial snippets) and does not mention the label parameter's effect on findings, 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?
Names a specific verb (Scan), a specific resource (a Python snippet defining a multi-agent orchestration), the frameworks it understands (LangGraph, CrewAI, AutoGen/ag2), and the exact defect class (excessive agency reachable through delegation). This is distinguishable from the sibling scan_file and scan_directory tools by the 'snippet' framing.
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 by 'Scan a Python snippet', which suggests in-memory text rather than a path. The description never explicitly routes the agent to agent_graph_auditor__scan_file for paths or scan_directory for trees, nor does it mention list_patterns for inspecting rule coverage. An agent must infer the alternative from the sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ai_code_scanner__list_patternsB
List all AI/LLM security patterns that the scanner can detect, grouped by category (including any custom rules loaded from .guardbee/rules)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden; it does signal the operation is a safe read-only listing and adds useful context that custom rules from `.guardbee/rules` are merged in. It does not state the return shape beyond 'grouped by category', whether counts/IDs are included, or what happens when no custom rules directory exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with the resource, scope, and grouping behavior; nothing redundant or padded.
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 does the work of indicating what comes back (categories with patterns, plus custom rules). That is adequate for a zero-parameter lister, though a hint about entry fields or whether categories are fixed would make it fully self-contained.
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 the baseline is 4. The schema is trivially complete and the description adds the only meaningful semantic note — that output includes custom rules loaded from `.guardbee/rules`.
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 ('List all AI/LLM security patterns that the scanner can detect'), which is clearer than a bare 'list patterns'. However, it offers no differentiation from the many sibling `*__list_patterns` tools (prompt_injection_scanner, mcp_server_auditor, memory_poisoning_scanner, etc.), so an agent choosing among them has to infer that this one covers AI/LLM code patterns.
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, no prerequisites, and no mention of alternatives. With over a dozen competing `list_patterns` siblings, the description gives the agent nothing to route on beyond the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ai_code_scanner__scan_directoryA
Recursively scan a directory for insecure AI/LLM integration patterns. Automatically skips node_modules, .git, dist, and binary files.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings (e.g. [".ts", "src/agents"]) | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
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 auto-skipped directories and binary files, which an agent could not infer otherwise, but says nothing about read-only safety, traversal limits, or whether it follows symlinks. The maxFiles cap is only in the schema, not the prose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the core action and the notable skip behavior front-loaded. No filler or restated name.
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 scanner with no annotations and no output schema, an agent still does not know what a result looks like (findings, severities, file/line references) or how large directories behave. The behavioral basics are covered, but return-value expectations and limits are left implicit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters (path, exclude, include, maxFiles) are already documented with examples and defaults. The description adds nothing about the interplay between exclude/include or the default 5000-file cap, 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 ('Recursively scan') and resource ('a directory') plus the target domain ('insecure AI/LLM integration patterns'). However, it does not distinguish this tool from the many sibling scan_directory tools (a2a_auditor, elicitation_auditor, tool_poisoning_scanner, etc.) that appear to operate identically on different pattern sets.
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 name and by the 'directory' scope, which implies scan_file/scan_text siblings are for narrower inputs, but the description never states when to choose this over them. No exclusions, prerequisites, or alternative-selection guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ai_code_scanner__scan_fileB
Scan a single file for insecure AI/LLM integration patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It doesn't state that this is a read-only operation, what the scan returns (findings, severities, pattern matches), or whether results are structured; 'scan' is the only hint of behavior, which is thin for a security scanner.
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 efficient sentence that front-loads the verb and resource with no filler. It is tight, though its brevity pairs with the completeness gap.
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 mean the description should describe what a scan produces and how to interpret it, but it does none of that. For a scanner tool it leaves the return behavior and result semantics entirely unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is only one parameter (path) and schema coverage is 100%, so the schema already fully documents it including absolute vs relative semantics. The description adds no further meaning, matching the baseline-3 case for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Scan') and a scoped resource ('a single file'), plus a clear subject domain ('insecure AI/LLM integration patterns'). The 'single file' wording implicitly separates it from scan_directory and scan_text siblings, though it doesn't name them outright.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use guidance, no mention of prerequisites, and no routing to siblings like ai_code_scanner__scan_text or scan_directory. Usage is only implied by 'single file'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ai_code_scanner__scan_textA
Scan a text string or code snippet for insecure AI/LLM integration patterns (client-exposed keys, unsafe output handling, excessive agent tool permissions, PII sent to a model, prompt injection surface).
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It discloses the categories of insecure patterns it looks for, which is valuable, but never states that the operation is read-only, whether it makes external calls, stores content, or what kind of response it returns. For a scanner with zero annotation coverage, these omissions are notable but not fatal because scanning is conventionally non-mutating.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with a parenthetical list of detectable issues; every clause conveys concrete information and there is 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?
With no output schema and no annotations, the description should ideally hint at what a scan returns (findings format, severity, counts). It identifies the detection categories but gives no sense of the response shape or how findings are presented, leaving a gap for an agent trying to interpret results.
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 are already documented in the schema. The description's mention of 'text string or code snippet' reinforces the content parameter but adds no syntax, format, or usage details for the optional label parameter beyond what the schema states.
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 (Scan) and resource (text string or code snippet) and enumerates the exact pattern categories it detects, which helps distinguish it from generic scanners. Sibling differentiation is implicit through the 'AI/LLM integration patterns' scope, but it doesn't name overlapping alternatives like prompt_injection_scanner__scan_text or secret_scanner__scan_text.
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 'text string or code snippet' implies this is for inline content rather than files or directories, which is a useful contextual cue. However, there is no explicit guidance on when to prefer this over sibling scanners (such as scan_file for persisted code or prompt_injection_scanner__scan_text for injection-only checks).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
audit_gap_auditor__list_patternsA
List every OWASP MCP08 audit-gap check this auditor runs
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description must carry the behavioral burden. The verb 'list' and 'every ... this auditor runs' make clear it is a complete, read-only enumeration with no side effects. However, it says nothing about the shape of the returned catalog (identifiers, names, severities) or whether the list can be filtered, which matters with no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the whole purpose is conveyed in under ten 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?
For a zero-param tool this is close to sufficient, but with no output schema and no annotations the agent does not learn what a returned entry contains or how to reference a check in a subsequent scan call. One more clause on the return contents would close the remaining gap.
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 the baseline of 4 applies. The description correctly signals an unfiltered, take-no-arguments listing.
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 'List' plus a concrete resource: the OWASP MCP08 audit-gap checks this auditor runs. It is clearly distinguished from its own scan_text/scan_file/scan_directory siblings by being the enumeration call. It stops short of naming any sibling explicitly, so it stays at 4.
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: the zero-parameter, 'list every check' framing suggests it is a discovery step before running a scan. There is no statement of when to prefer it over scan_file/scan_text, and no prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
audit_gap_auditor__scan_directoryA
Recursively scan a directory of MCP server source for OWASP MCP08 audit/telemetry gaps
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry behavioral context. It discloses recursive traversal and the audit target, which is useful, but does not explicitly state that the scan is read-only, whether it modifies anything, or what constraints apply beyond the schema-level maxFiles option.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler. It states the traversal mode, target resource, and audit category efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a four-parameter scanner with complete schema descriptions, the definition is adequate to invoke the tool correctly. However, it lacks usage alternatives and any sense of output or behavioral constraints, leaving it minimally 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 path, exclude, include, and maxFiles are already fully documented in the schema. The description adds no parameter-specific meaning beyond that baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb and resource: 'Recursively scan a directory of MCP server source', and names the target issue category 'OWASP MCP08 audit/telemetry gaps'. It implicitly distinguishes itself from scan_file/scan_text siblings by specifying a directory scan, though it does not explicitly name those alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The directory scope implies when to use this tool rather than file- or text-level scanners, but there is no explicit guidance such as when to prefer scan_file or scan_text. Usage is inferable but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
audit_gap_auditor__scan_fileC
Scan a single file for OWASP MCP08 audit/telemetry gaps
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden. It does not say whether the scan is read-only, whether it follows symlinks or reads auxiliary files, what rules are applied, or how findings are reported — all left to inference from the tool name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short, front-loaded sentence with zero filler. It is efficient, though the terseness leaves no room for the routing or output context a scanner in this family needs.
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 annotations and no output schema mean the description should explain what an MCP08 audit/telemetry gap is and roughly what comes back. It does not, so an agent can call the tool but cannot anticipate or interpret its findings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is a single required parameter with 100% schema description coverage ("Absolute or relative path to the file to scan"), so the schema already covers it fully. The description adds no syntax, size-limit, or path-resolution detail beyond that, which is the expected baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (scan) plus resource (single file) plus the target concern (OWASP MCP08 audit/telemetry gaps). "Single file" implicitly separates it from the sibling scan_text and scan_directory variants, though it never names them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use, when-not-to-use, or prerequisite guidance. With ~130 siblings including audit_gap_auditor__scan_text and audit_gap_auditor__scan_directory, the agent must infer that this is the file-in/patterns-out entry point from the word "file" alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
audit_gap_auditor__scan_textB
Scan MCP server source for OWASP MCP08:2025 (Lack of Audit and Telemetry) gaps: tools registered with no audit trail, raw args/results logged, audit hard-disabled, silent catch blocks, audit events without a session/request id.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the behavioral burden. It helpfully discloses the checks performed (audit trail gaps, logging of raw args, silent catch, missing request ids), but says nothing about whether it is read-only, safe, what the findings format/severity looks like, or that it does not execute the source.
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 front-loads the target framework and then lists the concrete gap types. It is efficient with no filler, though the trailing colon-list makes it slightly long.
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 scanner with no annotations and no output schema, the description covers inputs conceptually but omits what a caller gets back (finding structure, severity, counts) and how results differ from the file/directory variants. Adequate but with clear gaps for the agent's decision-making.
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% – both 'label' and 'content' are documented in the schema. The description adds no parameter-level detail (e.g. that content should be raw source text, not a path), so the schema does the work and 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 concrete verb (Scan) plus resource (MCP server source) and enumerates the exact gap classes it detects for OWASP MCP08:2025, which is far more specific than the bare name. It is clearly a text/scanner tool, but it never explicitly distinguishes itself from the sibling scan_file/scan_directory variants.
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 by the tool name and the word 'source' – an agent can infer this is for arbitrary code text. There is no explicit statement of when to choose scan_text over scan_file/scan_directory, and no mention of the list_patterns sibling for enumerating the underlying rules.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compliance_checker__analyze_privacy_policyA
Fetch and analyze a privacy policy page for completeness against GDPR/KVKK requirements. Works without an API key.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Direct URL to the privacy policy page (or homepage to auto-detect) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral burden. It usefully discloses that the tool works without an API key (a real auth-related detail), but omits what happens on unreachable/non-policy pages, whether the fetch leaves a trace, or the shape of the analysis output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the action and scope front-loaded and the no-API-key constraint appended. No wasted text.
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 is a scanner/analyzer with no output schema and no annotations, so the description should hint at what 'analysis' returns (findings, score, missing sections). That gap leaves the agent guessing about output shape and error semantics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a strong url description that already covers the 'homepage to auto-detect' nuance. The description adds nothing beyond what the schema states, which is the correct baseline when the schema does the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action (fetch and analyze) against a specific resource (privacy policy page) with a specific scope (completeness against GDPR/KVKK). This distinguishes it from the more general check_compliance sibling, though it doesn't name the alternative explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (analyze a privacy policy URL for GDPR/KVKK completeness) but gives no explicit when-to-use vs when-not guidance, and doesn't mention the check_compliance/compare_frameworks siblings that a user might confuse it with.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compliance_checker__check_complianceA
Run a full compliance scan for a URL against a regulatory framework (KVKK, GDPR, or CCPA) using the GuardBee scanner. Returns a gap analysis and action plan.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Target URL to audit for compliance | |
| wait | No | Wait for scan to complete (default: true) | |
| framework | Yes | Regulatory framework: KVKK, GDPR, or CCPA |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations at all, the description carries the full disclosure burden. It does add real value by naming the scanning engine and stating the return shape ('gap analysis and action plan'), but it never addresses that this appears to be a long-running network operation (the undocumented-in-description 'wait' semantics), whether it polls or is async, or what happens if the default wait is disabled.
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, with the return value appended. Every clause earns its place; nothing is padded or repeated.
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 no annotations, so the description is the only place to learn how results come back. It mentions 'gap analysis and action plan' but not the findings structure, IDs, or how to fetch results later via the sibling findings tool — leaving a meaningful gap for a scan-then-retrieve workflow.
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 restates the url and framework enum values already fully documented in the schema and adds nothing about the 'wait' parameter's tradeoff (blocking vs. fire-and-forget), so it does not compensate beyond the schema's own text.
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 + resource + scope: run a compliance scan of a URL against one of three named regulatory frameworks, using a named engine (GuardBee). This clearly separates it from siblings like list_requirements or compare_frameworks, though it never explicitly names the downstream retrieval tool (get_compliance_findings), so the distinction is inferred rather than declared.
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: 'full compliance scan' suggests this is the entry point before retrieving findings, but the description never says when to use it versus analyze_privacy_policy or compare_frameworks, and gives no prerequisites (does the URL need to be publicly reachable?).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compliance_checker__compare_frameworksB
Compare KVKK, GDPR, and CCPA requirements side by side to understand overlaps and gaps
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden. It does implicitly reveal that the framework set is fixed to KVKK/GDPR/CCPA (no parameters exist to choose frameworks), but says nothing about whether this is a pure read, what the comparison output looks like, or how large a result to expect.
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, no filler, with the resource list and the payoff ('overlaps and gaps') both front-loaded. Nothing to trim.
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 tool with no annotations and no output schema, the description covers what is compared but not the shape of the result (matrix, per-framework findings, gap list). An agent knows what it will get conceptually but not what it will have to parse.
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 the baseline is 4. The description usefully clarifies that the compared frameworks are a fixed trio rather than selectable, which is the only semantic point available for a no-arg tool.
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 (compare) plus the exact resources (KVKK, GDPR, CCPA requirements) and the intended output (overlaps and gaps). It is clearly not a scan/check tool like check_compliance or list_requirements, though it never explicitly names those siblings to sharpen the boundary.
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 trailing clause 'to understand overlaps and gaps' implies the use case, but there is no explicit when-to-use, when-not-to-use, or named alternative among check_compliance, list_requirements, or get_compliance_findings. The agent must infer routing from the verb alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compliance_checker__get_compliance_findingsA
Get compliance findings from a completed GuardBee scan, optionally filtered by severity
| Name | Required | Description | Default |
|---|---|---|---|
| scanId | Yes | Scan ID returned by check_compliance | |
| severity | No | Filter by severity | |
| framework | No | Framework label for the report header |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It implies a read-only retrieval from a completed scan but does not describe return format, pagination, permissions, or rate limits; this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no wasted words. It presents the source and optional filter efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple three-parameter retrieval tool with complete schema descriptions, the definition covers the key prerequisite and filter. It lacks return-value context, but no output schema exists and the core invocation information is present.
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 schema explains scanId, severity, and framework. The description only reinforces the optional severity filter, so it adds little beyond the already rich 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 ('Get') and resource ('compliance findings') with its source ('completed GuardBee scan') and an optional severity filter. This clearly distinguishes it from the sibling check_compliance tool, which initiates a scan, because it requires a completed scan and scanId.
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 makes the prerequisite clear: the scan must be completed, and the schema notes scanId comes from check_compliance. It does not explicitly name alternatives or when not to use it, but the usage context is sufficiently clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compliance_checker__list_requirementsB
List all compliance requirements for a framework with legal basis references
| Name | Required | Description | Default |
|---|---|---|---|
| severity | No | Filter by severity | |
| framework | Yes | Framework: KVKK, GDPR, or CCPA |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the disclosure burden. "List all ... for a framework" plus "with legal basis references" conveys that this is a non-mutating enumeration returning requirement entries annotated with legal citations, which is genuinely useful. It stops short of stating whether the result set is a fixed catalog, whether it is paginated, or whether it can be empty for an unsupported framework.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the resource and scope appear first. The trailing "with legal basis references" is slightly ambiguous about whether it describes returned content or a capability, which keeps it from a 5.
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 two-parameter read tool with a fully documented schema and no output schema, the description is close to adequate. Since no output schema exists, though, it should say more about the shape of a returned requirement (identifier, title, legal basis, severity) rather than just hinting at legal references.
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 both parameters carry enum documentation, so the schema already fully specifies framework and severity. The description adds only that the framework scopes the result set and that "all" requirements are returned, implicitly framing severity as an optional narrowing filter. That is baseline value, not extra.
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 ("List all compliance requirements") scoped to a framework, which is unambiguous on its own. It does not, however, distinguish itself from siblings like compliance_checker__check_compliance, get_compliance_findings, or compare_frameworks, so an agent must infer that this is the static catalog lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use statement, no exclusions, and no named alternative. The word "List" implies a read-only enumeration versus the sibling check_compliance (an assessment run), but that contrast is never stated and must be inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
context_oversharing_auditor__list_patternsA
List every OWASP MCP10 context-oversharing check this auditor runs
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 that this is a pure enumeration of the checks the auditor runs (a safe, read-only listing), but says nothing about the shape of each returned entry, whether the list is static, or how the patterns map to the scan tools.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler. The scope qualifier ('this auditor') is placed where it matters, and 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?
For a zero-parameter listing tool with no output schema, the agent still has to guess what each returned pattern looks like (IDs, descriptions, severity, categories) and how to feed a chosen pattern into the scan_* tools. The description is adequate but does not close that loop.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly spends no words on non-existent inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('List') and a specific resource ('every OWASP MCP10 context-oversharing check this auditor runs'), which clearly separates it from the scan_text/scan_file siblings that perform scanning. It stops short of naming those siblings explicitly, but the name-plus-description pairing leaves little ambiguity.
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 a discovery call to enumerate available checks before or instead of scanning. There is no explicit when-to-use, no statement of when not to use it, and no pointer to the scan_* siblings as the alternative once a pattern is chosen.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
context_oversharing_auditor__scan_directoryA
Recursively scan a directory for OWASP MCP10 context-oversharing issues
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Scan' implies a read-only operation, but the description doesn't confirm read-only behavior, symlink following, permission needs, or whether the operation is costly at scale — only the schema's maxFiles default of 5000 hints at scale control.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with zero filler. The purpose and scope are communicated immediately with nothing 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 four-parameter tool with no annotations and no output schema, the description covers purpose but not what the scan returns (findings shape, severity, counts) or any behavioral caveats. It's adequate to invoke but thin on expectations setting.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters (path, exclude, include, maxFiles) are already documented in the schema. The description adds no meaning beyond the schema, 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 ('recursively scan'), resource ('a directory'), and target domain ('OWASP MCP10 context-oversharing issues'). The directory-vs-file scope implicitly distinguishes it from sibling scan_text/scan_file tools, but no sibling is named explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by 'recursively scan a directory', which makes clear this is for tree-wide sweeps vs. single-file scans. However, there is no explicit when-to-use guidance, no exclusions, and no reference to a specific alternative such as context_oversharing_auditor__scan_file.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
context_oversharing_auditor__scan_fileB
Scan a single file for OWASP MCP10 context-oversharing issues
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral-disclosure burden. It indicates a scan of a file for a specific issue class, but does not state that the operation is read-only, what the scan checks, whether files are modified, or what the result looks 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?
The definition is a single front-loaded sentence with no filler. Every word contributes to identifying the scan target and issue domain.
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 one-parameter file-scanning tool, the description is sufficient to invoke it correctly. However, with no output schema and no explanation of returned findings or what constitutes an oversharing issue, it leaves some contextual gaps.
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 fully documents the single path parameter, including that it can be absolute or relative. The description adds no further parameter meaning beyond what the schema already provides, 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?
The description uses a specific verb ("Scan") and resource ("single file") and scopes it to OWASP MCP10 context-oversharing issues. It implicitly distinguishes itself from scan_text and scan_directory siblings by specifying a single file, though it does not name those alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase "single file" implies when to use this tool rather than the text or directory variants. However, it provides no explicit when-to-use guidance, prerequisites, or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
context_oversharing_auditor__scan_textB
Scan agent/MCP source for OWASP MCP10:2025 context oversharing — full conversation dumps, unscoped memory tools, shared global session stores, system-prompt leaks via tools, cross-session tool-result bleed, and unfiltered vector queries.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It usefully discloses the detection scope (what categories of oversharing it finds), but does not state that it is read-only/non-mutating, nor what the findings output looks like or whether severity/line info 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?
A single front-loaded sentence with no filler; the long enumeration of pattern categories earns its place by precisely scoping detection. Slightly dense but 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?
There is no output schema and no annotations, so the description should ideally explain the return/findings structure to fully guide an agent. It covers the 'what' well but leaves the result shape and read-only safety profile 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 description coverage is 100%, so both params are already documented in the schema. The description adds no syntax, format, or content-type detail beyond what the schema provides, so the 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?
States a specific verb (Scan) and resource (agent/MCP source) plus the exact rule category (OWASP MCP10:2025 context oversharing), enumerated with concrete pattern types. This clearly separates it from unrelated scanners, though it does not explicitly name scan_file/scan_directory siblings as the file-based alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the 'scan_text' name plus the required 'content' string param suggest it is for in-memory text rather than a file path. There is no explicit statement of when to prefer this over scan_file/scan_directory or list_patterns.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
db_gateway__describe_tableB
Get the column names and gateway masking policy for a table — helps the LLM understand what data it can access.
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table name |
TDQS
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 usefully discloses that the response includes a masking policy (i.e., data may be redacted), which is real behavioral context, but it says nothing about permissions, behavior on a non-existent table, or result shape.
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 the return content stated first. The trailing 'helps the LLM…' clause is mildly promotional but does add rationale, so nothing is seriously 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 read tool with no output schema the bar is low, and the description does state what comes back. However, it omits what an agent most needs to act on that information — e.g., that masking policy governs whether query_table results are redacted, and what happens if the table is unknown.
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 there is a single required 'table' parameter fully documented in the schema. The description only restates 'a table' and adds no format, qualification, or case-sensitivity guidance, so baseline 3 is correct.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb + resources: 'Get the column names and gateway masking policy for a table'. An agent can distinguish it from db_gateway__query_table and db_gateway__list_tables by the resource returned. It stops short of naming those siblings explicitly, but the distinction is inferable.
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 clause 'helps the LLM understand what data it can access' implies a pre-query inspection step, but the description never states when to call this versus query_table, nor any prerequisite. Usage is implied rather than directed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
db_gateway__gateway_statusA
Show the active gateway configuration: field masking rules, table policies, and audit settings.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations at all, the description carries the full disclosure burden. It does add real behavioral content by naming the three configuration surfaces returned (masking, policies, audit settings), but omits that this is read-only, whether it requires elevated permission to view policy config, and whether the settings apply immediately or are merely displayed. Useful but incomplete for an unannotated 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?
One front-loaded sentence with no padding; the scope is established before detail. It is arguably too terse rather than too long — a short trailing clause on when to prefer it would cost nothing and buy a lot.
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 is simple (no params, no output schema), so the description does not need to document return values or argument formats. However, for a config-inspection tool with no annotations, the description should still establish that it is a non-mutating read and roughly how fresh or complete the displayed configuration is.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No schema-vs-description gap exists here.
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 ("Show") plus a well-scoped resource ("active gateway configuration") and an enumeration of the three sections returned: field masking rules, table policies, audit settings. This clearly separates it from the data-access siblings (query_table, list_tables, describe_table) which is enough for an agent to pick correctly, though it never names those siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the noun phrase — an agent would infer it is the call to make when it needs to know the gateway's current masking/policy/audit posture. There is no explicit "use when..." clause and no statement about what it is not for, so the caller must infer the boundary with query_audit_log or describe_table.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
db_gateway__list_tablesA
List all available database tables. Tables marked as 'deny' in gateway policy are omitted.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It does disclose one meaningful behavior: tables marked 'deny' in gateway policy are omitted, which explains why results may be incomplete. It says nothing about ordering, pagination, or what metadata each table entry carries.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with no waste; the core action is front-loaded and the filtering caveat follows immediately.
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 listing tool with no output schema and no annotations, the definition covers purpose and the policy-filtering caveat. Only the shape of returned table entries (name only? schema? row counts?) is 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?
The tool takes zero parameters, and the description correctly implies no inputs are needed. Baseline 4 applies for a parameterless tool.
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 ('List all available database tables'), so the agent knows exactly what it returns. It doesn't explicitly distinguish itself from siblings like db_gateway__describe_table or db_gateway__query_table, but the listing purpose is 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?
Usage is only implied — an agent can infer this is the discovery step before describe_table or query_table, but the description never says so or names alternatives. No prerequisites or when-not-to-use conditions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
db_gateway__query_audit_logA
Query the gateway's own audit log — inspect which tools were called, on which tables, whether they were allowed or denied (and why), and which fields were redacted/written. Covers events since this server process started; count is capped by the gateway's audit.bufferSize (default 200).
| Name | Required | Description | Default |
|---|---|---|---|
| tool | No | Filter by MCP tool name, e.g. 'query_table', 'update_row' | |
| limit | No | Max events to return, most recent first (default 50) | |
| since | No | ISO 8601 timestamp — only events at or after this time | |
| table | No | Filter by table name | |
| operation | No | Filter by operation type | |
| deniedOnly | No | Only return calls the gateway denied/blocked |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the whole burden and does disclose the two non-obvious behavioral limits: coverage is limited to the current process lifetime (in-memory, non-persistent) and result count is capped by audit.bufferSize (default 200). It leaves implicit that the call is read-only and says nothing about permissions or auth requirements, which keeps it out of 5 territory.
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, no filler. The identity/scope statement comes first, then the operational caveats (time window, buffer cap) — exactly the right front-loading for an agent deciding whether to call it.
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?
Six optional filters with no output schema and no annotations is a lot of unstructured surface, and the description compensates well by describing the event fields and the retention/window limits. The only gap is that without an output schema the exact return shape (field names, ordering, empty-result behavior) is only sketched rather than specified.
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 every filter (tool, table, operation, since, limit, deniedOnly) is documented in the schema with examples and defaults. The description reinforces what the filters select ('which tools were called, on which tables, whether allowed or denied') but adds no syntax or format details beyond the schema, so the baseline of 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?
Specific verb plus specific resource: queries the gateway's *own* audit log, explicitly contrasted with the data-plane tools in the sibling list (query_table, describe_table, list_tables). It also enumerates the content of an event — tool, table, allow/deny with reason, redacted/written fields — so an agent knows exactly what class of information comes back.
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 'the gateway's own audit log' implicitly routes the agent away from query_table when it wants metadata about calls rather than data from tables, and the buffer/retention note tells the agent when this tool is *not* useful (events before process start). No explicit when-to-use sentence or named alternative sibling, 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.
db_gateway__query_tableB
Query rows from a database table with optional filters. All results pass through the KVKK/GDPR gateway — sensitive fields are automatically masked.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max rows to fetch before gateway limit is applied (default 50) | |
| table | Yes | Table name to query | |
| filter | No | Key-value filter pairs, e.g. { status: 'active' } |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden; it does disclose a genuinely non-obvious trait — that every result is routed through the KVKK/GDPR gateway and sensitive fields are auto-masked. However, it doesn't state that the operation is strictly read-only, what permissions are needed, or how masked values are represented in the returned rows.
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 the non-obvious gateway/masking caveat. No filler and nothing 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?
The tool has no output schema and no annotations, so the description is the only place return behavior could be explained, yet it doesn't describe what a result row looks like or how masking appears. For a query tool with a nested filter object, that leaves a real gap even though the inputs are fully documented.
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 table, filter, and limit are all documented with examples and the 200-row cap. The description adds nothing beyond that, so the baseline 3 applies rather than a higher score.
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 ("Query rows from a database table") with the scope qualifier "optional filters". It is distinguishable from db_gateway__list_tables and db_gateway__describe_table, but it never explicitly names or contrasts with db_gateway__query_audit_log, the closest 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?
There is no guidance on when to use this versus list_tables/describe_table (e.g. 'use describe_table first to learn column names') or query_audit_log. The only inferred usage is that a table name is required, which the schema already implies.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dependency_auditor__audit_directoryA
Auto-detect and audit every supported project in a directory: npm (package-lock, pnpm, yarn, bun), Python (uv, Poetry, Pipenv, requirements), Rust (Cargo.lock), Go (go.mod), Ruby (Gemfile.lock) and PHP (composer.lock)
| Name | Required | Description | Default |
|---|---|---|---|
| directory | Yes | Path to the project root directory | |
| exploitData | No | Add CISA KEV (exploited in the wild) and FIRST EPSS data and order findings by it (default: true; sends CVE IDs only) | |
| includeDevDeps | No | Include dev dependencies (default: false) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden, and it discloses almost nothing beyond what it scans: it does not state that the operation is read-only / non-mutating, that no installs or lockfile changes occur, or that exploitData defaults on and sends CVE IDs to CISA KEV / FIRST EPSS services (network egress), which is a meaningful trait an agent should know before calling.
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 that names the action, the scope, and then the supported ecosystem/format list with parenthetical precision. No filler, and the enumeration earns its place by telling the agent what will be detected.
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 annotations and no output schema, the description should hedge more than it does: it says what gets detected but not what a finding looks like, whether results are aggregated per project, or that external exploit data is fetched by default. Adequate for selecting the tool, thin for anticipating its behavior.
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 'directory', 'exploitData' and 'includeDevDeps' including defaults and the fact that CVE IDs are transmitted. The description adds no parameter-level meaning beyond that, so the baseline of 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 pair ('auto-detect and audit') and a specific resource scope ('every supported project in a directory'), then enumerates exactly which ecosystems and lockfile formats are covered. This makes it clearly the multi-ecosystem, directory-wide variant in contrast to sibling single-ecosystem tools like audit_npm, audit_pip and audit_package.
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 'every supported project in a directory' — an agent can infer this is for whole-repo sweeps rather than a single package. However, there is no explicit when-to-use/when-not guidance and no sibling is named (e.g. 'use audit_npm for a single package'), nor is there any prerequisite or exclusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dependency_auditor__audit_npmA
Audit npm dependencies for known CVEs using the OSV database. Reads exact versions from package-lock.json, npm-shrinkwrap.json, pnpm-lock.yaml, yarn.lock (v1 and berry) or bun.lock, falling back to package.json ranges
| Name | Required | Description | Default |
|---|---|---|---|
| directory | Yes | Path to the directory containing package.json | |
| exploitData | No | Add CISA KEV (exploited in the wild) and FIRST EPSS data and order findings by it (default: true; sends CVE IDs only) | |
| includeDevDeps | No | Include devDependencies in the audit (default: false) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the disclosure burden, and it does reasonably well: it names the OSV data source and explains the exact-versions-vs-range fallback logic. It omits output shape and read-only/rate-limit traits, but for a scanner the data-provenance detail is the most valuable part and is present.
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 and threat source, then the file-resolution detail. No padding; every clause adds information an agent can act on.
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 read-only audit tool with fully documented parameters and no output schema, the description covers data sources and file-resolution behavior adequately. Return format is unaddressed, but the core invocation requirements are satisfied.
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 schema already documents directory, exploitData, and includeDevDeps. The description implies directory-based lockfile discovery but adds no parameter-level meaning beyond the schema baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (audit), resource (npm dependencies), threat source (known CVEs via OSV), and exact file formats parsed. The npm specificity plus lockfile list clearly separates it from sibling audit_pip and audit_package 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 for when this applies: npm projects, with precedence order for lockfiles and fallback to package.json ranges. It does not explicitly name alternatives like audit_directory or audit_pip, so the routing is inferred rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dependency_auditor__audit_packageC
Audit a single package by name, version, and ecosystem
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Package name | |
| version | Yes | Package version (e.g. 1.2.3) | |
| ecosystem | Yes | Package ecosystem | |
| exploitData | No | Add CISA KEV (exploited in the wild) and FIRST EPSS data and order findings by it (default: true; sends CVE IDs only) |
TDQS
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 says nothing about what an audit returns, whether it makes network/registry calls, whether it is read-only or cached, or how long it takes. Some behavioral nuance (exploitData sends CVE IDs, KEV/EPSS enrichment) exists only in the schema, not the description.
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, though it is arguably under-specified rather than efficiently concise given a mutation-adjacent audit operation with four parameters.
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 annotations, no output schema, and a one-line description, an agent cannot know what the audit produces (vulnerability list? severity ordering? KEV/EPSS flags?), how results are structured, or what differentiates a package audit from the ecosystem-specific siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters, including the ecosystem enum and the exploitData toggle, are documented in the schema itself. The description merely repeats the three required parameter names and adds no syntax or format detail beyond what the schema provides — baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource — 'Audit a single package' — and names the three identifying dimensions. It implicitly separates itself from audit_directory by scoping to one package, but does not distinguish itself from the more specific siblings audit_npm and audit_pip, leaving ambiguity about which of the three to call.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance, no stated alternatives. An agent choosing between audit_package, audit_npm, audit_pip, and audit_directory gets no routing help from the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dependency_auditor__audit_pipA
Audit Python dependencies for known CVEs using the OSV database. Reads exact versions from uv.lock, poetry.lock or Pipfile.lock, falling back to requirements.txt / pyproject.toml
| Name | Required | Description | Default |
|---|---|---|---|
| directory | Yes | Path to the directory containing requirements.txt or pyproject.toml | |
| exploitData | No | Add CISA KEV (exploited in the wild) and FIRST EPSS data and order findings by it (default: true; sends CVE IDs only) | |
| includeDevDeps | No | Include dev groups from poetry.lock, uv.lock or Pipfile.lock (default: false) |
TDQS
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 external data source (OSV) and the resolution precedence across lockfiles, which is real behavioral context, but it never says the tool is read-only/non-destructive, whether it hits the network per package, what it does when no lockfile is found, or what the findings 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: the action and CVE source come first, followed by the file-resolution rule. No filler, and the most decision-relevant information is 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?
For a 3-parameter read-only audit with full schema coverage and no output schema, this is close to sufficient: source resolution and data source are covered. A short note on output shape or that no files are modified would close the remaining gap left by the absence of annotations.
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, but the description earns more by clarifying that `directory` may contain uv.lock/poetry.lock/Pipfile.lock and not only requirements.txt/pyproject.toml as the schema says. That precedence also gives context for includeDevDeps, though exploitData behavior is left entirely to 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 (audit Python dependencies) and the data source (OSV CVE database), which implicitly separates it from dependency_auditor__audit_npm. However, it never names or contrasts the closest siblings (audit_package, audit_directory), so routing relies on the reader inferring that this is the Python/lockfile-specific variant.
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 mention of lockfiles and fallback files: use it on a Python project directory that has one of these manifests. There is no explicit when-to-use/when-not statement and no reference to audit_package or audit_directory as alternatives for other input shapes or ecosystems.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dns_intelligence__audit_domainsA
Audit several domains at once (e.g. every brand or country domain) and compare them: an A–F grade per domain from all DNS, email, DNSSEC, CAA and nameserver checks, plus each domain's most serious findings
| Name | Required | Description | Default |
|---|---|---|---|
| domains | Yes | Domains to audit, e.g. ["example.com", "example.de"] | |
| nameserverProbe | No | Query nameservers directly (default: true) |
TDQS
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 what checks execute (DNS, email, DNSSEC, CAA, nameserver) and what comes back (per-domain grade plus top findings). It omits operational traits an agent would want, such as expected latency when auditing up to 20 domains, behavior on unresolvable domains, and whether live DNS queries are made.
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 that opens with the action and follows with a colon-introduced payoff of what the agent gets. No filler; the enumeration of check types is dense but each item adds real 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 no annotations, so the description's output preview (grade per domain plus most serious findings) does meaningful work that structured fields don't cover. Remaining gaps are operational — failure modes for malformed domains and cost of large batches — rather than conceptual.
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 already carry their own documentation and the 3 baseline applies. The description adds light semantic framing for `domains` (brand/country groupings) but says nothing about `nameserverProbe` or how it changes 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?
Names a specific verb and resource in plural scope ("Audit several domains at once") and previews the output (A–F grade per domain plus most serious findings), which implicitly distinguishes it from single-domain siblings like lookup_dns or check_email_security. It never names those siblings explicitly, so the 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?
"Audit several domains at once (e.g. every brand or country domain) and compare them" implies the use case is bulk/comparative work, which is a reasonable usage cue. However, it gives no explicit when-not guidance and doesn't tell the agent to prefer lookup_dns or check_email_security for single-domain or single-check needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dns_intelligence__check_email_securityA
Check a domain's email security: MX, SPF (nested lookup count), DMARC, DKIM key strength, MTA-STS and TLS-RPT, with remediation advice
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | Domain to check email security for | |
| dkimSelectors | No | Additional DKIM selectors to check (default: common selectors) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral burden. It discloses the specific checks performed and that remediation advice is included, but it does not state read-only behavior, network access requirements, rate limits, or output format. 'Check' implies a safe read operation, but this is not made explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler. Every clause identifies a concrete email-security control or capability, and the key purpose is stated 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?
With no output schema and no annotations, the description does a good job listing exactly what is checked and noting remediation advice. It stops short of explaining the return structure or pass/fail semantics, but it is complete enough to know what the tool does.
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 are already documented in the schema. The description implies the domain parameter and mentions DKIM checks, but does not add syntax or selector-handling details beyond what the schema provides; 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 states a specific verb and resource: 'Check a domain's email security.' It then enumerates the exact email-security controls checked (MX, SPF, DMARC, DKIM key strength, MTA-STS, TLS-RPT), which clearly distinguishes it from generic DNS siblings such as lookup_dns or enumerate_dns.
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 for email-security checks but gives no explicit when-to-use guidance, prerequisites, or alternatives. It does not say when to prefer this over dns_intelligence__lookup_dns or dns_intelligence__audit_domains.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dns_intelligence__check_takeoverB
Check specific hostnames (e.g. from your DNS zone or certificate logs) for subdomain takeover
| Name | Required | Description | Default |
|---|---|---|---|
| hosts | Yes | Hostnames to check, e.g. ["blog.example.com"] | |
| httpProbe | No | Fetch pages to match takeover fingerprints (default: true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full disclosure burden, and it discloses almost nothing: it never says the tool performs live network resolution/HTTP fetches, gives no timeout or rate-limit expectations, and doesn't mention the 200-host batch cap or whether a probe failure invalidates a result. The only hint of network activity ('Fetch pages') lives in the schema, not the description.
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 tight sentence with the action front-loaded and no filler. It is efficient, though slightly under-specified for a tool that performs active probing.
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 two-parameter tool with full schema coverage, this is minimally adequate. But with no output schema and no annotations, the description still leaves the agent guessing what comes back (per-host verdicts, fingerprints, findings?) and doesn't warn that the default httpProbe=true triggers outbound page fetches.
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 hosts and httpProbe (including its default of true). The description only adds the source of hostnames (DNS zone, certificate logs), which is mild but real value beyond the schema; 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 (check) plus the resource (specific hostnames) and the exact condition being tested (subdomain takeover), which separates it from sibling DNS tools like lookup_dns or enumerate_subdomains. It does not explicitly name those siblings, 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 parenthetical 'e.g. from your DNS zone or certificate logs' implies where input hostnames come from, giving an implied workflow (enumerate, then check). It never says when to prefer this over dns_intelligence__lookup_dns or enumerate_subdomains, and states no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dns_intelligence__enumerate_dnsA
Enumerate all DNS records for a domain and detect misconfigurations: SPF, DMARC, DKIM key strength, MTA-STS/TLS-RPT, MX, DNSSEC (signed / broken / weak algorithms) and CAA (including whether it blocks the CA of the live certificate) and nameservers (lame delegation, anonymous zone transfer, open recursion)
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | Domain to enumerate (e.g. example.com) | |
| nameserverProbe | No | Query each nameserver directly for lame delegation, SOA serial drift, anonymous zone transfer (AXFR) and open recursion (default: true) |
TDQS
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 add real behavioral context about what is actively probed (zone transfer attempts, open recursion, DNSSEC algorithm weakness, CAA vs live cert), which tells the agent this performs live network queries rather than reading a cache. It omits, however, whether the operation is read-only/non-mutating, expected latency, rate limits, or failure behavior for unreachable domains.
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 the verb and resource first, then the check list. The parenthetical inventory is dense and each item is informative, though the run-on structure makes it slightly harder to scan than a short bulleted scope statement.
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 parameters, no output schema, and no annotations, the description is close to sufficient: it tells the agent what will be checked and that misconfigurations are detected. The missing piece is any hint of result shape or severity/verdict reporting, which the agent must discover at call time.
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 are already documented, including the nameserverProbe default and its four probe types. The description never references the nameserverProbe toggle, so it adds no semantics beyond the schema; 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 and resource ('Enumerate all DNS records for a domain') and then enumerates the exact check families covered (SPF, DMARC, DKIM, MTA-STS/TLS-RPT, MX, DNSSEC, CAA, nameservers). The breadth implicitly separates it from dns_intelligence__lookup_dns, but no sibling is named explicitly, so an agent must infer the boundary.
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 comprehensive scope hints that this is the full-audit call versus a simple lookup, but there is no explicit when-to-use/when-not guidance, no mention of alternatives like lookup_dns, audit_domains, or check_email_security, and no stated prerequisites (e.g. whether the domain must be resolvable).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dns_intelligence__enumerate_subdomainsA
Find subdomains from Certificate Transparency logs and a common-name wordlist, and detect subdomain takeovers: CNAMEs to S3, GitHub Pages, Azure, Heroku, Netlify and other providers whose resource is gone (verified fingerprints), or to targets that no longer exist
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | Root domain to enumerate subdomains for (e.g. example.com) | |
| httpProbe | No | Fetch pages behind provider CNAMEs to match takeover fingerprints (default: true) | |
| certificateTransparency | No | Add names found in Certificate Transparency logs via crt.sh and Cert Spotter (default: true; sends only the domain name) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries the full burden, and it does real work: it names the data sources (crt.sh, Cert Spotter), discloses that only the domain name is sent to them, and notes that provider fingerprints are verified rather than guessed. Gaps remain around rate limits, runtime, and the fact that httpProbe issues live HTTP requests to third-party hosts, 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?
A single front-loaded sentence puts the primary action first and appends the takeover-detection scope. It is dense but every clause adds information; the provider list is mildly long but concrete. Minor run-on structure keeps it from a 5.
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 tool with no output schema and no annotations, the description conveys enough: what is enumerated, from which sources, and what kind of finding (dangling provider CNAME) results. It stops short of describing result shape or handling of partial failures, which is the remaining gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters are already documented in the schema. The description restates the same concepts (CT logs, provider fingerprint probing) at a slightly higher level without adding syntax, defaults, or edge-case behavior beyond what the schema provides. 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 and resource: find subdomains from Certificate Transparency logs and a wordlist, plus detect subdomain takeovers via dangling CNAMEs to named providers. That is far more specific than a bare 'enumerate' label. It doesn't explicitly contrast with the sibling tools dns_intelligence__check_takeover or dns_intelligence__enumerate_dns, which overlap meaningfully, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when it is appropriate (broad enumeration plus takeover detection in one pass), but never says when to prefer the narrower check_takeover or enumerate_dns siblings, nor does it state prerequisites like needing authorization to probe third-party hosts. Usage is inferable but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dns_intelligence__lookup_dnsB
Perform a targeted DNS lookup for specific record types on a domain
| Name | Required | Description | Default |
|---|---|---|---|
| type | Yes | DNS record type to look up | |
| domain | Yes | Domain to query |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It does not say whether the query is live against authoritative/public resolvers, whether it follows CNAMEs, what the response shape is, or any rate/recursion limits — for a zero-annotation tool that is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler and no repetition of the name. It is efficient, though the brevity borders on under-specification for a tool with no annotations and no output schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (2 required params, no nesting), but with no annotations and no output schema, the description should at least sketch what a lookup returns (record values, TTL, resolver used) and how failures/NXDOMAIN appear. That is missing, leaving the agent to discover it empirically.
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 type enum is self-documenting, so the schema does the heavy lifting. The description only restates that a domain and record type are supplied, adding no format, normalization, or IDN handling detail 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?
The description gives a specific verb (lookup) and resource (DNS records) plus scope (targeted, specific record types on a domain), which implicitly contrasts with the broader enumerate_dns sibling. It stops short of naming that sibling or stating what 'targeted' excludes, so it is clear but not fully differentiated.
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?
'Targeted ... for specific record types' hints that this is the tool to use when you already know which record type you want, implying enumerate_dns covers the broader case. However, there is no explicit when-to-use/when-not or named alternative, so the agent must infer the routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
document_scanner__list_detectorsA
List the PII and credential detectors this scanner runs
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'List' implies a read-only, side-effect-free operation, but nothing states the return shape, whether detectors can be configured, or whether this reflects enabled vs. available detectors.
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. Brevity is appropriate for a zero-argument listing tool, though it leaves detail on the table rather than being too long.
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, so the description should say what the returned list looks like (detector names, categories, enabled status). It also doesn't distinguish 'PII and credential detectors' from the scanner's other capabilities, leaving a gap for such a simple 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?
Zero parameters, so there is nothing to document; baseline 4 applies. The description correctly signals no input is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource: 'List the PII and credential detectors this scanner runs'. An agent knows exactly what it returns conceptually. It doesn't explicitly contrast with sibling scanners' list_patterns tools, but the scope is specific to this scanner's detectors.
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?
Implied use as a discovery/introspection step before or alongside scan_document and scan_base64, but the description never states when to call it or what to do with the results. No alternatives or exclusions named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
document_scanner__scan_base64B
Scan a document given as base64 (an attachment, an image a tool returned) for PII and credentials. The type is detected from the bytes.
| Name | Required | Description | Default |
|---|---|---|---|
| ocr | No | OCR images and PDF pages without a text layer (default true; needs tesseract.js) | |
| data | Yes | Base64 bytes (a data: URL prefix is allowed) | |
| label | No | ||
| include | No | Opt-in detectors: ip_address, mac_address, plate_tr | |
| languages | No | Tesseract languages, default ["tur", "eng"] |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It does usefully disclose that 'the type is detected from the bytes' (no format param needed) and scopes the detectors to PII and credentials, but says nothing about size limits, whether processing is local vs. remote (relevant since raw base64 data is being uploaded), or latency costs of OCR.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the resource and the format constraint front-loaded and zero filler. Appropriately sized, though brevity comes at the cost of the missing behavioral and output detail noted elsewhere.
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, so the description is the only place an agent could learn what findings look like, and it says nothing about return shape, severity, or truncation behavior. For a 5-parameter scan tool with no annotations, that leaves a real gap despite an otherwise competent header sentence.
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 documents data, ocr, languages and include. The description adds only the framing that the payload is base64 bytes and that format detection is automatic, which explains the absence of a type parameter but does not add meaning to label or include.
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 ('Scan a document given as base64') plus the detection targets ('PII and credentials'), which sets it apart from generic scanners. It does not explicitly name its closest sibling, document_scanner__scan_document (file-path variant), though the base64 framing implies the difference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The parenthetical 'an attachment, an image a tool returned' hints at the input situations this is for, which is useful implicit guidance. However it never states when to choose this over document_scanner__scan_document or what to do if the input is a path, leaving routing to the agent's inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
document_scanner__scan_documentA
Find PII (TC Kimlik No, IBAN, card, passport, e-mail, phone, address…) and credentials inside a PDF, an image (screenshot, scanned page) or a text file on disk, before it is given to an LLM. PDFs are read from their text layer; images and scanned pages with OCR (Turkish and English).
| Name | Required | Description | Default |
|---|---|---|---|
| ocr | No | OCR images and PDF pages without a text layer (default true; needs tesseract.js) | |
| path | Yes | Path to a file, or a folder to scan every PDF and image in it | |
| include | No | Opt-in detectors: ip_address, mac_address, plate_tr | |
| languages | No | Tesseract languages, default ["tur", "eng"] |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full disclosure burden, and it does disclose the important non-obvious behavior: PDFs are read from the text layer, while images and scanned pages go through OCR in Turkish and English. That tells an agent how results are produced and why a scan may miss text in embedded/scanned PDFs. It still omits that the operation is read-only/non-mutating and gives no hint about output shape or limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two dense sentences, no wasted clauses. The purpose and detector coverage come first, followed by the medium-specific processing behavior. Front-loaded and appropriately sized for the tool's complexity.
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, so the description is the only place an agent could learn what a scan returns. It never says whether results are a list of findings with line numbers, severities, or masked snippets, which is a notable gap for a scanner. Input-side completeness is adequate given 100% schema coverage.
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 of 3 applies. The description adds some meaning by naming the PII/credential categories, but those are default detectors, not the opt-in include enum values (ip_address, mac_address, plate_tr), which remain documented only in the schema. No syntax, path format, or default details are added 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 (Find) plus the exact resource categories it scans for (PII: TC Kimlik No, IBAN, card, passport, e-mail, phone, address, plus credentials) and the exact container types (PDF, image, text file on disk). An agent can distinguish this from sibling scanners like document_scanner__scan_base64 or a2a_auditor__scan_file 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?
Provides a clear use case and timing: 'before it is given to an LLM.' That is genuine guidance on when this tool fits. However, it never names an alternative (e.g., document_scanner__scan_base64 or document_scanner__list_detectors) or states when not to use it, so it stops short of explicit routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
elicitation_auditor__list_patternsA
List every elicitation check this auditor runs
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and 'List' does make clear this is a non-mutating enumeration rather than a scan. However, it says nothing about whether calling it triggers any analysis, whether the result includes pattern IDs, descriptions, or severities, or how large the listing may be — and no output schema exists to fill that gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single eight-word sentence, front-loaded with the verb and scoped by 'this auditor'. Nothing is padded and nothing is buried.
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 schema is trivially empty and there are no annotations or output schema, so the description is the only source of information about the result — and it doesn't say what a 'check' looks like in the response. For a catalog-listing tool an agent typically needs that to chain into scan calls; the definition is minimally viable but not 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?
The tool takes zero parameters, so the baseline is 4; there is no parameter semantics to convey. The description correctly implies a no-argument, whole-catalog listing.
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 ('List') and a specific resource ('every elicitation check this auditor runs'), which scopes it to the elicitation_auditor family rather than the dozens of sibling list_patterns tools. It stops short of distinguishing a check inventory from the sibling scan_text/scan_file/scan_directory operations, but the purpose itself is 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?
Usage is only implied: an agent can infer this is a discovery call to enumerate available checks, likely prior to scanning. There is no explicit when-to-use, no statement of when to prefer scan_text or scan_directory instead, and no prerequisites. Adequate 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.
elicitation_auditor__scan_directoryA
Recursively scan a directory of MCP server source for elicitation anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the burden: it conveys that scanning is recursive and confined to a directory tree, which is useful scoping context. It does not disclose whether files are merely read (static analysis) versus executed, whether results are truncated at maxFiles, or how findings are aggregated, which matters for a scanner 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?
One sentence, front-loaded with the core action and scope, with no filler. Nothing to trim and no delay before the essential 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?
With four parameters, no output schema, and no annotations, the description covers the 'what' but not the 'what to expect': no mention of the result shape, per-file versus aggregated findings, or behavior on large trees. Adequate to invoke, but not to set expectations.
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 path, include/exclude filters, and the maxFiles default of 5000 are already fully documented in the schema. The description adds no syntax, matching semantics, or interaction details (e.g. how include and exclude combine), 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?
Specific verb+resource ('recursively scan a directory') scoped to 'MCP server source' and a named class of findings ('elicitation anti-patterns'), so an agent knows exactly what it produces. It does not, however, distinguish itself from the sibling scan_file/scan_text variants of the same auditor.
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 by the word 'directory': an agent can infer this is the bulk/batch variant versus elicitation_auditor__scan_file and scan_text, but the description never states when to pick one over the other. No prerequisites (e.g. that the directory must contain server source) are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
elicitation_auditor__scan_fileC
Scan a single file for elicitation anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden yet says nothing about what an anti-pattern is, whether the operation is read-only, how large a file can be, or whether results are returned inline or summarized. It only restates the obvious 'scan' action.
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 no wasted words. Its brevity is appropriate for the format, though the terseness edges toward under-specification rather than genuine economy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
A scanner with no annotations and no output schema needs the description to explain what findings look like and what pattern set is applied; neither is covered. An agent cannot predict the result shape or how to interpret findings from this definition.
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 path parameter is fully documented in the schema, so the baseline of 3 applies. The description adds no additional semantics such as path resolution behavior, error handling for missing files, or supported file types.
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 (Scan), a specific resource (a single file) and the domain object (elicitation anti-patterns), so an agent knows exactly what the tool targets. It does not explicitly differentiate itself from siblings like elicitation_auditor__scan_text or scan_directory beyond the implicit 'single file' 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?
There is no guidance on when to choose this over elicitation_auditor__scan_text, scan_directory, or list_patterns; the agent must infer that a directory input should route to scan_directory. No prerequisites or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
elicitation_auditor__scan_textB
Scan MCP server source for elicitation anti-patterns from the 2026-07-28 spec: form mode requesting secrets or embedding a link, URL mode opened directly on a third-party authorize endpoint, credentials in the elicitation URL, a form answer used as the user's identity, and a result used without checking decline or cancel.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden. It does useful work by naming the six detection categories, which lets the agent anticipate findings, but it says nothing about whether the scan is purely local/read-only, what the findings look like, severity levels, or whether a single call returns all matches.
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: verb and resource first, then the pattern taxonomy. Every clause names a distinct detectable anti-pattern, so nothing is padding, though the run-on list could be split for scanability.
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 annotations and no output schema, the description is the only source of behavioral information, and it omits return shape, severity, and routing to the file/directory siblings. It is adequate to understand what the tool hunts for but not complete enough to predict the response.
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 'content' and the optional 'label' are already documented in the schema; the description adds no extra meaning such as expected size limits or how 'label' surfaces in findings. Baseline 3 applies when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb ('Scan') plus a precise resource ('MCP server source') followed by an enumerated list of the exact anti-patterns detected under the 2026-07-28 spec, which tells the agent far more than the tool name alone. It does not, however, distinguish itself from the sibling scan_file / scan_directory variants of the same auditor, so the agent must infer the text-vs-file split from the name.
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 enumerated pattern list and the required 'content' parameter, so an agent can infer this is the in-memory variant. There is no explicit statement about when to prefer scan_file or scan_directory, nor any precondition (e.g. content must be source code, not prose).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
llm_redteam__list_probesA
List all red-team probes this tool can run against a target LLM/chatbot, grouped by category. Every probe is canary-based (safe) — none ask the target to produce genuinely harmful content.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does meaningful work: it discloses that every probe is canary-based and safe, and that none request genuinely harmful content — exactly the concern an agent or operator would have about a red-team tool. It stops short of saying whether the call contacts a target at all or is purely a static catalog read.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each earning its place: the first defines the operation and result shape, the second preempts the safety objection. Nothing is padded or restated from the name.
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 catalog tool with no output schema, the description covers what is returned (probes grouped by category) and the safety profile. It could go one step further and note whether the returned probe identifiers are the inputs expected by run_probe_suite, but nothing essential is missing for correct 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?
The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies no inputs are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ("List") and resource ("red-team probes") plus the grouping structure of the result, which is enough to distinguish it from the sibling run_probe_suite. The phrase "probes this tool can run" is slightly imprecise, since list_probes itself doesn't run anything, but the intent is 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?
Listing probes implies a discovery step before running them, and the sibling run_probe_suite makes that workflow inferable, but the description never says 'use this to discover probes before calling run_probe_suite' or states any prerequisite or exclusion. Usage is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
llm_redteam__run_probe_suiteA
Run canary-based red-team probes against a live LLM endpoint or chatbot you control, to test whether known jailbreak/extraction/obfuscation techniques bypass its guardrails. ONLY point this at an endpoint you own or are explicitly authorized to test — every probe consumes API quota on the target. Probes never request genuinely harmful content; success is measured by whether the target reproduces a random one-time token, proving an override instruction was obeyed.
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | ||
| probeIds | No | Only run these specific probe IDs (see list_probes) | |
| maxProbes | No | Cap the number of probes run, to limit API cost | |
| categories | No | Only run probes in these categories |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already flag readOnlyHint=false and openWorldHint=true, but the description goes further: it discloses quota consumption per probe, that probes never request genuinely harmful content, and precisely how success is judged (target reproduces a random one-time token). That is meaningful behavioral context an agent cannot get from the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences: purpose first, authorization/cost constraint second, safety rationale third. Every sentence carries information 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 non-idempotent, open-world tool with no output schema, the description covers authorization, cost, and success criteria. It stops short of describing the shape of results (per-probe pass/fail, reproduction evidence), which an agent would want, but the token criterion covers the essential outcome.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 75% and the nested target union is fully documented inline, so the description needn't re-explain parameters. It loosely frames the target as an 'endpoint or chatbot you control' but adds no new semantics for probeIds, maxProbes, or categories beyond what the schema already states.
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 ('Run canary-based red-team probes against a live LLM endpoint or chatbot') plus the exact technique classes tested (jailbreak/extraction/obfuscation bypass of guardrails). This is clearly distinguishable from the companion llm_redteam__list_probes, which only enumerates probe IDs.
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 a hard precondition ('ONLY point this at an endpoint you own or are explicitly authorized to test') and a cost warning ('every probe consumes API quota'), which tells the agent when NOT to call it. It lacks explicit routing guidance to alternatives (e.g., call list_probes first to choose probeIds), leaving that inference to the schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_config_auditor__discover_shadow_mcpA
OWASP MCP09:2025 — discover MCP client configs in well-known host paths (Cursor, Claude Desktop, Windsurf, VS Code, Claude Code) and flag servers that are not on an organization allowlist (Shadow MCP). Does not start any MCP server.
| Name | Required | Description | Default |
|---|---|---|---|
| home | No | Override home directory used to resolve well-known config paths | |
| allowlist | No | JSON allowlist: {"names":["filesystem"],"packages":["@modelcontextprotocol/server-filesystem"],"hosts":["mcp.example.com"]} or line form name:/package:/host: | |
| includeContentAudit | No | Also run the normal config content checks on each discovered file (default false) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does provide one important behavioral guarantee: it 'Does not start any MCP server.' However, it does not explicitly state that the tool is read-only, whether it modifies config files, permission requirements, or what form the 'flag' output takes.
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 two sentences, front-loaded with the core action and scope, and includes only useful qualifiers such as the host applications and the no-server-start boundary. Every 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?
The description covers the essential purpose, scan scope, allowlist checking, and the safety boundary of not starting MCP servers. It is slightly incomplete for a tool with no annotations and no output schema because it does not describe the returned findings format or permission assumptions.
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 description references the allowlist concept in context but adds little parameter-specific detail beyond what the schema already provides for home, allowlist, and includeContentAudit.
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 ('discover') and resource ('MCP client configs in well-known host paths'), names the relevant host applications, and explains the additional behavior of flagging servers not on an allowlist. This clearly distinguishes it from sibling tools such as mcp_config_auditor__list_host_config_paths or mcp_config_auditor__scan_file.
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 context for when the tool is appropriate: auditing well-known host config locations for Shadow MCP. It does not explicitly name alternatives or exclusions (e.g., when to use list_host_config_paths or scan_directory instead), but the intended usage is readily inferred from the scope.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_config_auditor__list_host_config_pathsA
List the well-known MCP client config paths this auditor checks during shadow (MCP09) discovery on the current OS.
| Name | Required | Description | Default |
|---|---|---|---|
| home | No | Override home directory |
TDQS
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 usefully signals that these are the paths the auditor *checks* (a static reference set) rather than files actually found, but it does not say whether nonexistent paths are included, how the result is formatted, or whether OS-specific filtering affects output.
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 that names the return content and the context (shadow/MCP09, current OS) with no filler. Nothing can be trimmed without losing meaning.
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-param read-only introspection tool with no output schema, the description covers what the tool is but not what the returned entries mean (existence status, format, ordering). Some additional guidance on interpreting the list would close the gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is one optional parameter with 100% schema description coverage, so the schema already documents the `home` override. The description adds nothing about how `home` changes the returned paths, which is the main semantic question an agent would have; 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 ("List") and resource ("well-known MCP client config paths") and scopes it to shadow/MCP09 discovery on the current OS, which separates it from the discovery sibling. It stops short of explicitly naming discover_shadow_mcp as the action-taking counterpart, so it is clear but not fully differentiated.
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 "paths this auditor checks during shadow (MCP09) discovery" implies the tool is a pre-flight/introspection step before or alongside discovery, but no explicit when-to-use, when-not, or named alternative is given. An agent must infer that this lists checks without performing them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_config_auditor__list_patternsA
List the MCP config, agent skill, shadow-MCP discovery, and cross-server shadowing checks, with their OWASP MCP Top 10 tags.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 one useful return detail — entries come with OWASP MCP Top 10 tags — and 'List' signals a non-mutating read, but it never explicitly states read-only behavior, output shape, or whether the catalog is static versus environment-derived.
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 compact sentence with the scope front-loaded and no filler. The four enumerated categories make it denser than necessary but each item maps to a real scanner in the sibling list, so nothing 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 should say more about what the list items look like and how to feed them into the scan tools. Naming the OWASP tag payload helps, but for a discovery entry point into a large auditor server the bridge to the actual scan calls is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4 and there is nothing for the description to compensate for. No misleading parameter hints are present.
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 (List) and enumerates the exact resource categories this server covers: MCP config, agent skill, shadow-MCP discovery, and cross-server shadowing checks. The scoping to this auditor's domains distinguishes it from the many other *_list_patterns siblings, though it never states the identifier form returned.
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 a discovery call to run before scanning, but the description never says when to call it, nor points to the scan tools (scan_config_text, scan_skill_text, discover_shadow_mcp) that consume these patterns. No exclusions 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.
mcp_config_auditor__scan_config_textA
Scan an MCP client config JSON string (Cursor mcp.json, Claude Desktop, Windsurf, or VS Code) for unpinned packages, secrets, wildcard auto-approve, unauthenticated remote endpoints, and typosquats.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional filename shown in findings | |
| content | Yes | Raw JSON config |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full behavioral burden, and it does disclose the audit surface (five finding categories) rather than restating the name. However, it says nothing about whether the operation is read-only, what a finding looks like, or how results are shaped/ordered — meaningful gaps for a scan tool with no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler: verb, input, supported sources, and the checked issue classes in that order. Every clause earns its place, and the run-on listing is appropriate for a scanner that must enumerate coverage.
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 are no annotations and no output schema, so the description should describe what comes back (findings, severities, summary counts) and what happens on invalid JSON — neither is covered. The inputs are fully documented and the detection scope is clear, so the tool is callable, but result interpretation is left entirely to guesswork.
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%, with `content` ("Raw JSON config") and `label` ("Optional filename shown in findings") both documented in-schema. The description reinforces that content is a JSON string of a client config, but adds nothing about `label` or about what happens when the JSON is malformed, so it matches rather than exceeds the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific verb+resource ("scan an MCP client config JSON string") and enumerates the exact classes of issues checked: unpinned packages, secrets, wildcard auto-approve, unauthenticated remote endpoints, typosquats. It also names the concrete config formats (Cursor mcp.json, Claude Desktop, Windsurf, VS Code), which is what separates this string-input scanner from siblings like mcp_config_auditor__scan_file or scan_directory.
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 "config JSON string" plus the supported host list makes clear when this tool applies versus the file/directory variants in the same family. It gives no explicit exclusion or fallback (e.g., "use scan_file when you have a path"), leaving the sibling routing to inference from naming.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_config_auditor__scan_directoryB
Find mcp.json, mcp_config.json, claude_desktop_config.json, and SKILL.md under a directory and audit each one. A directory scan also compares skill names. Does not start any MCP server.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Directory to search | |
| exclude | No | Skip paths containing one of these strings | |
| maxFiles | No | Maximum files to consider (default: 5000) |
TDQS
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 usefully discloses that no MCP server is started and that skill-name comparison happens at directory scope, but says nothing about recursion depth, write side effects, or behavior on zero matches — gaps that matter for a filesystem walker.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the concrete artifact list, and the negative constraint is cleanly separated at the end. Slight dead weight in the fragment 'A directory scan also compares skill names,' which could be folded into the main 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?
With no annotations and no output schema, the description must cover both behavior and results. It explains what is scanned and audited but not what the audit returns or how findings are shaped, leaving an agent to discover the response by calling it.
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% with all three parameters documented in the schema. The description adds no extra meaning about path, exclude strings, or the maxFiles cap, 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?
Specific verb+resource: it names the exact file names it looks for (mcp.json, claude_desktop_config.json, SKILL.md) and says it audits each one, which implicitly separates it from sibling mcp_config_auditor__scan_file and scan_config_text. It stops short of explicitly naming those siblings, so differentiation is inferable 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?
The description implies usage ('under a directory', 'a directory scan also compares skill names') but never states when to pick this over scan_file or scan_inventory. The only explicit guidance is a negative boundary: 'Does not start any MCP server.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_config_auditor__scan_fileA
Scan one MCP client config file, or a SKILL.md agent skill when the file has that name.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path to the config file |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the dual-mode behavior (config file vs SKILL.md skill), which is genuinely useful, but says nothing about read-only semantics, what findings it produces, or how it handles unparseable files.
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, front-loaded with the primary resource and the exception appended. No filler, nothing 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 one-parameter scanner with no output schema and no annotations, the description identifies the target but not the nature of the result (security findings, format, pass/fail). It is adequate to invoke correctly but thin on what the agent gets back.
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% for the single 'path' parameter, so the schema does the documentation work. The description adds no format detail (absolute vs relative, config file extensions) beyond what the schema provides, so 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?
States a specific verb (scan) and resource (one MCP client config file), plus a special case for SKILL.md agent files. The 'one file' scope implicitly contrasts with scan_directory, though it never names the sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The single-file targeting and the SKILL.md special case imply when to use it, but the description never states when to reach for it over scan_config_text, scan_directory, or scan_skill_text. Usage must be inferred from the noun phrase.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_config_auditor__scan_inventoryA
Detect cross-server tool shadowing from an inventory of tool catalogs. Pass the tool names and descriptions already collected from each installed server. This tool does not connect to those servers.
| Name | Required | Description | Default |
|---|---|---|---|
| inventory | Yes | JSON: {"servers":[{"name":"github","tools":[{"name":"create_issue","description":"..."}]}]} |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden; it usefully discloses that no network connection to the audited servers occurs, which is real behavioral context. It says nothing about read-only guarantees, cost, or what a shadowing finding looks like, leaving notable gaps for a scanner with no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the outcome, then input instruction, then the key non-behavioral caveat. 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?
The single input parameter is fully covered, but with no output schema the description never indicates what the scan returns (findings shape, per-server pairing, severity). For a detection tool that is a meaningful omission.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and includes a concrete JSON exemplar, so the parameter is already documented. The description reinforces intent (names and descriptions from each installed server) but adds no format or constraint detail 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+object ("Detect cross-server tool shadowing") and a specific input ("inventory of tool catalogs"), which is far more informative than the generic scan_* siblings. It does not name the closest siblings (discover_shadow_mcp, toxic_flow_auditor__audit_catalog), so the agent must infer the split itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
"Pass the tool names and descriptions already collected" implies the precondition (inventory pre-collected) and "does not connect to those servers" implicitly excludes live-discovery tools. No explicit when-not or named alternative is given, so the choice between this and discover_shadow_mcp is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_config_auditor__scan_skill_textA
Scan one agent SKILL.md (YAML frontmatter plus body) for unrestricted allowed-tools, instruction override, credential file reads, and literal secrets. Name collisions across skills require a directory scan.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional filename shown in findings | |
| content | Yes | Raw SKILL.md text |
TDQS
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 enumerates the detection categories, which is helpful, but does not state that the operation is read-only, that it does not modify the input, whether it makes network calls, or what the response format looks like. For a pure text-scanning tool the implicit behavior is safe, but the description stops short of explicit behavioral 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?
Two tight sentences: the first states what is scanned and for what; the second gives the key exclusion. Front-loaded with zero 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 scanner with no output schema and no annotations, the description covers the input expectation and detection scope sufficiently. It omits return-value format and any explicit non-destructiveness guarantee, but those are minor for a straightforward text-scanning tool called on provided content.
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 'content' (Raw SKILL.md text) and 'label' (Optional filename shown in findings). The description adds the context that content should be one agent SKILL.md with YAML frontmatter and body, but does not elaborate on the optional label or any parameter formats beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('scan'), a specific resource ('one agent SKILL.md'), and enumerates the exact categories of findings (unrestricted allowed-tools, instruction override, credential file reads, literal secrets). The second sentence explicitly distinguishes it from the directory-scan alternative by noting when name collisions require that sibling, so an agent can tell it apart without inspecting 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 a clear usage condition: use this for a single SKILL.md, but switch to a directory scan when name collisions across skills matter. It does not mention other alternatives such as scan_file (for reading from disk) or scan_config_text, so an agent must infer those distinctions from sibling names, but the main exclusion is stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_server_auditor__list_patternsA
List all MCP server security patterns that the auditor can detect, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral disclosure burden. It adds useful context by saying results are grouped by category, and the operation is clearly a listing/read operation, but it does not explicitly state side-effect safety, permissions, or response shape beyond grouping.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no wasted wording. It states the resource, scope, and grouping behavior efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter listing tool with no output schema, the description is nearly complete. It explains what is listed and that results are grouped by category, though it could clarify the category structure or intended discovery workflow slightly more.
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 are no parameter semantics to document. The schema is empty and complete, and the description does not need to compensate for any parameter gaps.
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-resource pair: list all MCP server security patterns the auditor can detect. This clearly separates it from scanning tools, though it does not explicitly distinguish it from the many other list_patterns sibling tools beyond the MCP server resource 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?
Usage is implied: an agent can infer this tool is for discovering supported MCP server security patterns, likely before scanning. However, the description does not explicitly state when to use it versus alternatives such as scan_text or other auditors' list_patterns tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_server_auditor__scan_directoryA
Recursively scan an MCP server's codebase for insecure tool-definition patterns. Automatically skips node_modules, .git, dist, and binary files.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings (e.g. [".ts", "src/tools"]) | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description must carry the behavioral burden, and it does contribute real information: recursive traversal plus automatic skipping of node_modules, .git, dist and binary files, which tells the agent results are filtered by default. It omits return shape, behavior on a nonexistent path, and the 5000-file cap interaction beyond what the schema states, so the disclosure is partial rather than 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?
Two sentences, no filler, with the core action front-loaded and the default-skip behavior as supporting detail. Nothing is repeated from the schema and nothing could be cut without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter tool with no annotations and no output schema, the definition covers what is scanned and what is skipped but leaves the agent guessing about the result shape, whether maxFiles truncation is silent, and error behavior on bad paths. Adequate, but not complete for a tool whose output is consumed to make security judgments.
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 schema already explains path, include, exclude and maxFiles, making 3 the baseline. The description adds the important semantic that certain paths are excluded automatically, which qualifies how include/exclude and file counting behave, but it does not clarify precedence between those filters and the built-in skips.
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 (scan), modality (recursively, directory-wide) and target (an MCP server's codebase for insecure tool-definition patterns), which separates it from the many sibling scan_directory tools aimed at prompt injection, secrets, or AI code. It is clear what it does and roughly where it sits relative to siblings, though it never names scan_file/scan_text as the narrower alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer 'use this when you have a directory rather than a file or text', but the description gives no explicit when-to-use, when-not-to-use, or alternative routing among mcp_server_auditor__scan_file, scan_text and scan_directory. No prerequisites or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_server_auditor__scan_fileC
Scan a single file for insecure MCP server/tool-definition patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
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 not say whether the scan is read-only, whether it reads outside the given path, how long it takes, how large a file can be, or what a finding looks like — all of which matter for an unannotated security scanner.
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; every word carries payload 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?
With no annotations and no output schema, the description should say more: what category of patterns are checked, roughly what the response contains, and how findings relate to mcp_server_auditor__list_patterns. As written, an agent can call it but cannot anticipate results or know its coverage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is exactly one parameter with 100% schema description coverage ('Absolute or relative path to the file to scan'), so the schema does the work and the baseline is 3. The description adds only the 'single file' framing, no path or file-type 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 ('Scan') and resource ('insecure MCP server/tool-definition patterns'), and 'a single file' scopes it against the sibling scan_directory. It does not explicitly name which sibling to use instead, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'single file' hints at scope but gives no explicit when-to-use, when-not-to-use, or alternative (e.g. use scan_directory for trees, scan_text for pasted content, list_patterns to see what is detected). The agent must infer routing from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mcp_server_auditor__scan_textB
Scan a text string or code snippet for insecure MCP server/tool-definition patterns (excessive-agency tool names, shell/eval/SQL/SSRF sinks fed by raw tool input, overly permissive schemas, hardcoded secrets, wildcard CORS).
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
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 concrete detection categories (excessive-agency names, shell/eval/SQL/SSRF sinks, permissive schemas, hardcoded secrets, wildcard CORS), which is real behavioral content. It omits outcome semantics entirely — no mention of whether it reports findings or errors, severity levels, or whether it only detects and never modifies.
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 the purpose stated before the parenthetical detail list. The pattern enumeration is long but each item adds discriminating information, and there is 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?
For a two-parameter read-only scanner with no output schema, an agent still does not know the shape of the response (finding objects, severities, rule IDs) or whether scanning is exhaustive. The detection scope is well covered, but return-value expectations are left entirely unspecified.
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 both parameters (content, optional label) are already documented in the schema. The description adds no extra meaning about content format, size limits, or how label appears in output, so the baseline of 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 (scan) and resource (text string / code snippet) and names the domain — insecure MCP server/tool-definition patterns — which distinguishes it from generic scanners like secret_scanner__scan_text or prompt_injection_scanner__scan_text. It never names a sibling or says which scanner to pick when several overlap, so differentiation is domain-based only.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this instead of the sibling mcp_server_auditor__scan_file / scan_directory / list_patterns, nor on prerequisites or when not to use it. The only routing signal is implicit in the word 'text string', leaving the agent to infer text-vs-file alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
memory_poisoning_scanner__list_patternsA
List every memory-write and memory-readback pattern this scanner detects, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It does disclose that the result is a complete enumeration grouped by category, which implies a safe read operation, but it says nothing about whether the list is static or configurable, how large it may be, or what a pattern entry contains.
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, front-loaded with the verb and the scope, with the output organization ('grouped by category') appended efficiently. 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?
With no output schema and no annotations, the description should do more: it omits what a pattern record looks like (id, name, severity, description) and whether categories are fixed. For a zero-parameter listing tool it is adequate but leaves the agent guessing about the payload.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline of 4 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?
Specific verb ('List') plus a precisely scoped resource ('every memory-write and memory-readback pattern this scanner detects'). The domain qualifier distinguishes it from the many other *_list_patterns 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 enumerates detection coverage before running scan_text/scan_file, but the description never states when to call it versus those scan tools, nor any preconditions. No exclusions or routing guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
memory_poisoning_scanner__scan_directoryB
Recursively scan a directory of agent source code for memory-poisoning patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden, and it discloses almost nothing beyond 'recursively'. It doesn't say whether the scan is read-only, how expensive a deep tree walk is (the maxFiles default of 5000 hints at cost but is only in the schema), or what a finding looks like. 'Recursively' is the only behavioral addition.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the verb and scope are immediately clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter scanner with no annotations and no output schema, the description is thin: an agent cannot tell what the scan returns (findings list? severity? file paths?) or how to interpret results. The well-documented schema partially compensates on inputs but not on outputs.
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%, covering path, exclude, include, and maxFiles with defaults, so the schema does the heavy lifting. The description adds no meaning about path format, globbing behavior, or how include/exclude interact, leaving it at the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (recursively scan), a specific resource (a directory of agent source code), and the target of the scan (memory-poisoning patterns). The 'directory' scope implicitly separates it from scan_text and scan_file siblings, though it never names them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied by the word 'directory' – an agent can infer this is the bulk/filesystem variant and that scan_text/scan_file exist for other inputs, but the description never states when to pick this over the sibling scanners or any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
memory_poisoning_scanner__scan_fileB
Scan a single file for memory-write and memory-readback poisoning patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
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 identifies the detection categories, but says nothing about whether the scan is read-only, whether the file is modified or opened exclusively, what the response contains (findings count, severities, matched lines), or any performance/limits on large files.
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 the action, scope, and threat domain; nothing redundant and nothing padding the front.
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 scanner the target of detection is stated, but with no output schema and no annotations the agent still cannot tell what a result looks like (clean vs. findings, severity, pattern identifiers) or whether the operation is purely read-only.
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?
Only one parameter exists and the schema already documents it at 100% coverage ('Absolute or relative path to the file to scan'). The description adds no syntax, encoding, or path-handling detail 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?
States a specific verb (scan) and resource (a single file) plus the exact threat class it targets: memory-write and memory-readback poisoning patterns. The 'single file' scope implicitly separates it from the scan_text/scan_directory siblings, though it never names them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied by the scope word 'file' — an agent can infer it should call this rather than scan_text or scan_directory when it has a path. There is no explicit when-to-use statement, no prerequisite, and no named alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
memory_poisoning_scanner__scan_textA
Scan agent code for memory-poisoning risks: untrusted input written into persistent, cross-session memory (MemGPT-style archival/core memory, or a vector store used as a long-term knowledge base) without visible sanitization, and memory retrievals fed into a system/assistant-role message or prompt template as trusted context.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full load. It makes clear this is a static content scan and defines the risk classes, but does not state whether code is executed, what findings/severity output looks like, or whether memory references require particular pattern fidelity. Useful risk definition, though behavioral details remain thin.
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 front-loaded sentence beginning with the action and risk name, then elaborating the two patterns. Dense but every clause adds detection specificity; slightly long and unbroken by structure prevents a 5.
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 scanner with no output schema, the description defines the risk surfaces thoroughly enough to know what it will catch. The main missing element is a hint about findings/output shape, but the risk definition compensates well.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and both parameters (content, optional label) are documented in the schema itself, so the description correctly adds no parameter syntax. Baseline 3 applies since the schema already does the work and the description adds nothing param-specific.
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 (scan) and resource (agent code) and then precisely enumerates the two memory-poisoning patterns it detects: unsanitized untrusted input written to persistent cross-session memory, and retrieved memory injected into a trusted system/prompt context. This differentiates it cleanly from sibling scanners like prompt_injection_scanner__scan_text and tool_poisoning_scanner__scan_text.
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 detection scope makes it clear this tool is for code involving archival/core memory or long-term vector knowledge bases feeding prompts, which implicitly routes the agent away from the prompt-injection and tool-poisoning siblings. There is no explicit 'use X instead when Y' statement or note on when not to use it, 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.
model_scanner__list_patternsA
List every dangerous Python global (module.function) this scanner treats as a red flag when found referenced inside a pickled model file, grouped by risk category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden, and it does disclose the key trait: output is grouped by risk category, and the entries are the scanner's own red-flag definitions rather than a scan result. It does not say whether the list is static/complete or permission-gated, but for a zero-param read-only listing the remaining risk is small.
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 no filler; the verb and the subject of the listing are front-loaded, with the pickled-model scope and the grouping qualifier following. Every clause adds 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 zero-param, no-annotation, no-output-schema tool, the description covers what is returned (patterns grouped by risk category) and the context in which those patterns fire. It stops short of hinting at the per-entry fields, which the agent must discover from the response itself.
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 no parameters, so the baseline is 4 and there is nothing for the schema to compensate for. The description adds no parameter meaning because none exists.
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 ('List') plus a precisely scoped resource ('dangerous Python global (module.function)'), and ties it to this scanner's domain ('referenced inside a pickled model file'). That domain framing clearly separates it from the many other *_list_patterns siblings (secret, prompt-leak, DNS, 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?
Usage is only implied: an agent can infer this is a reference/legend call and can be paired with model_scanner__scan_file or scan_directory, but the description never says when to call it versus scanning, nor names any alternative. No explicit exclusions or prerequisites are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
model_scanner__scan_directoryA
Recursively scan a directory for ML model files (.pt, .pth, .ckpt, .pkl, .pickle, .bin, .dill, .joblib, .jbl, .npy, .npz, .safetensors, .h5, .hdf5, .keras, .onnx, .gguf, .pb, .pbtxt, .tflite; a TensorFlow SavedModel directory through its saved_model.pb) and report supply-chain risks in each. Automatically skips node_modules, .git, venv, and other non-model directories.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 2000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It does disclose two genuinely useful behaviors: automatic exclusion of node_modules/.git/venv, and per-file risk reporting (with the 2000-file default living in the schema). It never states that the scan is read-only/non-mutating, says nothing about performance cost or timeouts on large trees, and does not describe the shape of the findings.
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 verb and scope, then the extension list, then the skip behavior. The long enumeration of extensions is verbose but earns its place by telling the agent exactly which artifacts are in scope. Slightly dense in a single 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?
With no output schema and no annotations, the description should explain what a scan returns (findings list? per-file verdicts? severity?), and it only says 'report supply-chain risks in each.' Parameters are fully covered by the schema, so the gap is entirely on the return-value and safety side.
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 description contributes indirectly — the extension whitelist clarifies what the include/exclude substring filters operate against — but it says nothing about how include and exclude interact when both are supplied, nor about the maxFiles truncation consequence.
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 ('Recursively scan a directory'), enumerates exactly which model file types qualify, and calls out the SavedModel-via-saved_model.pb special case. The directory scope makes it trivially separable from model_scanner__scan_file and model_scanner__scan_hf_repo.
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 by the resource type — an agent infers 'use this when you have a local directory, use scan_file for a single artifact.' There is no explicit when-to-use/when-not statement and no mention of the sibling tools by name, though the auto-skip list gives useful operating context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
model_scanner__scan_fileA
Scan a single ML model file for supply-chain risks: dangerous Python globals reachable during pickle deserialization (os/subprocess/eval/socket/dill gadgets, inside PyTorch zip checkpoints, joblib dumps and NumPy object arrays too), a malformed or disguised .safetensors header, a Keras Lambda-layer RCE pattern in .h5/.keras files, a path-traversal external_data reference in .onnx files, malformed GGUF headers and chat templates that escape the Jinja sandbox or carry hidden instructions, and TensorFlow SavedModel/GraphDef/TFLite graphs that read or write files or call Python.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the model file (.pt, .pth, .ckpt, .pkl, .pickle, .bin, .dill, .joblib, .jbl, .npy, .npz, .safetensors, .h5, .hdf5, .keras, .onnx, .gguf, .pb, .pbtxt, .tflite) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden. It richly characterizes what it inspects (pickle globals, safetensors headers, Keras lambdas, onnx external_data, GGUF templates, TF graphs), but never states that it performs static analysis without executing/loading the model, nor describes cost, permissions, or result 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?
The purpose is front-loaded, but the remainder is a single ~90-word run-on sentence stacking format after format, which is hard to parse at a glance. The content earns its place, but the structure could be broken into scannable clauses.
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 should cover return shape and safety posture; it only covers detection scope. An agent knows what is checked but not what a finding looks like or whether the scan has side effects.
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?
Only one parameter and schema description coverage is 100%; the schema already lists every accepted extension. The description's format mentions overlap with the schema rather than adding syntax or path-resolution guidance, 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 and resource ('Scan a single ML model file') and enumerates the concrete risk classes and file formats it covers. 'Single ... file' plus the per-format detector list clearly distinguishes it from siblings like model_scanner__scan_directory and model_scanner__scan_hf_repo.
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 word 'single' implies this is for one file rather than a directory or repo, but the description never explicitly says when to prefer scan_directory/scan_hf_repo or when not to use this tool. Usage is inferable rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
model_scanner__scan_hf_repoA
Scan every model file in a Hugging Face model repo at a pinned commit. The revision (branch, tag or commit sha, default main) is resolved to a commit sha and all files are read from it. Files over 256 MB are checked from their first 64 MB (and last 64 MB for zip containers), which hold the headers and pickle streams the checks read. Gated or private repos need HF_TOKEN in the server's environment.
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | Model repo id, e.g. "openai-community/gpt2" | |
| maxFiles | No | Maximum number of model files to fetch and scan (default: 200) | |
| revision | No | Branch, tag or commit sha (default: main) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does it well: revision resolution to an immutable commit sha, the 256 MB size threshold with first/last 64 MB sampling and why that suffices for headers and pickle streams, and the HF_TOKEN requirement for gated/private repos. These are exactly the operational facts an agent needs before invoking.
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 dense sentences, front-loaded with the core action, and each adds distinct information (pinned commit, sampling limits, auth). Slight cost in that the size-sampling sentence is longer than it needs to be.
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?
Covers fetching, revision pinning, size handling and auth for a three-parameter tool with no output schema or annotations. It never indicates what the scan produces or which checks run, which would help an agent interpret results, but nothing needed 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 the schema already documents repo, maxFiles and revision. The description adds one genuinely new semantic — that revision is resolved to a commit sha and all files are read from it — but says nothing about maxFiles' effect on coverage. 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?
States a specific verb and resource: "Scan every model file in a Hugging Face model repo at a pinned commit." The remote-repo scope implicitly separates it from the sibling scan_file/scan_directory tools that operate on local paths.
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 described scope (a remote HF repo, resolved to a commit sha) makes the use case clear: remote model artifact scanning rather than local file/directory scanning. It never names an alternative sibling or states exclusions, 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.
oauth_auditor__list_patternsA
List every OAuth/token-handling pattern this auditor detects, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden. It does add real behavioral information beyond the name: the result is a complete enumeration ('every pattern') and is 'grouped by category'. What it does not say is whether entries are names only or include descriptions/severities, or that the call is a safe static read.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One front-loaded sentence with the distinguishing domain qualifier in the first few words and zero filler. Nothing could be removed without losing meaning.
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, non-destructive listing tool with no output schema, this is close to sufficient: the agent knows what comes back (patterns, grouped by category). Only the absence of any link to the scan_* siblings and of a sense of output shape keeps it from a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing to disambiguate and the baseline is 4. The description correctly signals that no filtering or scoping input is expected.
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 'List' applied to a concrete resource: 'OAuth/token-handling pattern this auditor detects'. The domain qualifier ('OAuth/token-handling') distinguishes it from the many sibling *_list_patterns tools belonging to other auditors, though it never names those siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use statement, no prerequisites, and no mention of the companion oauth_auditor__scan_text/scan_file/scan_directory tools it logically precedes. That a discovery call should come before scanning is only implied by the verb 'List' and the zero-parameter schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
oauth_auditor__scan_directoryA
Recursively scan a directory of MCP server source for OAuth/token-handling anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that scanning is recursive, but it does not say whether the tool is read-only, what permissions it needs, whether it modifies anything, how results are returned, or how maxFiles affects file traversal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no wasted words. It communicates the action, scope, and target domain immediately.
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 four-parameter scanning tool with no annotations and no output schema, the description is minimally viable but incomplete. The schema fully covers parameters, but the description does not explain the return shape or findings format, which an agent would need to interpret results 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 description coverage is 100%, so the schema already documents path, include, exclude, and maxFiles thoroughly. The description adds no parameter-level detail beyond what the schema provides; the baseline of 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb (recursively scan), a specific resource (a directory of MCP server source), and a specific target problem class (OAuth/token-handling anti-patterns). This distinguishes it clearly from the sibling OAuth scanner tools that scan text or individual files.
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 strongly implied by 'Recursively scan a directory of MCP server source,' which tells the agent the intended input type and context. However, it does not explicitly say when to use this instead of oauth_auditor__scan_file or oauth_auditor__scan_text, nor does it state any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
oauth_auditor__scan_fileB
Scan a single file for OAuth/token-handling anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. 'Scan' reasonably implies a read-only analysis, but the description does not disclose what a scan produces (findings format), whether the file is modified, or performance characteristics. For a low-risk read scan this is acceptable but thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the resource and domain are stated immediately. It is efficient, though it could carry one more differentiating clause without becoming bloated.
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, no-output-schema tool, the description establishes purpose but does not describe what the scan returns or how findings are surfaced (no output schema exists to offload this). This leaves a modest gap for an agent deciding what to expect.
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 single 'path' parameter has 100% schema description coverage ('Absolute or relative path to the file to scan'), so the schema already documents it. The description adds no syntax or format detail beyond that, 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 ('Scan'), resource ('a single file'), and domain ('OAuth/token-handling anti-patterns'). The 'single file' qualifier implicitly distinguishes it from scan_text and scan_directory siblings, though it doesn't name them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the 'single file' scope suggests it is for one file versus a text blob (scan_text) or a tree (scan_directory), but no explicit when-to-use or when-to-avoid guidance is given. The reader must infer routing from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
oauth_auditor__scan_textB
Scan an MCP server's authorization code for OAuth 2.1 anti-patterns named in the MCP spec's own Security Considerations: token passthrough (forwarding a client's token to a downstream API unchanged), missing audience validation on JWT verification, OAuth/OIDC discovery SSRF, missing PKCE, loose redirect_uri validation, and hardcoded client secrets.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden; it discloses the detection scope precisely but says nothing about what a scan returns, whether results include severity/line locations, or any limits. Since this is a purely read-only text analysis of a user-supplied string, the risk surface is low, so this is a moderate rather than severe gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with the verb and resource first, followed by an enumeration that earns its length by telling the agent what categories are covered. Slightly dense but 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?
There is no output schema, so ideally the description would describe the shape of findings (list of findings with pattern, severity, snippet). It is complete about input scope and detection categories but silent on the return value, which an agent needs to interpret results.
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% for both parameters, so 'label' and 'content' are already documented in the schema. The description adds no further guidance on what 'content' should contain (truncation, encoding, size limits), so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Scan') and resource ('an MCP server's authorization code') and enumerates the exact OAuth 2.1 anti-pattern classes detected, which lets an agent distinguish this from generic text scanners like secret_scanner__scan_text. However, it never explicitly contrasts itself with its closest siblings, oauth_auditor__scan_file and oauth_auditor__scan_directory.
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 enumerated checks (use this when auditing OAuth code for token passthrough, PKCE, redirect_uri issues, etc.), giving an agent a reasonable trigger. There is no explicit when-not guidance and no mention of the file/directory siblings as the alternative for non-inline content.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
owasp_scan__list_owasp_coverageA
List OWASP MCP Top 10 categories and which GuardBee scanners cover them in this meta-scan
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 shape of the return conceptually (categories mapped to covering scanners) and 'List' implies a non-mutating read, but it never explicitly states read-only behavior, whether the mapping is static or derived from the current scan configuration, or how large the output is.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler. The resource being enumerated and the coverage mapping are both stated up front, and nothing is repeated.
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 informational tool with no output schema, the description supplies enough to know what comes back (OWASP categories plus scanner coverage) and that no arguments are needed. A brief note on whether the coverage map is static or reflects current scanner availability would close the remaining gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description correctly signals that the call is argument-free by describing a fixed catalog-style lookup.
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 ('List') and a precise resource: OWASP MCP Top 10 categories plus which GuardBee scanners cover them. This clearly separates it from the sibling scan tools (owasp_scan_path, owasp_scan_live, owasp_scan_catalog) because it produces a coverage map rather than a scan result, though it never names those siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'in this meta-scan' hints at the context in which to call it, and a zero-parameter 'list' tool is fairly self-evidently a discovery call. However, there is no explicit when-to-use/when-not guidance and no pointer to the sibling scanners it references, so the agent must infer that this is an orientation step before running an actual scan.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
owasp_scan__owasp_scan_catalogC
Audit a tools/list JSON dump for toxic flows and tool-description poisoning (MCP03/MCP10).
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | ||
| catalog | Yes | JSON string: { tools: [...] } or a bare tools array |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden. It never states that this is a read-only audit, whether it makes network calls or just parses the supplied string, what the response contains (findings, severities, rule IDs), or any limits on catalog size — all material for an unscored mutation-adjacent 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 front-loaded sentence with zero padding; the scope and the threat categories land immediately.
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 pure-audit tool with no output schema, the description should say what the agent gets back (findings, severities, threat IDs) and clarify the `label` parameter. It identifies the input conceptually but leaves the return contract entirely 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?
Only 50% schema coverage and the description mentions no parameters at all. The schema does document `catalog` (JSON string of { tools: [...] } or a bare array), but `label` is undocumented in both schema and description, and the description does nothing to compensate for the gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ("Audit") and resource ("a tools/list JSON dump") plus the exact checks performed (toxic flows, tool-description poisoning) with MCP threat IDs MCP03/MCP10. It is clear what the tool does, but it does not distinguish itself from sibling toxic_flow_auditor__audit_catalog, which appears to overlap heavily.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use / when-not-to-use guidance. Given the crowded sibling set with near-identical candidates (toxic_flow_auditor__audit_catalog, tool_poisoning_scanner__scan_file, mcp_config_auditor__scan_inventory), an agent is left to guess which tool handles a tools/list dump.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
owasp_scan__owasp_scan_liveA
Connect to a live MCP server (stdio or HTTP), call tools/list, then grade toxic-flow + tool-poisoning (MCP03/MCP10).
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | Streamable HTTP MCP URL | |
| args | No | ||
| command | No | stdio command to spawn |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It helpfully discloses the mechanism (opens a connection, calls tools/list, grades results) and the two transports, but does not mention that the 'command' parameter spawns a local process, nor timeouts, auth requirements for HTTP endpoints, or whether the remote server is mutated in any way.
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 the mechanism and grading scope stated first; no filler, no repetition of the tool name.
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 no annotations, so the description is the only source of truth, yet it says nothing about what a 'grade' result looks like, how failures/timeouts on the target server surface, or what args contains. Adequate to select the tool, thin on what to expect back.
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% (url and command documented, args undocumented). The description adds a useful hint by pairing '(stdio or HTTP)' with those transports, but never states the key semantic that url and command are mutually exclusive alternatives, leaving the agent to infer it.
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 chain (connect, call tools/list, grade) against a specific resource (a live MCP server over stdio or HTTP), and names the OWASP categories being graded (MCP03/MCP10). The word 'live' implicitly separates it from owasp_scan_path and owasp_scan_catalog, which operate on stored artifacts rather than a running endpoint.
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 'connect to a live MCP server' implies the usage context (you have a running server to interrogate), but there is no explicit when-not guidance and no named alternative such as 'use owasp_scan_path for local directories' or 'use tool_poisoning_scanner__scan_text for static text'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
owasp_scan__owasp_scan_pathA
Run a unified OWASP MCP Top 10 scan over a filesystem path — orchestrates secret, server, oauth, audit-gap, context-oversharing, toxic-flow, and tool-poisoning auditors; returns A–F grade.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | File or directory to scan | |
| maxFiles | No | ||
| allowlistPath | No | Allowlist file for Shadow MCP discover | |
| discoverShadow | No | Also discover Shadow MCP on this host (MCP09) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations at all, the description carries the full disclosure burden. It does useful work by revealing that this is a compound/orchestration operation rather than a single check and by naming the output shape (A–F grade). It says nothing about runtime cost despite fanning out to seven auditors, whether the scan is read-only, whether results are persisted, or what maxFiles limits do when exceeded.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence with the action front-loaded, the orchestration list in the middle, and the return value last. No filler, no restatement of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-param, no-annotation, no-output-schema tool, the description covers what is scanned, that it is an aggregate, and the output form (letter grade), which is the key information an agent needs. The remaining gap is the optional parameters — especially discoverShadow's host-level side effect — which an agent cannot reason about from the description alone.
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%, just under the high-coverage threshold, and the description adds no parameter meaning at all. The undocumented `maxFiles` (no schema description) and the non-obvious `allowlistPath` / `discoverShadow` semantics — notably that discoverShadow ties to MCP09 host discovery and needs an allowlist — are left entirely to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb+resource+scope: "Run a unified OWASP MCP Top 10 scan over a filesystem path." It then enumerates the auditors it orchestrates (secret, server, oauth, audit-gap, context-oversharing, toxic-flow, tool-poisoning) and the return value (A–F grade), which clearly separates it from the single-purpose sibling scanners like secret_scanner__scan_directory or oauth_auditor__scan_file.
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 word "unified" and "orchestrates" imply this is the one-shot aggregate over many individual auditors, giving clear usage context against ~100 single-scanner siblings. However, it never explicitly states when to choose it over closely related siblings such as owasp_scan__owasp_scan_live, owasp_scan__owasp_scan_catalog, or owasp_scan__list_owasp_coverage, and offers no exclusion criteria (e.g. cost, when a targeted scanner is preferable).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_injection_scanner__list_patternsA
List all indirect prompt injection patterns that the scanner can detect, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 read-only enumeration by saying 'List all ... patterns' and discloses the grouping by category, but it does not state whether patterns include names, descriptions, examples, or any pagination behavior. For a simple list operation this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no wasted words. It states the resource, scope, and return grouping efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter list tool with no output schema, the description explains what is listed and that results are grouped by category. It does not specify the exact return structure, but it is complete enough for an agent to know what to expect.
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, and the empty schema is fully self-documenting. There is no parameter semantics to explain, so the baseline of 4 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 and resource: 'List all indirect prompt injection patterns that the scanner can detect.' It also states the grouping ('by category'). It does not explicitly distinguish this from sibling list_patterns tools for other scanners, but the purpose is otherwise clear.
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: the tool enumerates detectable patterns, which suggests it is useful for discovery before scanning. However, the description does not say when to use it versus prompt_injection_scanner__scan_text, __scan_file, or __scan_directory, nor does it give exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_injection_scanner__scan_directoryA
Recursively scan a directory — e.g. a RAG knowledge base or a corpus of scraped pages — for indirect prompt injection payloads. Automatically skips node_modules, .git, dist, and binary files.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings (e.g. [".md", "knowledge-base/"]) | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It usefully discloses automatic exclusion of node_modules, .git, dist, and binary files — real behavior not in the schema defaults — but says nothing about what a scan returns (findings shape, severity, per-file locations), whether scanning is read-only, or how the automatic skips interact with user-supplied include/exclude.
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, zero filler. The core action and scope lead, and the operational caveat (auto-skipped directories and binaries) follows immediately where an agent will read it.
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 annotations and no output schema, the description is the only source of behavioral and return-value context, and it stops short of describing what a scan produces or how large-result sets are handled. Adequate to invoke correctly given full schema coverage, but not complete for a bulk-scan security 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 all four parameters (path, exclude, include, maxFiles) are already documented with examples and a default. The description adds little beyond implying default exclusions, and it does not clarify precedence when automatic skips conflict with an explicit include.
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 ('recursively scan') and resource ('a directory') plus the detection target ('indirect prompt injection payloads'), so the operation is unambiguous. It doesn't name the sibling tools (scan_file, scan_text) that do the same scan at different granularity, so differentiation is left implicit 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?
The RAG knowledge base / scraped corpus examples give a clear sense of appropriate use, and 'recursively' plus the auto-skip list imply it is for bulk corpora rather than single files. There is no explicit exclusion or pointer to scan_file/scan_text for single inputs, so the agent must infer the boundary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_injection_scanner__scan_fileA
Scan a single file (a knowledge-base document, an HTML page, extracted text) for indirect prompt injection payloads
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
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 adds real behavioral scoping by narrowing the detection target to indirect prompt injection (as opposed to leaks, secrets, or tool poisoning), but it never states that the operation is read-only/non-mutating, whether it can be slow on large files, or what the result looks 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?
A single sentence with the scope constraint and examples packed into a short parenthetical. Zero filler and the key noun (indirect prompt injection) lands at the end for emphasis.
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 should at least hint at what a scan returns (findings, severity, matched patterns) and any file-size or encoding limits. It is adequate to identify the action but leaves the agent guessing about results and constraints.
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?
Only one parameter with 100% schema description coverage ('Absolute or relative path to the file to scan'), so the schema already does the work; baseline is 4. The description's examples of accepted content types add marginal value by hinting at what a valid path may point to.
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 (scan) and resource (a single file) plus the exact threat class targeted: indirect prompt injection payloads. The parenthetical examples (knowledge-base document, HTML page, extracted text) clarify the input domain, and 'single file' implicitly separates it from prompt_injection_scanner__scan_directory, though scan_text is never named.
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: 'single file' suggests it is the right choice when the payload lives on disk rather than in an inline string, but the description never explicitly tells the agent to prefer scan_text for raw strings or scan_directory for trees. No prerequisites or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_injection_scanner__scan_textB
Scan a text string — a RAG chunk, a scraped web page, a document, a tool result — for indirect prompt injection payloads (instruction-override phrases, spoofed chat-template roles, hidden/invisible text, content addressing 'the AI' directly, data-exfiltration attempts) before it reaches a model's context.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. source URL or filename) | |
| content | Yes | The text content to scan |
TDQS
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 usefully discloses what detection signal categories are covered and implies a read-only inspection, but says nothing about return shape (severity, offsets, pattern IDs), latency, or whether it inspects the content only versus any embedded markup.
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 that leads with the action and resource before the parenthetical detail list. No filler, though the long parenthetical of detection categories makes it dense.
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 annotations and no output schema, the description is the only source of behavioral information. It covers what is scanned and why, but leaves the agent guessing about the findings structure and whether a clean result is signalled distinctly from a hit.
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 both parameters ('content', 'label') are described in the schema itself. The description adds nothing about parameter meaning, which is acceptable at full coverage but earns only the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('scan') and resource ('a text string') and then enumerates the exact payload classes it targets (instruction-override, spoofed chat roles, hidden text, exfiltration), which cleanly separates it from the many other *_scan_text siblings. It stops short of naming a sibling or stating an explicit boundary, so it is clear but not fully differentiated.
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 'before it reaches a model's context' gives a usable trigger point, and the input examples (RAG chunk, scraped page, document, tool result) hint at the intended call sites. However, no alternatives are named despite siblings like secret_scanner__scan_text, a2a_auditor__scan_text, and prompt_injection_scanner__scan_file existing, and no when-not-to-use condition is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_leak_scanner__list_patternsB
List every credential/PII pattern this scanner detects, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 read-only enumeration and discloses the grouping by category, but says nothing about whether this is a static catalog vs. dynamic detection, whether it requires configuration, or what a pattern entry contains — thin disclosure for a 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?
A single front-loaded sentence with the verb, scope, and result shape. Nothing redundant and nothing padded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read tool this is close to sufficient, and the category grouping is a useful hint about the return shape. But with no output schema and no annotations, the agent still cannot tell what fields each pattern record exposes (id, regex, severity, description), which is the main remaining gap.
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 and the schema is an empty object, so there is nothing to disambiguate. Baseline 4 applies; the description correctly implies no input is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("List every credential/PII pattern this scanner detects") plus the shape of the result ("grouped by category"). The phrase "this scanner" scopes it to the prompt_leak_scanner namespace, which distinguishes it from the many sibling list_patterns tools, though it never names an alternative explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No statement of when to call this versus the scan_text/scan_file/scan_messages siblings. The use case (inspecting the detector catalog before or after a scan) is inferable from "patterns this scanner detects" but never spelled out, and there are no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_leak_scanner__scan_directoryA
Recursively scan a directory of prompt logs or request-body fixtures for leaked credentials and PII
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
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 two real behavioral traits: the scan recurses into subdirectories, and it is scoped to prompt-log/request-body material. It says nothing about whether files are modified, how findings or truncation are reported, or what happens when maxFiles is reached, which leaves meaningful gaps for an unannotated 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?
One sentence, front-loaded with the action and scope, with zero filler. Nothing is redundant or buried.
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?
Parameter semantics are fully covered by the schema and recursion is stated, but with no output schema an agent still cannot anticipate the return shape (findings list? counts? per-file grouping?) or how include/exclude and maxFiles interact with results. Adequate but not complete for a scanner the agent must interpret output from.
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 all four parameters (path, exclude, include, maxFiles) are documented in the schema itself. 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?
A specific verb ('Recursively scan') plus resource ('a directory') plus target of detection ('leaked credentials and PII'). It implicitly distinguishes itself from scan_file/scan_text siblings via the directory scope, though it never names them; adding 'use scan_file for a single file' would have pushed this to 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 through the material it targets ('prompt logs or request-body fixtures'). There is no statement of when to prefer this over prompt_leak_scanner__scan_file or scan_text, no prerequisites, and no exclusions such as binary or ignored file types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_leak_scanner__scan_fileA
Scan a single file — plain text, or a JSON chat-request-body fixture (auto-detected) — for leaked credentials and PII
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full burden. It usefully discloses that input format detection is automatic and that both credentials and PII are sought, but says nothing about read-only semantics, side effects, size limits, or what the returned findings look like (there is no output schema).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence with the action and detection scope front-loaded and no filler. Every clause (format tolerance, auto-detection, credential/PII targets) contributes 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 one-parameter read-only scanner this is close to adequate, but with no annotations and no output schema the description should say something about the shape of results (findings, severities, counts) or about file-size/encoding limits. That gap matters for an agent deciding whether this tool answers its question.
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?
Only one parameter exists and the schema already documents it at 100% coverage ('Absolute or relative path to the file to scan'). The description adds only the acceptance of either plain text or JSON fixture content, which is a marginal but real addition. 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 (scan), a specific resource (a single file), and the finding classes (leaked credentials and PII), plus a format detail (plain text or JSON chat-request-body fixture, auto-detected). It implicitly separates itself from scan_directory by scoping to one file, but never names the sibling alternatives explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'single file' scope and auto-detection of input format imply when to use this over scan_directory or scan_text, but the guidance is never made explicit. There is no statement of when-not-to-use or what to do for pasted content or whole trees.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_leak_scanner__scan_messagesA
Scan an OpenAI/Anthropic-style chat request body (a JSON object with a messages array and/or a system field) for leaked credentials and PII in every message's text content, before it would be sent to the model.
| Name | Required | Description | Default |
|---|---|---|---|
| body | Yes | The chat request body object, e.g. { model, system, messages: [{ role, content }] } |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully specifies that it scans every message's text content and the system field, but does not say whether the operation is read-only, what the results look like, whether non-text content is ignored, or whether it blocks/returns findings only.
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 that front-loads the input format, the inspection target, and the purpose. Every clause adds useful information 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 nested body object, no output schema, and no annotations, the description does a good job defining what to pass and what gets inspected. It leaves out the return shape and any limitations on structured message parts, but the invocation-relevant context is largely present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and there is one parameter, so the baseline is 3. The description adds meaningful detail beyond the schema: it identifies the expected OpenAI/Anthropic-style shape and clarifies that only message text content is scanned.
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 (scan) and a specific resource (chat request body in OpenAI/Anthropic format), and the purpose (leaked credentials and PII). This clearly distinguishes it from sibling tools that scan raw text, files, or directories.
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 a clear use context: scan before the request would be sent to the model, i.e. a pre-flight check on structured chat payloads. It does not explicitly name alternatives like scan_text or scan_file, but the input scoping makes the intended use clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prompt_leak_scanner__scan_textA
Scan a raw text string (e.g. a prompt you're about to send to an LLM) for leaked credentials (API keys, private keys, JWTs) and PII (TC Kimlik No, credit card, IBAN, email, phone) — checksum-validated where applicable to keep false positives low.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings | |
| content | Yes | The text to scan |
TDQS
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 detection scope and that checks are 'checksum-validated where applicable to keep false positives low' — real behavioral context. But it says nothing about output shape, whether scanned content is retained, or performance/limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence that names the input type first, then the detection categories, then the false-positive mitigation. No filler; every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema and no annotations, so the description is the only source of behavioral detail. It covers detection scope well but leaves the return/findings format entirely unexplained, which an agent would want before invoking a scanner whose whole value is its report.
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% for both parameters, so the schema already explains 'content' and 'label'. The description adds no further parameter guidance (e.g. size limits on content, what label appears in). Baseline 3 applies when the schema does the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource (scan a raw text string) and enumerates what it detects: credentials (API keys, private keys, JWTs) and PII (TC Kimlik No, credit card, IBAN, email, phone). The 'raw text string' phrasing implicitly separates it from scan_file/scan_directory/scan_messages siblings, but no sibling is named explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a use context via the example 'a prompt you're about to send to an LLM,' which implies when to reach for it. However, it never names alternatives such as secret_scanner__scan_text or prompt_injection_scanner__scan_text, nor states when not to use it, leaving the agent to infer routing among several text-scanning siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
rug_pull_detector__baseline_serverA
Connect to an MCP server (stdio command or Streamable HTTP URL), read its current tools/list response, and store it as the trusted baseline for future drift checks. Call this once, right after you've reviewed and approved a server's tools.
| Name | Required | Description | Default |
|---|---|---|---|
| cwd | No | Working directory for the spawned process | |
| env | No | Extra environment variables for the spawned process | |
| url | No | URL of a Streamable HTTP MCP server (alternative to command/args) | |
| args | No | Arguments for the stdio command | |
| label | No | Stable identifier for this server, used to look up its baseline. Defaults to the command line or URL. | |
| command | No | Command to spawn for a stdio MCP server (e.g. "npx") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full behavioral burden. It does disclose the core effect (reads tools/list and persists a baseline) but omits what happens when a baseline already exists for the label, whether the process is spawned with inheritable privileges, and what a failure looks 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 sentences, zero waste, with the action and the timing condition front-loaded. Nothing needs to be read twice.
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 six-parameter, nested-object tool with no output schema, the description leaves the return value and overwrite/duplicate-baseline behavior unstated. It is adequate to attempt a call but not 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 coverage is 100%, so every parameter is already documented. The description adds the useful framing that command/args and url are mutually exclusive alternatives ('stdio command or Streamable HTTP URL') and that label keys the baseline, but goes no further. Baseline 3 applies when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: connect to an MCP server, read its tools/list response, and store it as the trusted baseline. An agent can tell this apart from check_server and list_baselines by the 'store as baseline' framing, though neither sibling is named.
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 a clear trigger: 'Call this once, right after you've reviewed and approved a server's tools.' That is a real when-to-use condition with an implied when-not (not for checking drift). It stops short of naming check_server as the follow-up alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
rug_pull_detector__check_serverA
Connect to an MCP server and compare its current tools/list response against the stored baseline. A tool whose description, schema, or annotations changed since baseline is a 'rug pull' — approved once, silently different now. If no baseline exists yet, one is captured automatically (set autoBaseline=false to require an explicit baseline_server call first).
| Name | Required | Description | Default |
|---|---|---|---|
| cwd | No | Working directory for the spawned process | |
| env | No | Extra environment variables for the spawned process | |
| url | No | URL of a Streamable HTTP MCP server (alternative to command/args) | |
| args | No | Arguments for the stdio command | |
| label | No | Stable identifier for this server, used to look up its baseline. Defaults to the command line or URL. | |
| command | No | Command to spawn for a stdio MCP server (e.g. "npx") | |
| autoBaseline | No | Automatically capture a baseline if none exists yet (default: true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden and discloses a critical side effect: it connects to a server and auto-captures a baseline (a state mutation). It also explains the autoBaseline toggle's consequence. It does not cover process-spawning/networking implications or error/timeout behavior when the server is unreachable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three compact sentences, each earning its place: what it does, what counts as a rug pull, and the baseline-fallback behavior. The core action is 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?
It covers the operation and the important autoBaseline fallback well for a 7-param tool. Since there is no output schema, the description could say more about what the comparison returns (e.g., changed-tool list), but the core callable behavior is well captured.
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 adds value beyond the schema by explaining the runtime consequence of autoBaseline=false (requiring an explicit baseline_server call first), linking the parameter to the sibling tool's workflow rather than just restating the default.
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+resource ('compare its current tools/list response against the stored baseline') and explicitly defines what a 'rug pull' is. It distinguishes itself from the sibling baseline_server tool by explaining the relationship between baselining and checking.
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 clearly specifies the baseline-existence condition ('If no baseline exists yet, one is captured automatically') and names the alternative path via 'set autoBaseline=false to require an explicit baseline_server call first'. It gives clear context but doesn't fully spell out when to prefer check_server over list_baselines or other auditors.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
rug_pull_detector__list_baselinesB
List every server this scanner has a stored baseline for
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It implies a read-only enumeration of stored baselines, which is the right safety signal for a zero-parameter tool, but it doesn't say what happens when no baselines exist (empty list vs error) or what the entries contain.
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 no waste, front-loaded with the verb and scope. Appropriate size for a zero-parameter enumeration 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?
There is no output schema, so the description is the only signal about the return value, yet it doesn't state what a baseline entry looks like (server identity, when captured) or whether the result is paginated. For a trivial list call this is adequate but not 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?
The tool takes zero parameters, so the baseline of 4 applies. There is nothing for the description to disambiguate at the argument level.
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 (list) and resource (stored baselines) with a scope qualifier ('every server this scanner has a stored baseline for'). An agent can distinguish it from rug_pull_detector__baseline_server and check_server by the 'stored baseline' phrasing, though it does not name them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to call this versus baseline_server (create/update a baseline) or check_server (detect rug pulls). The natural 'discover what's covered before checking' workflow is left entirely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
secret_scanner__list_patternsB
List all secret patterns that the scanner can detect
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden, but the operation is a zero-parameter enumeration with low risk, and 'list all ... that the scanner can detect' adequately conveys that it is a read-only catalog dump. It stops short of describing what a pattern entry contains or how patterns relate to the scan tools.
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 tight sentence with no filler, front-loaded with the verb. It is efficient but so terse that it omits routing information that would have cost only a few 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?
For a simple catalog tool with no output schema and no annotations, the description should at least hint at the shape of the returned records (pattern names, categories, IDs usable in scan output). Without that, an agent knows the intent but not what it gets back.
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, which is the baseline-4 case; there is nothing for the description to clarify beyond confirming that the listing is unfiltered ('all').
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 ('List') and resource ('all secret patterns that the scanner can detect'), which is unambiguous on its own. It does not, however, differentiate itself from the many sibling list_patterns tools belonging to other scanners; only the tool name prefix carries that disambiguation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to call this versus secret_scanner__scan_text/scan_file/scan_directory, nor any mention that this is a discovery/introspection call typically run before or alongside a scan. The agent must infer the workflow entirely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
secret_scanner__scan_agent_historyA
Scan the transcripts coding agents keep on this machine (Claude Code, Codex, Gemini CLI, Continue) for secrets that were pasted into a chat or printed by a command. Such a secret was already sent to the model provider and should be rotated. Each secret is reported once with how often it appears.
| Name | Required | Description | Default |
|---|---|---|---|
| entropy | No | Also flag random-looking values assigned to secret-like names (default false here: transcripts hold a lot of code) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full behavioral burden. It does disclose report semantics — each secret appears once with an occurrence count — and the remediation implication, but says nothing about which paths on disk are read, whether access permissions are needed, whether the scan is read-only, or how long it takes on a large history.
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: scope, consequence, and result shape, in that order. Nothing is repeated from the title or schema, and the most decision-relevant fact (which transcripts) leads.
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-required-parameter discovery scan with no output schema, the description covers what is scanned, why it matters, and how findings are deduplicated and counted. The remaining gap is practical detail — the actual transcript locations and whether the scan can be narrowed — but nothing needed to call it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single `entropy` parameter is fully documented in the schema, including its non-default behavior for transcripts. The description adds no interpretation of that flag or of what gets flagged by default, so this is the baseline-3 case where 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 (scan) and a precise, unusual resource scope: the transcripts kept on this machine by named agents (Claude Code, Codex, Gemini CLI, Continue). That scope cleanly distinguishes it from the sibling scan_text/scan_file/scan_directory/scan_git variants, which cover pasted input, arbitrary files, directories, and git history instead.
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 a clear reason to reach for this tool specifically: secrets found here were already sent to the model provider and should be rotated, which is a different remediation posture than scanning a file before commit. It never names an alternative or says when not to use it (e.g., 'for arbitrary directories use scan_directory'), so it stops short of explicit routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
secret_scanner__scan_directoryA
Recursively scan a directory for exposed secrets and API keys. Automatically skips node_modules, .git, dist, and binary files.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| entropy | No | Also flag random-looking values assigned to secret-like names (default true) | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings (e.g. [".env", ".ts"]) | |
| baseline | No | Path to a baseline file: only findings not in it are reported | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden, and it does add real value by disclosing the built-in skip list (node_modules, .git, dist, binaries) — a behavior an agent could not otherwise predict. It stops short of covering what a finding looks like, the file-count ceiling (only in the schema), or whether the built-in skips can be overridden by the exclude parameter.
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, zero filler, with the core capability front-loaded ahead of the secondary skip behavior. Nothing in it could be cut without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Six parameters, no annotations, and no output schema mean the description must explain the result shape, which it does not — an agent learns nothing about what a finding contains or how findings are reported. The scan behavior itself is well covered, so this is adequate rather than complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the six parameters are already documented, and the baseline is 3. The description's mention of automatic skips gives useful context around the exclude/include parameters, but it adds no syntax or precedence information beyond what the schema already says.
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 ("Recursively scan a directory") plus the target of the scan (exposed secrets and API keys), which is far more than a restatement of the name. It doesn't explicitly distinguish itself from the sibling file/text/git variants in the secret_scanner family, relying on the name's scope word to do that work.
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 scope (a whole directory, recursively) implicitly signals when to pick this over scan_file or scan_text, but there is no explicit statement of when to use it, when not to, or which sibling to prefer. An agent must infer the routing decision 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.
secret_scanner__scan_fileC
Scan a single file for exposed secrets and API keys
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan | |
| entropy | No | Also flag random-looking values assigned to secret-like names (default true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it says nothing about whether the scan is read-only, whether the file is opened/read into memory or executed, how large or binary files are handled, or what happens when a secret is found. Only the high-level purpose is disclosed.
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 nine-word sentence with the target resource front-loaded and no filler. It is efficient, though its brevity is part of why other dimensions are thin.
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 are no annotations and no output schema, so an agent gets no indication of what a scan returns (findings list? locations? severity?) or whether the operation has any side effects. For a security-scanning tool with a configurable detection flag, the description is under-specified.
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 `path` and `entropy` are already documented in the schema, including the default for `entropy`. The description adds no extra semantics such as accepted path forms, behavior on missing files, or what enabling entropy detection costs in false positives, so it stays at the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Scan a single file for exposed secrets and API keys') and the word 'single file' implicitly separates it from secret_scanner__scan_directory. It does not, however, distinguish it from secret_scanner__scan_text or scan_git, which target the same secret-detection goal via different inputs.
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 or when-not-to-use guidance is given. The agent must infer from the tool name alone that this is for an on-disk file path versus pasted content (scan_text) or a repository history (scan_git); no alternative is named or recommended.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
secret_scanner__scan_gitA
Scan a git repository for secrets in what git says was added: the staged changes (before a commit) or every commit's added lines (history). History finds secrets that were deleted from the files but are still in the repository.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | Yes | staged: lines added in the index; history: lines added by each commit | |
| path | Yes | A directory inside the git repository | |
| range | No | History only: a revision range such as main..HEAD (default: all refs) | |
| entropy | No | Also flag random-looking values assigned to secret-like names (default true) | |
| baseline | No | Path to a baseline file: only findings not in it are reported | |
| maxCommits | No | History only: stop after this many commits |
TDQS
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 usefully discloses the scan basis — only added lines per git's view, not deletions or the working tree as-is — which prevents wrong expectations. It does not say anything about read-only safety, cost/performance on large histories, or the shape of the response, leaving real 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?
Two sentences, front-loaded with the scope constraint before the mode explanation. No filler or restatement of the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter tool with full schema coverage and no output schema, the description covers the core decision (which mode and why) and the scanning semantics well. It leaves unaddressed the baseline-file workflow, the entropy default's effect, and limits on large repositories, which are the remaining things an agent might need.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and each parameter is already documented inline, including the mode enum. The description reinforces why history mode matters but adds no syntax or interaction detail (e.g. how baseline, entropy, or maxCommits behave in combination), so the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (scan) plus resource (a git repository) and narrows the scope to 'what git says was added', which separates it from the file/directory/text scanners in the sibling list. The parenthetical on staged vs history modes makes the operation 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?
It gives a clear rule for choosing between the two modes and motivates history mode ('finds secrets that were deleted from the files but are still in the repository'). It never names an alternative sibling tool (e.g. scan_directory for plain working-tree scanning) or states when this tool should not be used, so it stops 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.
secret_scanner__scan_textB
Scan a text string or code snippet for exposed secrets and API keys
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The text content to scan | |
| entropy | No | Also flag random-looking values assigned to secret-like names (default true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden, and it delivers almost nothing beyond the one-line purpose. It does not state that the operation is non-mutating, what a finding looks like, whether severity/confidence is reported, or how large inputs are handled.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single well-formed sentence with the resource and detection target front-loaded and no filler. It is efficient, though its brevity reflects under-specification rather than disciplined editing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations and no output schema, the description is the only place an agent could learn what the tool returns, and it says nothing about findings, their structure, or their format. For a 3-parameter detection tool that gap leaves the agent guessing about results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters (content, label, entropy) are already documented, including the entropy default of true. The description adds no meaning beyond that, which is the baseline case when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific verb (scan) and resource (a text string or code snippet) plus the target of detection (exposed secrets and API keys). The input-type framing implicitly distinguishes it from sibling scan_file/scan_directory, but it never names those alternatives explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'text string or code snippet' implies the usage context (inline content rather than a file path), but there is no explicit when-to-use/when-not guidance and no pointer to scan_file or scan_directory for other inputs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
slopsquat_scanner__check_packageB
Check a single package name against the real npm or PyPI registry
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Package name | |
| ecosystem | Yes | Which registry to check |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. Saying 'the real ... registry' hints at a live network call, but nothing is said about rate limits, what happens for a non-existent or unreachable registry, whether results are cached, or what 'check' actually evaluates (existence alone versus typosquat/hallucination risk).
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 no filler or redundancy. It is efficient, though so terse that it leaves the tool's actual output and behavior underexplained rather than being genuinely complete.
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 simple required parameters and full schema coverage, the low complexity keeps a minimal description viable. However, with no output schema and no annotations, the description should at least indicate what a 'check' returns (existence verdict, risk score, advisory) and is silent on that.
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% with an explicit enum for ecosystem, so the schema already documents both parameters fully. The description merely echoes them ('package name', 'npm or PyPI') without adding naming rules, scoped-package syntax, or case sensitivity.
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 ('check') plus resource ('a single package name') and scope ('against the real npm or PyPI registry'), which implicitly separates it from the bulk siblings scan_npm/scan_pip/scan_directory. It stops short of naming those siblings, so an agent must infer the boundary from the word 'single'.
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: 'single package name' signals one-off lookups versus the directory/registry-wide scans in the same family. There is no explicit when-to-use, when-not-to-use, or pointer to scan_npm / scan_pip for bulk work.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
slopsquat_scanner__scan_directoryB
Auto-detect and check both npm and pip manifests (package.json, requirements.txt, pyproject.toml) in a directory against their real registries
| Name | Required | Description | Default |
|---|---|---|---|
| directory | Yes | Path to the project root directory |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It does usefully disclose two traits: automatic detection (so missing manifest types are tolerated) and live lookups 'against their real registries', which signals outbound network calls. It does not disclose what findings look like, timeout/failure behavior, or whether the operation touches anything on disk.
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 with zero filler, and the key differentiator (both npm and pip) is front-loaded. Slightly over-packed with parenthetical file lists but still 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?
For a tool with no annotations and no output schema, the description covers the 'what' and enough of the 'how' (auto-detect, registry lookup) to call it, but leaves return shape and partial/error results unexplained. Adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter is fully documented as 'Path to the project root directory'. The description reinforces that the directory is a project root by naming the manifest files it looks for, but adds no format, path-style, or recursion details beyond the schema. 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 action (auto-detect and check manifests) against a specific resource (npm/pip manifests in a directory), and the explicit file names (package.json, requirements.txt, pyproject.toml) make the scope unambiguous. It is implicitly distinguished from scan_npm, scan_pip, and check_package by covering both ecosystems across a whole directory, but it never names those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied rather than stated: use it when you have a project root containing one or both manifest types. There is no explicit 'use this instead of scan_npm/scan_pip when...' guidance, and no mention of what happens when no manifest is found.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
slopsquat_scanner__scan_npmA
Check every dependency declared in a package.json (dependencies, devDependencies, peerDependencies, optionalDependencies) against the real npm registry -- flags any package name that doesn't exist at all (a likely LLM-hallucinated dependency an attacker may have pre-registered, i.e. 'slopsquatting'), and separately notes any that exist but were only first published very recently.
| Name | Required | Description | Default |
|---|---|---|---|
| directory | Yes | Path to the directory containing package.json |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden, and it does disclose useful behavior: it queries the live npm registry (implying network I/O) and reports two distinct finding categories. It stops short of stating prerequisites (package.json must exist at the path), failure behavior on registry errors or private/unpublished scoped packages, or performance/rate considerations for large manifests.
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, front-loaded with the action and resource before the parenthetical explanation of slopsquatting. The em-dash aside is informative rather than padding, though the sentence is long enough that a reader must re-parse it once.
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 scanner with no annotations and no output schema, the description explains what is being checked and what kinds of issues are surfaced, which is the essential context. It omits how findings are reported and what the agent should do with a 'recently published' warning, leaving a gap for a security tool whose output drives decisions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is a single parameter with 100% schema description coverage ('Path to the directory containing package.json'), so the schema already does the work. The description adds only the implicit constraint that a package.json must live in that directory, which is a marginal gain, so the baseline of 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 names a specific verb and resource ('Check every dependency declared in a package.json') and states the exact detection goal — non-existent package names ('slopsquatting') plus recently-first-published packages. The explicit mention of 'npm registry' and package.json cleanly separates it from slopsquat_scanner__scan_pip and the directory/package-level siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The scope ('every dependency declared in a package.json') implies this is the whole-manifest npm scan as opposed to the single-package check_package or the generic scan_directory, but no alternative is named and no when-not-to-use condition is given. An agent must infer the routing from the tool name and sibling names rather than from the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
slopsquat_scanner__scan_pipA
Check every dependency declared in requirements.txt or pyproject.toml against the real PyPI registry -- flags any package name that doesn't exist at all (a likely LLM-hallucinated dependency an attacker may have pre-registered), and separately notes any that exist but were only first published very recently.
| Name | Required | Description | Default |
|---|---|---|---|
| directory | Yes | Path to the directory containing requirements.txt or pyproject.toml |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses the two finding categories (nonexistent package names, and packages first published very recently) and the underlying intent (LLM-hallucinated deps pre-registered by attackers). It does not disclose that the check requires network access to PyPI, whether it is read-only, rate-limit behavior, or how findings are shaped.
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, front-loaded with the action and the target files, then the two outcome classes. Slightly dense with the parenthetical explanation, but no filler sentences.
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, no-annotation, no-output-schema tool, the description covers what is scanned and what gets flagged, but leaves the return shape and the network/registry dependency unstated. An agent knows when to call it but not what to expect back.
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% for the single 'directory' parameter, and the description reinforces which files it looks for inside that directory, so the agent knows the expected layout. It adds a small amount of meaning beyond the schema but nothing about behavior if both files are present.
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 (check declared dependencies against PyPI) and names the input artifacts (requirements.txt, pyproject.toml). It also names the two distinct finding classes, so it is clearly distinguishable from slopsquat_scanner__scan_npm and dependency_auditor__audit_pip.
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 file scope (pip projects only), but there is no explicit when-to-use guidance and no routing to siblings such as slopsquat_scanner__check_package for a single package or scan_npm for Node projects. The agent must infer the boundary from the ecosystem name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ssl_inspector__check_cert_expiryB
Check certificate expiry for one or more domains and highlight certificates expiring soon
| Name | Required | Description | Default |
|---|---|---|---|
| hosts | Yes | Domain names to check | |
| warnDays | No | Warn if expiring within this many days (default: 30) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full behavioral burden, yet it says nothing about live network connections, timeouts, rate limits, behavior on unreachable hosts, or partial failure across multiple domains. 'Highlight certificates expiring soon' hints at result shaping but is 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?
A single front-loaded sentence with the scope and the threshold-highlighting behavior stated first; no filler. Slightly compressed to the point of underspecification rather than maximally informative.
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 annotations and no output schema, the description must explain return shape and multi-host failure handling, and it does not. Adequate for identifying the tool, insufficient for predicting what an agent will get back from a bulk check.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and both parameters are documented, including the warnDays default of 30. The description does not add syntax or semantics beyond 'one or more domains' and the vague 'expiring soon', 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 and resource ('Check certificate expiry for one or more domains') plus the added signal of flagging near-expiry certs. It is not explicitly distinguished from sibling ssl_inspector__get_cert_info or inspect_ssl, though the expiry-only focus is implied.
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, and no mention of when to prefer this over get_cert_info or inspect_ssl_bulk. The domain-expiry framing implies usage but leaves alternative selection to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ssl_inspector__get_cert_infoB
Get detailed certificate information for a domain including fingerprint, SANs, and issuer chain
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Domain to inspect | |
| port | No | Port (default: 443) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It does disclose the returned content (fingerprint, SANs, issuer chain), which is useful given there is no output schema, but says nothing about making a live TLS connection, timeout/failure behavior on unreachable hosts, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler or redundancy. It is arguably too sparse for a network-facing tool, but as a structural matter it wastes nothing.
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?
Without an output schema, the description should describe return shape; it partially does via the field enumeration. However, it omits disambiguation from near-identical siblings and any failure/edge-case behavior, leaving meaningful gaps.
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% — both 'host' and 'port' (default 443) are documented in the schema. The description adds only the implicit notion of 'domain' as the host, which is baseline at best.
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 ('Get detailed certificate information for a domain') plus the fields returned (fingerprint, SANs, issuer chain). It does not distinguish itself from close siblings such as ssl_inspector__inspect_ssl or check_cert_expiry, so an agent cannot tell from the description which of the three to pick.
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 versus inspect_ssl, inspect_ssl_bulk, or check_cert_expiry, and no prerequisites (e.g. reachable host, port open) are stated. The agent must infer usage entirely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ssl_inspector__inspect_sslA
Inspect TLS certificate, cipher suite, and protocol configuration for a single domain
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Domain name or IP to inspect (e.g. example.com) | |
| port | No | Port to connect to (default: 443) | |
| probes | No | Extra handshakes to find what the server still accepts: TLS 1.0/1.1, RSA key exchange, weak DH, weak ciphers (default: true) | |
| checkHsts | No | Also check HSTS header via HTTP HEAD (default: true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of disclosure. It implies a read-only network inspection but never states that it opens connections to the remote host, whether it can time out, or that the 'probes' option performs additional handshakes against the target (that detail lives only in the schema). Adequate but missing real behavioral context.
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 that names the verb, the checked resources, and the scope with zero filler. Nothing redundant or padded.
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 an inspection tool with no annotations and no output schema, the description says nothing about what the results look like (findings, grades, raw cert fields) or whether the scan is passive. The fully documented params compensate partially, but the return shape and behavioral envelope remain undocumented.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters (host, port, probes, checkHsts) are already well documented, including defaults and the meaning of probes. The description adds no parameter-level meaning beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Inspect) and enumerates the resources examined: TLS certificate, cipher suite, and protocol configuration. The phrase 'for a single domain' implicitly distinguishes it from the ssl_inspector__inspect_ssl_bulk sibling, though it never names that sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied by the 'single domain' scoping — an agent can infer that multiple domains should go to inspect_ssl_bulk. There is no explicit when-to-use, when-not, or mention of the other SSL siblings (check_cert_expiry, get_cert_info) that overlap in purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ssl_inspector__inspect_ssl_bulkB
Inspect TLS configuration for multiple domains in parallel
| Name | Required | Description | Default |
|---|---|---|---|
| port | No | Port to use for all domains (default: 443) | |
| hosts | Yes | List of domain names to inspect | |
| probes | No | Run the legacy-protocol and weak-cipher probes for each domain (default: false; 8 extra handshakes per domain) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden, yet it discloses only one trait: parallel execution. It says nothing about network/auth requirements, timeout or partial-failure behavior (what happens when one domain fails), rate limiting, or what the per-domain output looks 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?
A single tight sentence with the key scoping fact ('multiple domains in parallel') front-loaded and zero waste. It is efficient, though the brevity contributes to the gaps in behavioral detail rather than being purely a virtue.
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 network-touching tool with three parameters, no annotations, and no output schema, the description leaves too much unexplained: what 'TLS configuration' covers, whether results are per-domain error objects or aggregated, and how failures are reported. The schema covers inputs, but the tool's behavior and return shape are undocumented.
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 hosts, port, and probes are already fully documented, including the probe cost (8 extra handshakes per domain). The description adds nothing about parameter semantics beyond restating 'multiple domains', so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (inspect TLS configuration) with an explicit scope qualifier (multiple domains, in parallel), which implicitly separates it from the single-domain sibling inspect_ssl. It stops short of naming the sibling outright, but an agent can still tell the bulk variant from the single-target one.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: 'multiple domains' signals this is for batch work while inspect_ssl handles one host. There is no explicit when-to-use/when-not, no guidance on choosing between this and check_cert_expiry or get_cert_info, and no advice on list size or batching.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threat_rules__evaluate_eventC
Evaluate a structured ATR AgentEvent JSON (type, content, fields, sessionId, …).
| Name | Required | Description | Default |
|---|---|---|---|
| lane | No | ||
| event | Yes | JSON AgentEvent: { type, content, fields?, sessionId?, agentId?, scanContext? } | |
| format | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does not disclose that this is a read/analysis operation, whether any rule can block or mutate anything, or what the response contains. Most critically, it is silent on the 'lane' values enforce/alert/hunt, where 'enforce' clearly implies consequence-bearing behavior that an agent must understand before calling.
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?
It is a single front-loaded sentence with no padding, which is good, but it is so short that it reads as truncated (trailing '…') rather than deliberate. Brevity here comes at the cost of needed detail rather than from efficient editing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 3-parameter tool with no annotations, no output schema, and two undocumented enum parameters, the description is far too thin. An agent cannot tell the return format, the effect of lane selection, or when to prefer this over the sibling evaluate_* tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is only 33%: 'lane' and 'format' have no descriptions, and the description adds nothing about either despite both being enums with meaningful choices. The parenthetical (type, content, fields, sessionId, …) merely restates what the 'event' parameter's schema description already says, so no new semantic value is added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('Evaluate') and a specific resource ('structured ATR AgentEvent JSON'), and even sketches the payload shape. It is clear what the tool acts on, but it never says what 'evaluate' means in practice (which rule set runs, what the verdict looks like) and gives no hint of how it differs from the sibling threat_rules__evaluate_text / evaluate_file.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no indication of when to pick this over threat_rules__evaluate_text, threat_rules__evaluate_file, or threat_rules__list_rules. The only implicit cue is that the input is an AgentEvent object, which the caller must infer rather than being told explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threat_rules__evaluate_fileC
Read a local file and evaluate its contents against ATR + GuardBee rules
| Name | Required | Description | Default |
|---|---|---|---|
| lane | No | ||
| path | Yes | Path to a text file (max 2MB) | |
| type | No | ||
| format | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden and mostly doesn't. 'Read a local file' implies a non-mutating operation, but the description says nothing about the 2MB limit beyond the schema, what the lane setting does to enforcement behavior, permission requirements, or what a result looks like (no output schema exists).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with no filler and the key verb/resource front-loaded, which is structurally sound. But the terseness is under-specification rather than disciplined brevity for a tool with four parameters and three opaque enums.
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 annotations, no output schema, and 25% schema coverage mean the description must explain more, yet it omits the lane/type/format semantics and the shape of findings. An agent could invoke it with just a path but would be guessing at the meaning of the three optional parameters and at what comes back.
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 25% – only 'path' is documented – and three enum parameters (lane, type, format) have no explanation anywhere. The description adds zero parameter meaning, so the agent must guess whether lane='enforce' vs 'hunt' changes the evaluation, and how 'type' or 'format' alter behavior or output.
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 (evaluate) and a specific resource (a local file's contents) and names the rule sets applied (ATR + GuardBee), so the operation is unambiguous. It does not, however, distinguish itself from the near-identical sibling threat_rules__evaluate_text, leaving the file-vs-text split implicit.
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 versus alternatives. Given the sibling set contains threat_rules__evaluate_text plus dozens of other *_scanner__scan_file tools, an agent gets no criteria for choosing this one, and no prerequisites or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threat_rules__evaluate_textC
Evaluate free text against Agent Threat Rules (ATR) plus GuardBee KVKK/TR rules. Returns matches with follow-up scanner hints.
| Name | Required | Description | Default |
|---|---|---|---|
| lane | No | Detection lane (default: hunt) | |
| type | No | ATR event type (default: llm_input) | |
| format | No | ||
| content | Yes | Text to evaluate | |
| scanContext | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description bears the full burden. It discloses that matches are returned with follow-up scanner hints, which is useful, but says nothing about the enforce/alert/hunt lane semantics, whether evaluation has side effects, or how the different rule sets interact — large gaps for a zero-annotation 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?
Two tightly packed sentences with zero waste; the core action and return shape are front-loaded. It is efficiently sized for what it covers, though this terseness contributes to the completeness gaps.
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 five-parameter tool with four enums, no annotations, and no output schema, the description is too thin. It never explains the detection lanes, event types, output formats, or what 'follow-up scanner hints' concretely means, so an agent lacks enough context to invoke it confidently.
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 60% and the description adds no meaning for any of the five parameters. The crucial 'lane' (enforce/alert/hunt) and 'type' enums are left unexplained, so the agent gets no help understanding what those values actually change about behavior.
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 (Evaluate) and resource (free text) and names the rule sets (Agent Threat Rules plus GuardBee KVKK/TR) it applies, which conveys real specificity. The 'text' in the name distinguishes it from siblings like evaluate_file and evaluate_event, but the description never says so explicitly, nor how it differs from the many other *_scan_text 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?
No when-to-use guidance is given. With siblings evaluate_file and evaluate_event and dozens of competing scan_text tools, the description offers nothing to route the agent between them, leaving selection entirely to inference from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threat_rules__explain_bridgeB
Explain how Agent Threat Rules (ATR) complements GuardBee static MCP auditors
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden; it implies a read-only informational tool but never states that there are no side effects, no required credentials, or that the result is static documentation text rather than computed analysis. It is adequate for a trivial explainer but adds no explicit behavioral guarantees.
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. Nothing is wasted, though nothing beyond the core claim is included either.
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 no annotations, so the description should indicate what the caller receives (e.g., a prose/markdown explanation of ATR vs. GuardBee coverage) and roughly when it is worth calling. For a zero-arg informational tool the gap is minor but real.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 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 ('Explain') and a specific subject ('how Agent Threat Rules (ATR) complements GuardBee static MCP auditors'), so the agent knows this is a conceptual/positioning explainer rather than a scan or list. It does not, however, differentiate itself from siblings like threat_rules__framework_map or threat_rules__rule_stats, which could also be consulted for 'how does this fit together' questions.
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, no when-not-to-use, and no mention of alternatives such as framework_map for framework mapping or list_rules for rule inventory. The agent must infer the context from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threat_rules__framework_mapA
Show how GuardBee's runtime findings map to OWASP Top 10 for LLM Applications (2025) and MITRE ATLAS — the mapping guardbee-proxy report uses
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It implies a static, read-only reference lookup with no inputs, but does not state that it is side-effect free, whether the mapping is static or derived from a prior scan, or what the result looks 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?
A single front-loaded sentence with the frameworks named early and the proxy-report context in a trailing clause; nothing is wasted. The only cost is mild ambiguity in 'runtime findings,' which could be read as an input the tool does not actually accept.
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 is the only source of return-value information, and it gives just a high-level notion of a mapping table. For a zero-param reference tool that is close to adequate, but an agent cannot tell the granularity of the mapping or whether findings must exist first.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing to disambiguate; baseline 4 applies. The empty schema is consistent with the description's implication that the mapping is a fixed reference rather than a query.
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: it shows how GuardBee runtime findings map to two named frameworks (OWASP Top 10 for LLM Applications 2025, MITRE ATLAS). The scope is clear enough to separate it from evaluation tools like threat_rules__evaluate_event, but it does not explicitly distinguish itself from nearby reference tools such as owasp_scan__list_owasp_coverage or compliance_checker__compare_frameworks.
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 it is for looking up framework attribution after findings exist, but the description never says when to call it, what prerequisite state is needed, or which sibling to use instead. The clause about the guardbee-proxy report gives context but not selection guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threat_rules__list_rulesC
List loaded ATR + GuardBee detection rules (optionally filter by category or source).
| Name | Required | Description | Default |
|---|---|---|---|
| lane | No | ||
| source | No | ||
| category | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full behavioral burden. It does not state that the operation is read-only, what the return value looks like, whether results are paginated, or how the lane parameter (present in the schema) affects behavior. It also omits the lane filter entirely, which is a meaningful gap given three schema parameters and no 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?
A single front-loaded sentence that states the core action and optional filters without filler. It is appropriately sized, though it could have used the same space to mention the lane filter instead of leaving it out.
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 annotations, no output schema, and 0% schema description coverage across three enum parameters, the description is too thin. It omits the lane filter and says nothing about the return shape or read-only nature, which an agent needs for confident 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 must compensate. It only mentions filtering by 'category or source' and completely omits the lane parameter and its enforce/alert/hunt semantics. The enums are somewhat self-explanatory in the schema, but the description does not add any meaning beyond naming two of three filters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('List') and resource ('loaded ATR + GuardBee detection rules'), which clearly distinguishes it from the evaluate/explain siblings in the threat_rules family. It does not explicitly differentiate itself from rule_stats, which likely also reports on rules, but the listing purpose is clear enough.
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 the tool lists loaded rules and that filtering by category or source is optional, which implies a discovery/inventory use case. However, it gives no explicit when-to-use guidance versus rule_stats, evaluate_event, or the many list_patterns tools in sibling scanners, leaving the selection logic implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
threat_rules__rule_statsB
Summarize loaded rule counts by category and source (ATR vs GuardBee)
| Name | Required | Description | Default |
|---|---|---|---|
| lane | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden, and it does disclose the returned content shape (counts grouped by category and source). However, it says nothing about whether rules must be loaded first, whether the result is filtered, or any behavioral edge cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with zero filler. It is efficient, though brevity here edges toward under-specification rather than tight completeness.
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 is simple (one optional param, no output schema), so the description does not need much, but the unexplained `lane` filter and the absence of any relation to list_rules/framework_map leave gaps an agent must guess at.
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% and the description never mentions the single `lane` parameter. The enum values enforce/alert/hunt are self-describing in isolation, but the description does not say whether lane filters the counts or how it interacts with the summary.
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 ("Summarize") and resource ("loaded rule counts") with an explicit grouping dimension (category and source, ATR vs GuardBee). It is clearly distinguishable from sibling list_rules, but the description never names that sibling to reinforce the split.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer this is the aggregation/overview tool versus list_rules or evaluate_event, but there is no explicit statement of when to call it or when not to. No prerequisites or routing guidance are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tool_poisoning_scanner__list_patternsA
List every description-injection phrase and confused-deputy sink rule this scanner detects
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden; it does disclose the scope of what is enumerated (phrase rules plus sink rules), which is useful. It does not say whether this is a read-only, side-effect-free lookup or what the returned entries contain, leaving the behavioral picture thin for an annotation-free 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 sentence with no filler, front-loaded with the verb and the two concrete rule categories. Every word 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 zero-parameter catalog tool with no output schema and no annotations, the description should indicate what an entry looks like (pattern id, name, description) or whether IDs can be reused with the scan tools. It conveys scope but not the shape or downstream use of the output.
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 the baseline is 4 and there is no parameter semantics for the description to compensate for. Nothing in the schema is left unexplained.
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 (List) and a specific resource (the detection patterns/rules this scanner uses), and it names the two rule categories — description-injection phrases and confused-deputy sinks. This clearly separates it from the sibling scan_text/scan_file/scan_directory tools, which run scans rather than enumerate the catalog.
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 intent of listing the rules is implied — inspect coverage before or after scanning — but the description never says when to call this instead of tool_poisoning_scanner__scan_text or the other list_patterns tools in sibling scanners. Usage is inferable, not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tool_poisoning_scanner__scan_directoryB
Recursively scan a directory of MCP server source for tool-poisoning and confused-deputy patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Recursively scan' does disclose traversal behavior, but nothing is said about read-only safety, what the results contain, or what happens with large trees despite a 5000-file default cap in the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with zero filler; the verb, scope, and detection targets appear immediately.
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?
Four parameters with no annotations and no output schema mean the description must place more weight on return-shape and safety expectations. It covers what is scanned and why, but leaves result structure and operational cost 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 description coverage is 100%, so the schema already documents path, include, exclude, and maxFiles. The description adds no extra meaning about path resolution, filter precedence (include vs exclude), or scan-cost implications, 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 (recursively scan) and resource (a directory of MCP server source), plus the exact threat classes targeted (tool-poisoning, confused-deputy). The word 'directory' implicitly separates it from scan_file/scan_text, but it never names those siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the 'directory of MCP server source' framing, so an agent can infer this is the directory-wide variant of the family. There is no explicit when-to-use, when-not-to-use, or named alternative (e.g. scan_file for a single server, list_patterns for coverage).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tool_poisoning_scanner__scan_fileA
Scan a single file for tool-poisoning and confused-deputy patterns in MCP tool registrations
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full behavioral burden. 'Scan' reasonably implies a read-only operation, but nothing is said about output (findings list, severity, empty-result behavior) or whether the file is ever modified, leaving most traits undisclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the scanned resource and the target pattern classes both appear immediately.
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 scanner with a fully described schema and no output schema, the description covers what the tool does and what it looks for. Only the shape of the result and the accepted file types are left implicit.
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?
Only one parameter, and the schema already documents it at 100% coverage ('Absolute or relative path to the file to scan'). The description adds no constraint such as supported file types or whether a directory path is rejected.
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 ('scan') and resource ('a single file') plus the exact pattern classes it hunts for (tool-poisoning, confused-deputy). The word 'single' implicitly separates it from sibling scan_directory and scan_text in the same 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?
Usage is only implied by the tool name and the word 'single file' – an agent can infer that scan_text is for inline content and scan_directory for whole trees, but the description never says so or states prerequisites (e.g., file must contain tool registration JSON).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tool_poisoning_scanner__scan_textB
Scan MCP server source (TypeScript/JavaScript, Python, Go) for tool poisoning (hidden instructions embedded in a tool's description string, read by the calling LLM as trusted context) and confused-deputy tools (a name/description promising read-only behavior while the handler has a shell/eval/file-write/env-dump sink).
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename); its extension picks the language | |
| content | Yes | The source code to scan | |
| language | No | Source language, when the label has no extension (default: typescript) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full load: it discloses the detection semantics (what patterns count as poisoning vs. confused deputy) which is genuine added value. However it never states that this is a non-mutating local analysis, whether findings include severities/line numbers, or any limits on input size, so an agent cannot predict the response shape.
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; every clause defines a threat class or a supported language. It is dense with nested parentheticals, which slightly slows parsing, but 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?
Purpose and input languages are well covered, but with no output schema and no annotations, the description should say more about what a finding looks like (rule IDs, severity, location) and point to scan_file/scan_directory for multi-file audits. An agent knows what the tool detects but not what it returns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters (label, content, language) are already documented in the schema, including the extension-based language inference and the typescript default. The description only echoes the supported language list, adding nothing beyond the enum. 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 (scan) and resource (MCP server source in TS/JS, Python, Go) plus the exact threat classes detected: tool poisoning via hidden instructions in a tool's description string, and confused-deputy tools whose name/description promises read-only while the handler has a shell/eval/file-write/env-dump sink. These definitions distinguish it from generic siblings like prompt_injection_scanner__scan_text or ai_code_scanner__scan_text without needing to name them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description never says when to use this versus scan_file or scan_directory, nor does it state prerequisites (e.g. that 'content' must be raw source, not a path). The scan_text/scan_file/scan_directory naming convention implies the split, but the description itself gives no routing guidance or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
toxic_flow_auditor__audit_catalogA
Audit a tools/list-shaped JSON catalog for the lethal trifecta (toxic flow): untrusted content + sensitive/private data + exfiltration or destruction on the same MCP server. Returns an A–F grade.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label for the server/catalog | |
| catalog | Yes | JSON array of tools, or { tools: [...] } from tools/list |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden and does so reasonably: it states what is detected (three co-occurring properties) and what is returned (an A–F grade). It stops short of explaining the grading criteria or confidence, but the behavioral profile is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences: the detection target and the return value. Front-loaded with the purpose and 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?
For an audit tool with no output schema and no annotations, the description covers purpose, detection basis, and return type adequately. It leaves the grade's meaning and any severity breakdown unexplained, a minor gap given the absent 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?
Schema description coverage is 100%, so both 'catalog' and 'label' are already documented. The description reinforces the catalog shape (tools/list-shaped) but adds no syntax or format detail beyond the schema, so the baseline of 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 (Audit) and resource (a tools/list-shaped JSON catalog) and names the concrete threat model (lethal trifecta). It is clearly a catalog-level audit rather than file/directory scanning, though it doesn't explicitly name its siblings to differentiate.
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: hand it a tools/list catalog when you have one. But there is no explicit when-to-use/when-not guidance, no mention of when to prefer scan_file/scan_directory/scan_source instead, and no prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
toxic_flow_auditor__explain_trifectaA
Explain the lethal trifecta / toxic-flow model this auditor uses
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 pure informational read with no side effects, but never says so explicitly, nor whether the explanation is static reference text or derived from configuration. For a zero-parameter tool the risk is low, but the disclosure is thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler or restated metadata. Every word carries information; nothing is padded.
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 no annotations, so the description is the only source of truth, and it does not say what the agent receives (prose explanation, structured findings, pattern identifiers) or how the result relates to audit_catalog and list_patterns. Adequate to identify the tool, insufficient to set expectations for its result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No misleading hints about inputs are given.
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 ('explain the lethal trifecta / toxic-flow model') and scopes it to 'this auditor', which clearly separates it from the sibling scan_* and list_patterns tools in the same family. An agent can tell this is a documentation/explanation tool rather than a scanner 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 only implied: an agent would infer it should call this before or alongside scans to understand what the auditor detects. There is no explicit 'call this when...' statement, no mention of list_patterns or audit_catalog as related alternatives, and no note on whether it must precede a scan.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
toxic_flow_auditor__scan_directoryC
Recursively scan a directory of MCP server source for toxic flows across all registered tools
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | ||
| exclude | No | ||
| maxFiles | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full disclosure burden. It never says whether the scan is read-only, how large a directory it will traverse, whether it follows symlinks, or what "across all registered tools" actually means — that phrase is ambiguous and could refer to tools declared in the source or tools registered with the auditor.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler. It is efficient, though the trailing clause "across all registered tools" adds ambiguity rather than 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?
With no annotations, no output schema, and zero-documented parameters, the description needed to do much more: explain the ambiguity around "registered tools", describe filtering/limits, and give a sense of the returned findings. As written an agent can attempt a call but cannot predict cost or output.
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% for three parameters. The description only hints at the required `path` via the word "directory"; `exclude` and `maxFiles` are never mentioned, so their format and effect (glob patterns? file count cap?) must be guessed entirely.
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 scope ("Recursively scan a directory of MCP server source") plus the target finding ("toxic flows across all registered tools"). The word "directory" implicitly separates it from toxic_flow_auditor__scan_file, but the other siblings (scan_source, audit_catalog) are never addressed, so differentiation is only partial.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to choose this over toxic_flow_auditor__scan_source, scan_file, or audit_catalog, and no prerequisites or exclusions. The only usage signal is the implied 'point it at a directory', which an agent must infer from the verb.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
toxic_flow_auditor__scan_fileC
Scan a single source file for toxic flows
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden, but it discloses nothing about what a 'toxic flow' detection entails, whether the operation is read-only, what depth of analysis is performed, or whether results are returned inline or aggregated. For a security-audit tool the agent cannot predict outcome shape or cost.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence, front-loaded with the verb and scope, with no filler. It is efficient, though its brevity is partly under-specification rather than disciplined concision.
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 no annotations, so the description must explain results and behavior but does not. Nothing explains the 'toxic flow' concept, its relation to explain_trifecta, or what a caller receives back.
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% – the single 'path' parameter is a bare string with no format, absolute-vs-relative, or file-type guidance. The description only weakly implies a file path via 'single source file' and adds no semantics the schema lacks.
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 the verb ('scan') and the resource ('single source file') plus the target concept ('toxic flows'), and 'single' implies scope limited to one file versus a directory. However, it does not distinguish this from the closely related sibling toxic_flow_auditor__scan_source, leaving an agent unable to choose between them from the description alone.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no indication of when to use this over scan_source, scan_directory, or explain_trifecta, and no stated preconditions such as whether the file must exist locally or be on an allowed path. The agent must infer usage from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
toxic_flow_auditor__scan_sourceA
Scan TypeScript/JavaScript MCP server source for .registerTool(...) and .tool(...) registrations and audit them for toxic flows
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | ||
| content | Yes | Source code to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It says the tool scans and audits for toxic flows but does not clarify what 'toxic flows' means, what the output looks like, whether the operation is purely read-only, or any limits/rate behavior; this leaves meaningful behavioral gaps for an unannotated tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler. Every phrase contributes specific information about file types, target patterns, and audit purpose.
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 scan tool with no output schema and no annotations, the description gives enough to know what input to provide, but it omits what the scan returns, what constitutes a 'toxic flow', and how it relates to sibling scan_file/scan_directory tools. It is minimally adequate but leaves real gaps.
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 50%, so the description must compensate. It adds useful meaning for 'content' by specifying TypeScript/JavaScript MCP server source and the registration patterns to look for, but it never mentions the 'label' parameter, so the undocumented parameter remains unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb (scan), resource (TypeScript/JavaScript MCP server source), and exact registration patterns (.registerTool(...) and .tool(...)) it targets. It also states the audit goal (toxic flows), which distinguishes it from generic scanners and from sibling scan_file/scan_directory tools that operate on paths rather than raw source content.
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 content parameter and the phrase 'scan ... source', suggesting this tool is for raw source snippets rather than files or directories. However, it never explicitly says when to use this versus toxic_flow_auditor__scan_file, scan_directory, or other scanner siblings, and it provides no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
unbounded_consumption_auditor__list_patternsA
List every Unbounded Consumption / denial-of-wallet pattern this auditor detects, grouped by category
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It adds one useful behavioral detail beyond the name — results are 'grouped by category' — but says nothing about what a pattern entry contains (ID, name, description, regex), whether results are stable/static, or how they map to scan findings. Low risk given a zero-param, clearly read-only listing operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with zero filler. The verb, scope, and output grouping are all present in one pass with nothing 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?
No output schema and no annotations exist, so the description is the only source of return-value information; 'grouped by category' hints at shape but does not say what fields a pattern entry has or whether pattern identifiers can be fed into the scanner tools. Adequate for a simple enumeration call, but not enough to chain confidently.
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 the baseline of 4 applies; the schema is trivially complete and there is nothing for the description to compensate for.
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 ('List') plus a clearly scoped resource ('every Unbounded Consumption / denial-of-wallet pattern this auditor detects'). The domain qualifier distinguishes it from the many other list_patterns siblings, though it never names an alternative tool explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer this is a discovery/introspection call to enumerate what the auditor can catch, presumably before running scan_text/scan_file/scan_directory. There is no explicit when-to-use, when-not-to-use, or named alternative among the ~20 sibling list_patterns tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
unbounded_consumption_auditor__scan_directoryB
Recursively scan a directory of LLM/agent application source for Unbounded Consumption / denial-of-wallet anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the directory to scan | |
| exclude | No | Skip files/dirs whose path contains one of these strings | |
| include | No | Only scan files whose path contains one of these strings | |
| maxFiles | No | Maximum number of files to scan (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden. It does reveal that scanning is recursive, which is genuinely useful, but says nothing about what a scan produces (inline findings? counts? per-file results?), whether traversal follows symlinks, or how the 5000-file default limit affects coverage. For a tool with zero annotation coverage, that is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single well-formed sentence with the verb, resource, and target pattern front-loaded and no filler. It is efficient, though arguably too terse for a four-parameter tool with no annotations or output schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Parameters are fully covered by the schema, but with no annotations and no output schema, the description is the only source for return-value behavior and it omits it entirely. An agent knows what the tool scans but not what it gets back or how large a directory is safe to pass.
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 all four parameters (path, exclude, include, maxFiles) are documented in the schema itself, so the baseline of 3 applies. The description adds no parameter-level detail beyond what the schema already says, such as whether include/exclude use substring or glob matching priority.
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 ('Recursively scan'), a precise resource ('directory of LLM/agent application source'), and the exact class of findings ('Unbounded Consumption / denial-of-wallet anti-patterns'). The word 'directory' implicitly separates it from the sibling scan_file/scan_text tools, but it never names them, so sibling differentiation is inferred rather than explicit.
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 by the resource type: scan a directory vs. a file or a text blob. There is no explicit statement of when to prefer this over unbounded_consumption_auditor__scan_file or __scan_text, no prerequisites, and no guidance on directory scope or expected run cost.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
unbounded_consumption_auditor__scan_fileB
Scan a single file for Unbounded Consumption / denial-of-wallet anti-patterns
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Absolute or relative path to the file to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden. It says nothing about what 'anti-patterns' actually get detected, whether the scan is read-only, what the output looks like, or any limits. Only the domain name hints at the 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?
One front-loaded sentence with zero filler; the resource and domain are stated immediately. Nothing could be trimmed without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-param read scan with a well-described schema this is nearly sufficient, but with no annotations and no output schema, an agent would still want to know what findings or rule set to expect. Adequate, not 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 coverage is 100% and the single parameter (path) is fully documented in the schema, so the description cannot add much. It correctly implies file-level input but adds no syntax, format or origin detail 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 (scan) and resource (a single file) plus the precise threat domain (Unbounded Consumption / denial-of-wallet anti-patterns). The 'single file' phrasing implicitly separates it from scan_text and scan_directory, though it does not name them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The scope word 'single file' implies when to use this versus the scan_text/scan_directory siblings, but the description never states the condition explicitly or names any alternative. Usage is inferable rather than guided, which is the definition of minimum-viable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
unbounded_consumption_auditor__scan_textB
Scan LLM/agent application code for Unbounded Consumption ("denial of wallet") anti-patterns from OWASP LLM Top 10 2026's #6 category: LLM calls with no output token limit, hand-rolled HTTP calls to an LLM endpoint with no timeout, agent tool-calling or retry loops with no iteration cap, framework safety limits (LangChain max_iterations, openai-agents max_turns) explicitly disabled, and MCP tool handlers that make billable calls with no visible rate limiting.
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional label shown in findings (e.g. filename) | |
| content | Yes | The code content to scan |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full behavioral burden. It does add real value by spelling out the five concrete detection categories, so an agent knows what will and will not be flagged. However it says nothing about the result shape (findings, severities, locations), whether the scan is purely local/read-only, or any size/time limits on the `content` input.
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 verb and target, and delivered as a single sentence. The long pattern enumeration is dense but every item earns its place by defining detection scope; a short lead-in clause signaling the sibling choice would have made it perfect.
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 scanner with no output schema and no annotations, the description covers scope well but leaves the return contract entirely implicit — an agent cannot tell whether it gets a findings list, counts, or severities, nor how to interpret a clean result.
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% — both `content` and `label` are documented in the schema, so the baseline is 3. The description adds no extra semantics on top (e.g. whether `content` must be a single file or may be a concatenation, or how `label` surfaces in findings beyond the schema's own example).
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 (Scan) and resource (LLM/agent application code) and enumerates the exact anti-pattern classes detected (missing output token limits, no timeouts, unbounded tool/retry loops, disabled framework caps, unrated MCP billable calls). This clearly separates it from unrelated scanners like secret_scanner or prompt_injection_scanner. It does not differentiate itself from its own siblings scan_file and scan_directory, so an agent gets no signal on which surface form this variant takes.
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 by the tool name suffix (_text) and the required `content` parameter; the description never says to use this when you have an in-memory snippet versus scan_file for a path. No prerequisites, no when-not-to-use case, and no pointer to unbounded_consumption_auditor__list_patterns for the pattern catalog.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vector_store_scanner__list_patternsA
List the vector-store types this scanner can fingerprint, and what unauthenticated-access checks it runs for each
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, but 'List' strongly implies a read-only, side-effect-free operation and the description discloses the shape of the returned content (store types plus the checks run per type). It does not state whether results are static or configurable, nor how large the output is.
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; both the primary payload (store types) and the secondary payload (per-type unauthenticated-access checks) are stated compactly.
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 carries the burden of describing the return content, and it does so at a conceptual level. It stops short of describing format or structure, but for a zero-parameter listing tool 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?
The schema has zero parameters and 100% coverage, so the baseline is 4. The description adds no parameter information, which is appropriate here, but nothing beyond the baseline is offered.
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 (List) plus a specific resource (vector-store types this scanner can fingerprint) and the secondary content (unauthenticated-access checks per type). It distinguishes this from the many other *_list_patterns siblings by naming the fingerprinting domain, though it doesn't explicitly name vector_store_scanner__scan_endpoint as the actionable counterpart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer this is a discovery call that should precede scanning an endpoint with vector_store_scanner__scan_endpoint. There is no explicit 'use this when...' statement or exclusion guidance, so intent must be inferred from context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vector_store_scanner__scan_endpointA
Probe a vector-database (or vector-index-capable) endpoint for unauthenticated exposure — Weaviate, Qdrant, Chroma, Elasticsearch/OpenSearch (HTTP fingerprinting, escalating from instance info → collection/schema listing → actual stored data), Redis (RESP PING without AUTH), and Postgres/pgvector (wire-protocol SSLRequest + StartupMessage handshake, no real credentials sent). Read-only — never writes or authenticates with real credentials.
| Name | Required | Description | Default |
|---|---|---|---|
| tls | No | Use https:// for HTTP-based probes (Weaviate/Qdrant/Chroma/Elasticsearch). Default: false | |
| host | Yes | Hostname or IP of the endpoint to probe | |
| port | No | Port to probe (defaults to the store type's conventional port, e.g. 6333 for Qdrant) | |
| type | No | Store type to probe for. 'auto' (default) fingerprints the endpoint by trying each known type in turn. | |
| timeoutMs | No | Per-request timeout in milliseconds (default: 4000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses read-only behavior, that no real credentials are sent, the escalating probe depth (instance info → schema listing → stored data), and concrete wire-level techniques (RESP PING without AUTH, SSLRequest + StartupMessage). It omits what a probe result contains, whether probing is detectable/alerting, and any rate or scope limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose and constraint; the technology list is dense but each item conveys real supported-capability information. Nothing is padded or restated from the tool name.
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 5-parameter, no-output-schema active probing tool, the description covers scope, supported targets, method depth, and safety stance. What's missing is any indication of what the caller receives (findings, severity, evidence) and whether the agent should expect side effects or detection — notable for a network-probing tool with no 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?
Schema description coverage is 100%, so all five parameters are already documented, including the enum and the conventional-port default. The description adds no parameter-level meaning beyond what the schema states (e.g., it never explains 'auto' fingerprinting order or timeout implications). 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?
States a specific verb and resource ('Probe a vector-database ... endpoint for unauthenticated exposure') and enumerates exactly which store families it covers, including the protocols used. An agent can immediately distinguish this from the sibling list_patterns and from generic scanners like vulnerability_scanner__start_scan.
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 use case (unauthenticated exposure of vector stores) and the hard constraint ('Read-only — never writes or authenticates with real credentials') are clear, and the escalation ladder implies scope. It does not, however, say when to prefer this over siblings or point at vector_store_scanner__list_patterns for a passive alternative, so the routing guidance is incomplete given the crowded sibling set.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vulnerability_scanner__get_findingsB
Get vulnerability findings from a GuardBee scan with optional severity filter. Includes title, description, and remediation recommendation per finding.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page number (default: 1) | |
| scanId | No | Filter by scan ID | |
| brandId | No | Filter by brand ID (gets findings across all scans for that brand) | |
| pageSize | No | Results per page (default: 20, max: 100) | |
| severity | No | Filter by severity level |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden; it usefully discloses what each finding contains (title, description, remediation recommendation), which substitutes for the missing output schema. It says nothing about read-only semantics, pagination behavior, or what happens when no scanId/brandId is supplied.
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 compact sentences, front-loaded with purpose followed by return content. No filler, though the second sentence could arguably be part of an output description rather than the purpose statement.
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?
Describing return fields is valuable given there is no output schema. However, with five parameters and zero required, the description should clarify that calling it with no scanId/brandId returns unfiltered findings across scans — a meaningful behavioral question left unaddressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all five parameters are already documented including the severity enum. The description only restates the severity filter already present in the schema and adds no semantics beyond it.
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 ('Get vulnerability findings from a GuardBee scan') and names the severity filter. It is distinguishable from sibling tools like vulnerability_scanner__list_scans and get_scan_status, though it never explicitly contrasts itself with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this vs. list_scans, get_scan_status, or scan_and_report, and no mention of prerequisites (e.g., that a scan must exist first). The phrase 'from a GuardBee scan' only weakly implies the workflow context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vulnerability_scanner__get_scan_statusB
Get the current status and summary of a GuardBee scan by ID
| Name | Required | Description | Default |
|---|---|---|---|
| scanId | Yes | Scan ID returned by start_scan |
TDQS
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 read operation but says nothing about what statuses exist, whether a scan may still be running, how often to poll, or what happens with an unknown/expired scan ID.
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 no filler; the resource and identifier are stated up front. It is efficient, though perhaps too terse given the missing behavioral 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?
There is no output schema and no annotations, so the description is the only place to explain the returned status/summary shape — yet it stops at naming them. For a polling tool an agent needs to know what the status values mean and when to call again.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter is documented as 'Scan ID returned by start_scan'. The description adds only 'by ID', which is redundant with the schema, 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?
Specific verb+resource: 'Get the current status and summary of a GuardBee scan by ID'. It is distinguishable from siblings like vulnerability_scanner__start_scan and vulnerability_scanner__get_findings by naming status/summary as the payload, though it never explicitly contrasts itself with those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the schema note 'Scan ID returned by start_scan' hints that this is a follow-up to starting a scan, but the description itself states no when-to-use condition, no guidance on polling, and no pointer to get_findings for detailed results.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vulnerability_scanner__list_scansC
List recent GuardBee scans in your workspace
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page number (default: 1) | |
| status | No | Filter by scan status | |
| brandId | No | Filter by brand ID | |
| pageSize | No | Results per page (default: 20, max: 50) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about auth/workspace permissions, ordering, pagination limits, or how many scans are returned by default. Only the vague 'recent' hint and the workspace scope constraint are conveyed.
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 efficient sentence with no filler and the resource front-loaded. It is close to under-specified rather than verbose, but nothing 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 tool with four optional filter/pagination params, no annotations, and no output schema, the description should clarify return shape, default ordering, and how paging behaves. It omits all of this, leaving the agent to infer pagination semantics from the schema alone.
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% with all four params (page, pageSize, status, brandId) documented in the schema, so the baseline of 3 applies. The description adds no extra semantics such as default time window, sort order, or how status/brandId filters combine.
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 ('List recent GuardBee scans') with workspace scoping, which distinguishes it from the scan-producing siblings like start_scan and scan_and_report. It does not explicitly contrast itself with get_scan_status or get_findings, so the boundary with those read siblings is left implicit.
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 versus vulnerability_scanner__get_scan_status or get_findings, and no mention of what to do if the list is paginated or empty. The word 'recent' implies a default ordering but nothing tells the agent how to widen scope or page through results.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vulnerability_scanner__scan_and_reportA
Run a full GuardBee scan and immediately return all critical and high findings with remediation guidance. Best for quick security assessments.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Target URL to scan | |
| scenario | No | Scan scenario (default: quick) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses that the scan runs synchronously ('immediately return') and filters output to critical and high findings with remediation guidance. However, it omits important behavioral traits for a network-facing scanner: whether scanning is intrusive, expected duration, rate limits, authentication requirements, or whether results are persisted.
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 two concise sentences with zero wasted words. The core action and the immediate-return behavior are 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?
There is no output schema, and the description only partially explains the return value: critical/high findings plus remediation guidance. It does not describe the response format, whether lower-severity findings are omitted or accessible elsewhere, or how this relates to get_findings. This leaves meaningful gaps for a tool with no annotations and no 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?
Schema description coverage is 100%, so the schema already documents both url and scenario, including the scenario enum. The description adds no additional meaning about parameter usage, so the baseline of 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 uses a specific verb and resource: 'Run a full GuardBee scan' and 'return all critical and high findings with remediation guidance.' This clearly states the operation, but it does not differentiate from sibling tools such as vulnerability_scanner__start_scan or get_findings.
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?
'Best for quick security assessments' implies the appropriate context, but it does not explicitly say when to use this versus start_scan, get_scan_status, or get_findings. No exclusions 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.
vulnerability_scanner__start_scanB
Start a GuardBee security scan on a URL. Returns a scan ID you can use to check status and get findings.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | Target URL to scan (e.g. https://example.com) | |
| wait | No | Wait for scan to complete and return summary (default: false). Warning: scans can take minutes. | |
| brandId | No | Brand ID from your GuardBee workspace (alternative to url) | |
| scenario | No | Scan scenario: 'quick' (all modules), 'kvkkFocus', 'gdprFocus', 'ccpaFocus' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full behavioral burden. It discloses that the tool returns a scan ID (a useful asynchronous workflow detail), but it says nothing about authorization requirements, whether the scan actively probes the target, rate limits, or side effects. For a tool that initiates external scanning, that is a notable gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, front-loaded with the action and then the return value/next step. There is 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?
The description explains the immediate return (scan ID) and how to follow up, and the rich input schema covers parameters. But with no annotations and no output schema, it should say more about side effects, authorization, and how this differs from scan_and_report to be fully complete for an 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?
Schema description coverage is 100%, with every parameter documented including the wait warning, brandId alternative to url, and scenario enum values. The description adds no parameter-level meaning beyond the schema, which is acceptable given the schema already does that job.
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 ('Start a GuardBee security scan on a URL') and distinguishes the output (scan ID). However, it does not differentiate from the sibling scan_and_report, so an agent cannot tell from the description alone when this tool is preferable to that one.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies an asynchronous workflow by noting the scan ID can be used to check status and get findings, which hints at usage context. But it never names or contrasts with siblings like get_scan_status, list_scans, or scan_and_report, leaving the agent to infer when this tool is the right choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
130 tool updates
v0.1.5- Changed
a2a_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
a2a_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
a2a_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
a2a_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
agent_graph_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
agent_graph_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
agent_graph_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
agent_graph_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
ai_code_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
ai_code_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
ai_code_scanner__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
ai_code_scanner__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
audit_gap_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
audit_gap_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
audit_gap_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
audit_gap_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
compliance_checker__analyze_privacy_policy1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
compliance_checker__check_compliance1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
compliance_checker__compare_frameworks1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
compliance_checker__get_compliance_findings1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
compliance_checker__list_requirements1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
context_oversharing_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
context_oversharing_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
context_oversharing_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
context_oversharing_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
db_gateway__describe_table1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
db_gateway__gateway_status1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
db_gateway__list_tables1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
db_gateway__query_audit_log1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
db_gateway__query_table1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dependency_auditor__audit_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dependency_auditor__audit_npm1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dependency_auditor__audit_package1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dependency_auditor__audit_pip1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dns_intelligence__audit_domains1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dns_intelligence__check_email_security1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dns_intelligence__check_takeover1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dns_intelligence__enumerate_dns1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dns_intelligence__enumerate_subdomains1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
dns_intelligence__lookup_dns1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
document_scanner__list_detectors1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
document_scanner__scan_base641 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
document_scanner__scan_document1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
elicitation_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
elicitation_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
elicitation_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
elicitation_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
llm_redteam__list_probes1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
llm_redteam__run_probe_suite1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_config_auditor__discover_shadow_mcp1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_config_auditor__list_host_config_paths1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_config_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
mcp_config_auditor__scan_config_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_config_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_config_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_config_auditor__scan_inventory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_config_auditor__scan_skill_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_server_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
mcp_server_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_server_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
mcp_server_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
memory_poisoning_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
memory_poisoning_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
memory_poisoning_scanner__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
memory_poisoning_scanner__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
model_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
model_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
model_scanner__scan_file2 fields changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema" - changed
Input schema / properties / path / descriptionPrevious value: -"Absolute or relative path to the model file (.pt, .pth, .ckpt, .pkl, .pickle, .bin, .safetensors, .h5, .hdf5, .keras, .onnx)"New value: +"Absolute or relative path to the model file (.pt, .pth, .ckpt, .pkl, .pickle, .bin, .dill, .joblib, .jbl, .npy, .npz, .safetensors, .h5, .hdf5, .keras, .onnx, .gguf, .pb, .pbtxt, .tflite)"
- Added
model_scanner__scan_hf_repo - Changed
oauth_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
oauth_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
oauth_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
oauth_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
owasp_scan__list_owasp_coverage1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
owasp_scan__owasp_scan_catalog1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
owasp_scan__owasp_scan_live1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
owasp_scan__owasp_scan_path1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
prompt_injection_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
prompt_injection_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
prompt_injection_scanner__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
prompt_injection_scanner__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
prompt_leak_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
prompt_leak_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
prompt_leak_scanner__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
prompt_leak_scanner__scan_messages1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
prompt_leak_scanner__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
rug_pull_detector__baseline_server1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
rug_pull_detector__check_server1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
rug_pull_detector__list_baselines1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
secret_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
secret_scanner__scan_agent_history1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
secret_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
secret_scanner__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
secret_scanner__scan_git1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
secret_scanner__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
slopsquat_scanner__check_package1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
slopsquat_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
slopsquat_scanner__scan_npm1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
slopsquat_scanner__scan_pip1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
ssl_inspector__check_cert_expiry1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
ssl_inspector__get_cert_info1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
ssl_inspector__inspect_ssl1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
ssl_inspector__inspect_ssl_bulk1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
threat_rules__evaluate_event1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
threat_rules__evaluate_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
threat_rules__evaluate_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
threat_rules__explain_bridge1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
threat_rules__framework_map1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
threat_rules__list_rules1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
threat_rules__rule_stats1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
tool_poisoning_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
tool_poisoning_scanner__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
tool_poisoning_scanner__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
tool_poisoning_scanner__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
toxic_flow_auditor__audit_catalog1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
toxic_flow_auditor__explain_trifecta1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
toxic_flow_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
toxic_flow_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
toxic_flow_auditor__scan_source1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
unbounded_consumption_auditor__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
unbounded_consumption_auditor__scan_directory1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
unbounded_consumption_auditor__scan_file1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
unbounded_consumption_auditor__scan_text1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
vector_store_scanner__list_patterns1 field changed- removed
Input schema / $schemaRemoved value: -"http://json-schema.org/draft-07/schema#"
- Changed
vector_store_scanner__scan_endpoint1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
vulnerability_scanner__get_findings1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
vulnerability_scanner__get_scan_status1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
vulnerability_scanner__list_scans1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
vulnerability_scanner__scan_and_report1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
vulnerability_scanner__start_scan1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
1 tool update
v0.1.3- Changed
tool_poisoning_scanner__scan_text2 fields changed- changed
Input schema / properties / label / descriptionPrevious value: -"Optional label shown in findings (e.g. filename)"New value: +"Optional label shown in findings (e.g. filename); its extension picks the language" - added
Input schema / properties / languageAdded value: +{ + "description": "Source language, when the label has no extension (default: typescript)", + "enum": [ + "typescript", + "javascript", + "python", + "go" + ], + "type": "string" +}
135 tool updates
v0.1.1- Added
a2a_auditor__list_patterns - Added
a2a_auditor__scan_directory - Added
a2a_auditor__scan_file - Added
a2a_auditor__scan_text - Added
agent_graph_auditor__list_patterns - Added
agent_graph_auditor__scan_directory - Added
agent_graph_auditor__scan_file - Added
agent_graph_auditor__scan_text - Added
ai_code_scanner__list_patterns - Added
ai_code_scanner__scan_directory - Added
ai_code_scanner__scan_file - Added
ai_code_scanner__scan_text - Added
audit_gap_auditor__list_patterns - Added
audit_gap_auditor__scan_directory - Added
audit_gap_auditor__scan_file - Added
audit_gap_auditor__scan_text - Added
compliance_checker__analyze_privacy_policy - Added
compliance_checker__check_compliance - Added
compliance_checker__compare_frameworks - Added
compliance_checker__get_compliance_findings - Added
compliance_checker__list_requirements - Added
context_oversharing_auditor__list_patterns - Added
context_oversharing_auditor__scan_directory - Added
context_oversharing_auditor__scan_file - Added
context_oversharing_auditor__scan_text - Added
db_gateway__describe_table - Added
db_gateway__gateway_status - Added
db_gateway__list_tables - Added
db_gateway__query_audit_log - Added
db_gateway__query_table - Added
dependency_auditor__audit_directory - Added
dependency_auditor__audit_npm - Added
dependency_auditor__audit_package - Added
dependency_auditor__audit_pip - Added
dns_intelligence__audit_domains - Added
dns_intelligence__check_email_security - Added
dns_intelligence__check_takeover - Added
dns_intelligence__enumerate_dns - Added
dns_intelligence__enumerate_subdomains - Added
dns_intelligence__lookup_dns - Added
document_scanner__list_detectors - Added
document_scanner__scan_base64 - Added
document_scanner__scan_document - Added
elicitation_auditor__list_patterns - Added
elicitation_auditor__scan_directory - Added
elicitation_auditor__scan_file - Added
elicitation_auditor__scan_text - Removed
list_patterns - Added
llm_redteam__list_probes - Added
llm_redteam__run_probe_suite - Added
mcp_config_auditor__discover_shadow_mcp - Added
mcp_config_auditor__list_host_config_paths - Added
mcp_config_auditor__list_patterns - Added
mcp_config_auditor__scan_config_text - Added
mcp_config_auditor__scan_directory - Added
mcp_config_auditor__scan_file - Added
mcp_config_auditor__scan_inventory - Added
mcp_config_auditor__scan_skill_text - Added
mcp_server_auditor__list_patterns - Added
mcp_server_auditor__scan_directory - Added
mcp_server_auditor__scan_file - Added
mcp_server_auditor__scan_text - Added
memory_poisoning_scanner__list_patterns - Added
memory_poisoning_scanner__scan_directory - Added
memory_poisoning_scanner__scan_file - Added
memory_poisoning_scanner__scan_text - Added
model_scanner__list_patterns - Added
model_scanner__scan_directory - Added
model_scanner__scan_file - Added
oauth_auditor__list_patterns - Added
oauth_auditor__scan_directory - Added
oauth_auditor__scan_file - Added
oauth_auditor__scan_text - Added
owasp_scan__list_owasp_coverage - Added
owasp_scan__owasp_scan_catalog - Added
owasp_scan__owasp_scan_live - Added
owasp_scan__owasp_scan_path - Added
prompt_injection_scanner__list_patterns - Added
prompt_injection_scanner__scan_directory - Added
prompt_injection_scanner__scan_file - Added
prompt_injection_scanner__scan_text - Added
prompt_leak_scanner__list_patterns - Added
prompt_leak_scanner__scan_directory - Added
prompt_leak_scanner__scan_file - Added
prompt_leak_scanner__scan_messages - Added
prompt_leak_scanner__scan_text - Added
rug_pull_detector__baseline_server - Added
rug_pull_detector__check_server - Added
rug_pull_detector__list_baselines - Removed
scan_agent_history - Removed
scan_directory - Removed
scan_file - Removed
scan_git - Removed
scan_text - Added
secret_scanner__list_patterns - Added
secret_scanner__scan_agent_history - Added
secret_scanner__scan_directory - Added
secret_scanner__scan_file - Added
secret_scanner__scan_git - Added
secret_scanner__scan_text - Added
slopsquat_scanner__check_package - Added
slopsquat_scanner__scan_directory - Added
slopsquat_scanner__scan_npm - Added
slopsquat_scanner__scan_pip - Added
ssl_inspector__check_cert_expiry - Added
ssl_inspector__get_cert_info - Added
ssl_inspector__inspect_ssl - Added
ssl_inspector__inspect_ssl_bulk - Added
threat_rules__evaluate_event - Added
threat_rules__evaluate_file - Added
threat_rules__evaluate_text - Added
threat_rules__explain_bridge - Added
threat_rules__framework_map - Added
threat_rules__list_rules - Added
threat_rules__rule_stats - Added
tool_poisoning_scanner__list_patterns - Added
tool_poisoning_scanner__scan_directory - Added
tool_poisoning_scanner__scan_file - Added
tool_poisoning_scanner__scan_text - Added
toxic_flow_auditor__audit_catalog - Added
toxic_flow_auditor__explain_trifecta - Added
toxic_flow_auditor__scan_directory - Added
toxic_flow_auditor__scan_file - Added
toxic_flow_auditor__scan_source - Added
unbounded_consumption_auditor__list_patterns - Added
unbounded_consumption_auditor__scan_directory - Added
unbounded_consumption_auditor__scan_file - Added
unbounded_consumption_auditor__scan_text - Added
vector_store_scanner__list_patterns - Added
vector_store_scanner__scan_endpoint - Added
vulnerability_scanner__get_findings - Added
vulnerability_scanner__get_scan_status - Added
vulnerability_scanner__list_scans - Added
vulnerability_scanner__scan_and_report - Added
vulnerability_scanner__start_scan
6 tool updates
v0.1.0- First observed
list_patterns - First observed
scan_agent_history - First observed
scan_directory - First observed
scan_file - First observed
scan_git - First observed
scan_text
TDQS
Scored across 130 tools
Each scanner family (secrets, prompt injection, prompt leak, tool poisoning, toxic flow, DNS, SSL, etc.) targets a reasonably distinct risk domain, and scan_text/scan_file/scan_directory differ by input shape. However several families overlap in practice — secret_scanner vs prompt_leak_scanner vs document_scanner all hunt credentials/PII, and mcp_server_auditor vs tool_poisoning_scanner vs toxic_flow_auditor vs owasp_scan__owasp_scan_path all audit MCP source with the meta-scanner wrapping the others. With 30+ near-identical 'scan_text/scan_file/scan_directory/list_patterns' quads, an agent must know the taxonomy well to pick the right family.
The dominant `family__verb_noun` namespacing (e.g. prompt_injection_scanner__scan_file, secret_scanner__list_patterns) is highly predictable and makes tool family obvious. Minor deviations exist — model_scanner__scan_hf_repo, ssl_inspector__inspect_ssl_bulk, toxic_flow_auditor__explain_trifecta, db_gateway__query_table — but they still read as verb_noun within their namespace.
130 tools is far beyond what an agent can reason over reliably; the count is inflated by mechanical multiplication (every auditor repeats scan_text/scan_file/scan_directory/list_patterns). While the breadth is genuinely large (static audits, live scans, DNS/TLS, DB gateway, red-team probes), a single server exposing this many entry points creates severe selection cost and a bloated context surface.
Coverage is unusually thorough: text/file/directory variants, pattern catalogs, orchestration (owasp_scan_path/live/catalog), remote scan lifecycle (start/status/findings/list), and baseline drift detection. Minor gaps: no cancel/delete scan operation and no remediation/fix-generation tools, so long-running scans and follow-through rely on workarounds.
Maintenance
Related MCP Connectors
Security & DLP proxy for MCP: tool-poisoning scans, PII redaction on tool args/results. Beta.
Scan prompts for injection attacks, redact PII, and audit LLM SDK usage from any MCP client
Governed MCP gateway: one endpoint for your tools, with credential custody and audit log.
Security firewall for AI agents — scans MCP calls for injection, secrets, and risks.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceControl-plane proxy that sits in front of MCP servers, enforcing per-identity policy (YAML/OPA/Cedar), budget limits, and an audit trail on every call. Includes real-time anomaly detection that auto-blocks a compromised agent without a human in the loop.17Apache 2.0
- FlicenseNot gradedqualityBmaintenanceEnforces deterministic security policies on Model Context Protocol traffic between agents and remote MCP servers, including request validation, signed human approval, response-side credential blocking, prompt-injection flagging, and privacy-minimized auditing.-
- AlicenseNot gradedqualityCmaintenanceEnables secure MCP traffic by filtering threats with a 3-stage detection pipeline, applying RBAC policies, and redacting sensitive data in real-time via an SSE-inspecting proxy.Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI agents and MCP clients to safely access upstream MCP servers through centralized policy enforcement, including allow/deny/approval decisions, schema pinning, circuit breakers, and audit logging.MIT