Skip to main content
Glama

Server Details

Runs your code against a contract; returns HELD or BROKE at the exact input. Deterministic.

Status
Healthy
Last Tested
Transport
Streamable HTTP
URL

Glama MCP Gateway

Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.

MCP client
Glama
MCP server

Full call logging

Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.

Tool access control

Enable or disable individual tools per connector, so you decide what your agents can and cannot do.

Managed credentials

Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.

Usage analytics

See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.

100% free. Your data is private.
Tool DescriptionsA

Average 5/5 across 1 of 1 tools scored.

Server CoherenceA
Disambiguation5/5

With only one tool, there is no possibility of confusing it with others. The tool's description clearly defines its purpose and input modes, so an agent can unambiguously select it for verification tasks.

Naming Consistency5/5

The single tool name 'verify' is a clear, imperative verb matching its purpose. There is no naming inconsistency to evaluate, as the name is simple, descriptive, and aligned with the server's function.

Tool Count4/5

One tool is minimal, but the server's purpose is narrowly scoped to verification, so a single, comprehensive tool is appropriate. It could potentially be split into sub-tools for contract and assumption checking, but the current design is not over- or under-provisioned for the stated use case.

Completeness5/5

The tool covers the full verification lifecycle: contract-based checking, assumption-based checking, and multiple verdict types including error cases. It also handles edge cases like self-audit limitations and non-deterministic code, leaving no obvious gaps in the verification domain.

Available Tools

1 tool
verifyAInspect

An outside check on code, executed in a sealed sandbox. Call it before code crosses a consequence boundary: before you merge it, deploy it, publish it, settle a payout on it, or report it done. A self-audit verifies consistency, never completeness: a check written inside the frame that produced the code passes on the code's own assumptions. This is the check that is not you. Also call it when a fix passes your own check but the target still fails; that means your check shares the code's assumption and cannot see the error. INPUT: code (JavaScript/Node or Python 3 source, deterministic only) plus ONE of: contract {fn, examples:[{call,expected}]} (copy call and expected from the test or spec the consequence depends on), or assumption (plain-language claim, weaker read). It checks the code against the contract exactly as given. VERDICTS (synchronous): BROKE: the code violates your contract, with the exact input and a rerunnable proof; do not proceed. HELD: the code meets the contract you gave; proceed on that contract, and nothing more. FINDINGS: a stated property strains under a generated input; check it before proceeding. DROP: not deterministically checkable. PAYMENT: 0.10 USDC per call, x402 v2 on Base, no account. Every delivered verdict is charged, HELD and DROP included. If no verdict is produced, the payment authorization is cancelled and you are not charged.

ParametersJSON Schema
NameRequiredDescriptionDefault
codeYesThe function source under test. 64000 char max.
contractNoProvide a {call, expected} contract for a BROKE-capable verdict. BROKE fires only from a contract you provide.
assumptionNoA claim about the code in plain words, for a FINDINGS read (never BROKE). 4000 char max.
Behavior5/5

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

No annotations are provided, so the description carries the full burden. It discloses the sealed sandbox, determinism requirement, synchronous verdicts with detailed meanings (BROKE, HELD, FINDINGS, DROP), and payment terms (0.10 USDC, x402 v2 on Base, charged for every delivered verdict, cancellation if no verdict). This is exceptionally transparent.

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

Conciseness5/5

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

The description is long, but it is tightly organized and front-loaded with purpose, then usage, inputs, verdicts, and payment. Every sentence carries operational or conceptual weight, and the uppercase verdict labels make the length navigable.

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

Completeness5/5

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, this description is complete enough to select and invoke correctly: it covers input requirements, verdict semantics, consequence directions, and payment failure behavior. The only minor gap is the exact response shape for verdicts, but the behavioral descriptions of BROKE/HELD/FINDINGS/DROP provide enough for safe usage.

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

Parameters5/5

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

Schema coverage is already 100%, but the description adds critical semantics: code must be JavaScript/Node or Python 3 and deterministic, exactly one of contract vs assumption should be supplied, contract pairs must be copied from the test/spec, and assumption is a weaker plain-language read that can only trigger FINDINGS, never BROKE. This goes well beyond the schema's property names.

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

Purpose5/5

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

The description defines verify as 'an outside check on code, executed in a sealed sandbox' and immediately gives concrete trigger scenarios (merge, deploy, publish, settle, report done). This is a specific verb-plus-resource statement with clear scope, and it explicitly contrasts itself with a self-audit, making the purpose unambiguous even without sibling tools.

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

Usage Guidelines5/5

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

It gives explicit when-to-use guidance: before any consequence boundary (merge, deploy, publish, settlement, done report), and in the specific case where a fix passes your own check but the target still fails. It also sets a boundary by requiring deterministic code and explaining what the tool cannot do ('never completeness'), which functions as a when-not.

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

Discussions

No comments yet. Be the first to start the discussion!

Related MCP Servers

View all MCP Servers

Try in Browser

Your Connectors

Sign in to create a connector for this server.

Resources