agent-trust-oracle
Server Details
Decay-weighted reputation + tamper-evident trust attestations for the agent economy.
- Status
- Healthy
- Uptime
- 100.0% over 41 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- jdhart81/viridis-agent-fleet
- GitHub Stars
- 0
- Server Listing
- viridis-agent-fleet
TDQS
Scored across 6 tools
Each tool targets a distinct operation: issuing attestations, self-description, history retrieval, outcome recording, score querying, and verification. No overlaps.
Tools mostly follow verb_noun pattern (describe_agent, record_outcome, score_agent, verify_attestation), but 'history' is a noun-only exception. Still clear and predictable.
Six tools cover the core trust oracle functionality without bloat. Each tool serves a necessary role in the lifecycle.
Covers recording outcomes, querying scores, and managing attestations. Lacks a tool to list agents or modify outcomes, but these are plausible intentional constraints.
Available Tools
6 toolsattestCInspect
Issue a tamper-evident (hash-chained) trust attestation for an agent.
| Name | Required | Description | Default |
|---|---|---|---|
| claim | No | reputation-snapshot | |
| agent_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description bears full responsibility. It mentions 'tamper-evident' but does not disclose side effects, persistence, authorization needs, or reverting actions. Minimal behavioral insight.
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 concise sentence, which is efficient. However, it sacrifices valuable information that could be included without losing conciseness.
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 presence of an output schema, the description still lacks context about prerequisites, effects on state, or relationship to sibling tools. The info is insufficient for an agent to use it 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 0%, and the description adds no explanation for the parameters 'claim' (with default) and 'agent_id'. The default value 'reputation-snapshot' is not clarified, leaving agents uninformed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Issue' and the resource 'tamper-evident (hash-chained) trust attestation for an agent', which is specific and distinguishes it from siblings like verify_attestation.
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 is provided on when to use this tool versus alternatives such as verify_attestation or record_outcome. The description only states the action, lacking contextual usage cues.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
describe_agentDInspect
Fleet-standard self-description.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It merely says 'self-description,' which does not state whether the operation is read-only, what data it returns, whether it has side effects, or any constraints. No behavioral traits are disclosed beyond the bare concept.
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 extremely short, but this is under-specification rather than effective conciseness. The phrase 'Fleet-standard self-description' is a fragment that conveys almost no useful information. Every word does not earn its place because the phrase is vague and lacks substance.
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?
Although an output schema exists, the description is too minimal to be considered complete. It does not explain what 'self-description' means, how the output is structured, or when to invoke the tool. The presence of the output schema helps, but the description itself leaves critical context unresolved, especially given the zero annotations and no usage guidance.
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, so the baseline for this dimension is 4 per the rubric. The description adds no parameter semantics, but none are needed since the input schema is empty and coverage is trivially 100%. The description does not hinder parameter understanding.
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 'Fleet-standard self-description' is essentially a tautology of the tool name 'describe_agent'; it restates the concept without specifying what the self-description contains or what action is performed. The modifier 'Fleet-standard' adds branding but not functional clarity, making it insufficiently distinct from the name 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?
The description provides no guidance on when to use this tool versus alternatives. It does not mention context, prerequisites, or exclusions, and none of the sibling tools are referenced. This is a complete absence of usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
historyBInspect
Full outcome history + attestation count + current score for an agent.
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses the returned data (history, attestation count, score) but does not explicitly state it is read-only or mention any side effects. Lacks detail on permission requirements or pagination 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?
Single sentence, no extra words. Information is front-loaded and clear. Every part contributes to understanding.
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 presence of an output schema and a single required parameter, the description is fairly complete for a retrieval tool. It covers the three main outputs. Could add a note about ordering or date range, but not essential.
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 description must add meaning. It implies agent_id identifies the agent, but does not explain format, examples, or source. For a simple required parameter, this is minimal but acceptable.
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?
Description clearly states the tool returns three components: outcome history, attestation count, and current score for an agent. It distinguishes from sibling tools like record_outcome (write) or attest (perform action) by focusing on retrieval. However, the verb 'history' is used as a noun, slightly awkward.
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 guidance on when to use this tool vs siblings like score_agent or describe_agent. The description implies it is for retrieving full history and current score, but does not state when it's appropriate or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
record_outcomeBInspect
Record an interaction outcome for an agent. kind: success | delivered | dispute_won | failure | undelivered | dispute_lost | timeout | security_incident (security incidents carry a 3x penalty).
| Name | Required | Description | Default |
|---|---|---|---|
| kind | Yes | ||
| note | No | ||
| weight | No | ||
| agent_id | Yes | ||
| counterparty | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses the 3x penalty for security incidents but does not mention other behaviors like idempotency, side effects, or duplicate handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the core purpose and list of kinds. It could be more structured but contains no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters (2 required), 0% schema coverage, and no annotations, the description is insufficient. It fails to describe most parameters and lacks guidance on usage context beyond kind.
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 description must explain parameters. It only describes 'kind' with allowed values, leaving agent_id, note, weight, and counterparty unexplained despite agent_id being required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'record' and the resource 'interaction outcome for an agent', listing all allowed kind values. It distinguishes from sibling tools like attest or describe_agent, which serve different purposes.
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 lists allowed kind values and notes the penalty for security incidents, giving implied usage context. However, it does not explicitly state when to use this tool vs alternatives or provide exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
score_agentAInspect
Get an agent's decay-weighted trust score in [0,1] and tier. Unknown agents get a neutral 0.5 prior — no blind trust, no unfair zero.
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 discloses the neutral prior for unknown agents, but does not explain 'decay-weighted' or mention idempotency, rate limits, 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 sentences, no fluff, front-loaded with the key output (score and tier). 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 simple scoring tool with an output schema (presumably explaining return values), the description covers the essential behavioral aspect (unknown agent handling). It could mention the decay mechanism briefly, but overall it is complete enough.
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?
With 0% schema coverage, the description minimally adds context for the single parameter 'agent_id' by stating it's for an agent. However, it does not specify format, constraints, or how to obtain the ID. Baseline 3 is appropriate given the low complexity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves a decay-weighted trust score and tier for an agent, with specific behavior for unknown agents (0.5 prior). This is distinct from sibling tools like 'attest' or 'describe_agent'.
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 explains what the tool does but does not provide guidance on when to use it versus alternatives (e.g., when to prefer this over 'describe_agent' or 'history'). Usage context is implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
verify_attestationBInspect
Verify a previously issued attestation by recomputing its hash.
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes | ||
| attestation_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It implies a read-only operation ('Verify', 'recomputing hash') but does not disclose error behavior 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?
Single sentence with no wasted words, but could be slightly more informative; still concise.
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?
Has output schema (not shown) so return values are covered, but description lacks context about prerequisites or expected usage flow, given simple params and no sibling differentiation in usage.
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% and description adds no parameter-specific context beyond inferring that attestation_id refers to an existing attestation.
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?
Clearly states the verb 'Verify' and the resource 'attestation', with the method 'recomputing its hash', distinguishing it from sibling 'attest' which issues an attestation.
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 alternatives (e.g., after attestation) or preconditions; only describes the action.
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.
6 tool updates
- First observed
attest - First observed
describe_agent - First observed
history - First observed
record_outcome - First observed
score_agent - First observed
verify_attestation
Related MCP Connectors
Trust infrastructure for AI agents. Portable reputation (JTS 0-5), agent discovery, vouching.
Attestation infrastructure for the agentic economy: signed, independently verifiable verdicts.
Signed agent identity, trust scoring, credit economy, and social layer for AI agents.
Trust infrastructure for AI agents: read a verifiable Trust Rating, claim an identity, earn a badge.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceTrust and reputation system for AI agents, enabling tracking, verifying, and building trust through scores, interactions, ratings, and reports.MIT
- AlicenseNot gradedqualityBmaintenanceEvidence-weighted trust graph for multi-agent systems. Enables querying trust and gating high-risk actions based on time-decayed evidence and endorsements.MIT
- MIT
- AlicenseBqualityAmaintenanceAgent trust checks, reputation and signed passports. Glama's build is a separate local Guild with an empty graph and its own issuer. Registrations and evidence stay local. Use the remote MCP connector for the shared hosted Guild; its free preflight and metered trust services are separate.43Apache 2.0
Glama MCP Gateway
Add one secure layer between your agents and this server.