Server and secret guardrails
Server Details
Local checks for sudo, systemd, sshd, ufw, and secret leaks before an agent applies them.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
The four tools target distinct outputs: install artifacts (install_local), the check catalog (list_checks), product/registry URLs (products), and demo finding ids (sample_findings). They are mostly distinguishable, though all are passive metadata endpoints, so overlap in 'returns static info' intent is mild.
install_local and list_checks follow a clean verb_noun pattern, but products and sample_findings are noun/noun-phrase names with no verb, breaking the convention. Still readable, but the pattern is mixed.
Four tools is on the thin side but reasonable for a static info/guardrails surface; each tool returns a distinct resource. It would sit better with at least one action-oriented tool, but nothing is redundant.
For a server-and-secret guardrails server, the core capability—actually running checks like scan_secret_leak or rewrite_safe_curl against input—is absent; list_checks explicitly cannot run them. Agents get a catalog and demo findings but hit a dead end for real scanning, a significant gap.
Available Tools
4 toolsinstall_localAInspect
Return the local install file, its sha256, and client config. Optional client: claude-desktop, claude-code, cursor, gemini, codex.
| Name | Required | Description | Default |
|---|---|---|---|
| client | No |
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 return contents (install file, sha256, client config), implying a read-only retrieval, but never explicitly states read-only/no-side-effects, permissions, or whether the client selection changes output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, zero waste. The primary action and returns are front-loaded, with the optional parameter noted second.
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 simple single-parameter tool with no output schema; the description explains both the inputs and the returned payload, which is sufficient. It could be improved by stating read-only behavior and the default client, but nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate, and it does add one thing: that 'client' is optional. However, listing the enum values merely repeats the schema's enum without explaining what distinguishes claude-desktop, cursor, gemini, etc., or the default when omitted.
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 (Return) plus the exact resources produced: the local install file, its sha256, and client config. An agent knows precisely what it yields. It does not need sibling differentiation since the sibling tools (list_checks, products, sample_findings) are unrelated.
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 – the tool is for fetching a local install artifact, and it notes which clients can be targeted. There is no explicit when-to-use/when-not or prerequisite (e.g. auth or platform) guidance, but no alternative tool overlaps, so ambiguity is low.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_checksAInspect
List the local checks (audit_server_snippet, scan_secret_leak, rewrite_safe_curl). This endpoint cannot run them on text you send.
| 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 behavioral burden, and it does disclose one real limitation (it cannot execute checks against supplied text). However, it says nothing about permissions, whether the listed checks are installed vs. merely available, or the shape of the result, leaving notable 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?
Two short sentences, zero filler, with the resource and its contents front-loaded before the constraint. 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?
For a no-parameter listing tool with no output schema and no annotations, the description is nearly complete: it identifies the resource, its contents, and its key limitation. Only the absence of any note about installation state or result format 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 the baseline is 4; there is nothing for the description to clarify or compensate for. The enumerated check names add mild value by indicating what the (empty-input) result will contain.
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 ('List the local checks') and enumerates the exact items returned (audit_server_snippet, scan_secret_leak, rewrite_safe_curl), which makes the tool's scope concrete. It does not explicitly contrast itself with the siblings (install_local, products, sample_findings), 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?
It gives a clear negative usage condition: 'This endpoint cannot run them on text you send,' telling the agent when this tool is not the right call. It stops short of naming an alternative tool for actually running checks, so it is clear context plus one exclusion rather than full when/when-not/alternatives guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
productsCInspect
Return the $19 and $39 kit URLs, the install page, and the registry remote. This endpoint does not read files.
| 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 behavioral burden. It does disclose one genuinely useful trait ('does not read files'), implying a safe, non-filesystem lookup, but says nothing about side effects, auth, or why it exists — thin coverage for a tool with zero annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the return payload and the behavioral caveat, with no filler. Efficient, though it is terse to the point of omitting context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-param tool with no output schema, the description should explain the return payload and when it is useful. It covers the payload but leaves the concepts ('registry remote', what a kit is) and the usage trigger unexplained.
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 takes no parameters (additionalProperties: false), so there is nothing for the description to clarify. Baseline 4 applies for a zero-param 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?
The description names the concrete return payload (the $19 and $39 kit URLs, install page, and registry remote), which is more specific than the bare name 'products'. However, it never states what the tool is for or what a 'product/kit' is in this system, and sibling differentiation is only implicit via 'does not read 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?
There is no when-to-use guidance, no prerequisites, and no named alternative. The clause 'does not read files' faintly gestures at install_local as the contrasting tool but never tells the agent when to pick this one instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sample_findingsAInspect
Show finding ids from built-in public fixtures. Does not read the request.
| 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 full burden. It discloses that the tool ignores request input and uses built-in public fixtures, but does not state read-only safety, return format, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the tool's purpose. Both sentences earn their place: the first states what it does, the second clarifies its non-input behavior.
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 output schema, the description adequately covers what it returns ('finding ids') and that it uses fixtures. It could be slightly more explicit about output format, but it's sufficient for 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 the baseline is 4 per instructions. The schema is empty and the description adds no parameter information, which 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 'Show' and resource 'finding ids from built-in public fixtures', distinguishing it from real data sources. However, it does not explicitly differentiate from siblings like list_checks or products.
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 siblings such as list_checks or products. The only contextual note is 'Does not read the request,' which is behavioral, not usage-oriented.
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.
4 tool updates
- First observed
install_local - First observed
list_checks - First observed
products - First observed
sample_findings
Related MCP Connectors
Stop your agent before it runs rm -rf /etc or emails your .env. Deterministic preflight checks.
Lets coding agents check their own code for leaked secrets, risky dependencies and AI-code mistakes
Independent agent preflight: verify change, mandates, evidence, and exact execution.
Verify before you act: deps-check, x402-preflight, json-repair & url-read for agents.
Related MCP Servers
- AlicenseAqualityAmaintenanceSafety checks an agent runs before it acts — flags malicious packages, destructive shell commands, secret leaks, and web-backend holes before execution.812 PyPIMIT
- AlicenseNot gradedqualityDmaintenanceLocal-first security check for AI coding agents — finds hardcoded secrets, exposed .env files, git-history leaks and vulnerable dependencies (OSV), entirely on your machine. Ask your agent "is this safe to ship?" and get a Launch Readiness score with a fix for every finding.MIT
- AlicenseNot gradedqualityCmaintenanceProvides security checks for AI agents, including secret scanning, CVE lookup, and dependency vulnerability scanning, all running locally except for CVE lookups.MIT
- -licenseNot gradedqualityNot gradedmaintenanceThe safety gate between AI agents and your servers: 25 typed, policy-checked tools for services, logs, Docker, disk, ports and nginx, with human approval for changes and a hash-chained audit log.-
Glama MCP Gateway
Add one secure layer between your agents and this server.