silicon_truth_bridge

by nomatic163

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation4/5
Most tools are clearly distinct, especially with object_* and wave_* prefixes. The only potential overlap is between trace and connectivity_direct, but the descriptions differentiate a general graph from a one-hop direct query. Specialized trace tools like trace_active_driver and trace_value_origin have specific purposes, reducing ambiguity.
Naming Consistency3/5
Snake_case is used consistently, but the verb/noun arrangement is mixed: some are verb-first (trace, catalog), some are noun-verb (context_manage, object_resolve), and some are noun-noun (wave_value, source_context). There is structure via prefixes like object_ and wave_, but no uniform pattern across all tools.
Tool Count4/5
The 17 tools are slightly above the ideal range but each addresses a distinct aspect of hardware design analysis, such as context lifecycle, object querying, tracing, waveform data access, and mapping. The count is justified by the breadth of the domain and does not feel bloated.
Completeness4/5
The toolset provides strong coverage for a read-only analysis bridge: lifecycle management for contexts and waveforms, object resolution/query/traversal, multiple trace types, waveform value/changes/compute, source context, and mapping. Minor gaps like an explicit list-scopes tool are likely covered by catalog, but overall the surface is comprehensive.
Average 2.9/5 across 17 of 17 tools scored. Lowest: 1.8/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries the full burden of disclosing behavior. It fails to mention side effects, permissions, or what 'manage' entails. The only hint is 'asynchronous jobs,' which is insufficient to understand the tool's behaviors or limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one short sentence, so it is not verbose, but it is under-specified rather than cleanly concise. It omits critical information that the tool's action-dispatch pattern requires. This is not a case of concise adequacy but of insufficient substance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (action dispatch, async jobs, output schema) and lack of annotations or parameter descriptions, the description is extremely incomplete. It does not enumerate valid actions, explain the request schema, or describe return behavior, making it nearly impossible for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has a required 'action' string and an optional 'request' object, but both lack descriptions. The description adds no parameter details, leaving the meaning of 'action' and the structure of 'request' entirely unknown. With 0% schema coverage, this is a significant gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the generic verb 'manage' and names two resources: evidence artifacts and asynchronous jobs. It vaguely suggests scope but does not specify the operations (create, update, delete, etc.) nor does it clearly differentiate from sibling tools like object_get or catalog. 'Bounded' adds slight context but remains ambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. The description does not mention any conditions, exclusions, or preferred scenarios. It only implies a domain (artifacts and jobs) without offering decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits beyond stating it runs an operation. It does not mention side effects, read-only nature, return format, or edge cases, which is especially insufficient for a complex tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words and is front-loaded with the main action. However, its brevity omits critical details, and the term 'typed bounded' is unclear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complex schema with many fields and no annotations, the description is severely incomplete. It fails to explain what a 'waveform operation' entails, how to construct the request, or important constraints, making it inadequate for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not explain the context_id or the request structure. It only lists some operation values, which are nested inside the request object, providing minimal parameter meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool runs a waveform operation and lists examples like sample, statistics, and compare. It conveys the core purpose but does not explain what these operations do or how this tool differs from sibling wave tools such as wave_value or wave_changes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 tool versus alternatives, no prerequisites, and no exclusions. The description merely lists operation names without providing context for appropriate use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. 'Discover' implies a read-only operation, but no explicit mention of safety, side effects, or behavior is made. Pagination (cursor, limit) and filtering capabilities are not disclosed, leaving the agent unaware of how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short but under-specifying. While brevity is good, the single vague sentence does not earn its place because it omits essential information. The structure is fine, but the content is too sparse to be useful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (3 parameters, nested filters, an output schema, and numerous sibling tools), a one-sentence description is far from complete. It does not explain the purpose of kind or filters, nor the context_id requirement. The agent cannot confidently invoke the tool based on this description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
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 meaning to parameters like context_id, filters, or kind. It merely lists a few enum values already visible in the schema, failing to explain their semantics or usage. For a tool with a complex nested filter object, this is a critical gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'Discover' and names specific catalog entities (models, properties, relations, operators), giving a clear sense of what the tool provides. However, it omits other kinds present in the schema (e.g., object_types, semantic_classes, limits) and does not distinguish from sibling tools with overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 like object_query or object_resolve. It lacks any context about appropriate scenarios, prerequisites, or exclusions, leaving the agent without decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It lists actions but does not explain side effects, whether operations are destructive, or what 'status' and 'release_objects' entail. The description lacks critical details about state changes and requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief and grammatically structured as a single list, but it is under-specified. It lacks the detail needed to be effective, so the brevity is a deficiency rather than a virtue.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, multiple actions, an output schema, and nested spec objects), the description is grossly insufficient. It fails to explain the tool's role within the wider context of sibling tools or how the parameters relate to the actions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero parameter descriptions, and the description does not compensate by explaining the parameters. The action enum is mentioned, but parameters like context_id, backend, wave_specs, and design_spec are completely unexplained, leaving the agent without meaning for these fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly lists the operations (open, reload, close, list, get status, release) and identifies the resource (context objects), making the tool's purpose clear. It does not explicitly differentiate from sibling tools, but the scope is distinct enough to be understood.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, nor does it mention any prerequisites or context. It implies usage only through the listed actions, leaving the agent without sufficient decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/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 of behavioral disclosure. It only mentions 'bounded depth' and 'cataloged relation', failing to state read-only nature, pagination via cursor, filtering behavior, max_nodes limits, or error cases. This is a significant gap for an operation that likely traverses a complex graph.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with zero wasted words. However, given the tool's complex nested schema, such extreme brevity borders on under-specification rather than being appropriately sized, so it doesn't earn a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a highly complex input schema with nested filter structures, no annotations, and an output schema (per context). The description covers only the basic traversal concept, omitting filtering, pagination, max_nodes constraints, and context_id semantics. The output schema mitigates return-value description needs, but the input side is still critically incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description compensates only for 'roots' (ObjectRef roots) and 'depth' (bounded depth). It ignores critical parameters like filters, cursor, max_nodes, wave_id, and relation, leaving the agent to infer their meaning from the raw schema. The complex Where* filter types are entirely unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the operation ('Traverse') and the resource ('cataloged relation') with specific modifiers ('ObjectRef roots', 'bounded depth'). This distinguishes it from object_get and object_query by focusing on relation traversal. However, it doesn't explicitly differentiate from the sibling tool 'trace', 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives like object_query or trace. The description does not mention any exclusions, prerequisites, or contextual conditions; the only hint is the verb 'Traverse', which merely implies a use case rather than stating it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose whether the tool is read-only, has side effects, requires special permissions, or what the output represents. 'Trace' implies a read operation, but this is not explicit. The description adds some context about state boundaries and wave time, but not enough to understand behavioral implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the core purpose. No filler or repetition. It is appropriately sized for a simple purpose statement, though it sacrifices detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has a complex nested request schema, many sibling tools, and no annotations, the description is severely incomplete. It does not explain return values, usage context, parameter structure, or how it differs from other trace tools. The output schema exists but the description does not help an agent understand what to expect or how to construct an invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not explain any parameter semantics. It hints at 'wave time' mapping to the 'time' field and 'sampled value' to 'signals', but does not clarify the required 'context_id' or the nested 'request' structure. The description fails to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('trace') and resource ('sampled value origin') with scope ('across state boundaries at a wave time'). It distinguishes from general 'trace' and sibling tools like 'trace_active_driver' by specifying the sampling and state-boundary context, but does not explicitly contrast with alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 like 'trace_active_driver' or 'wave_value'. There is no mention of prerequisites, suitable scenarios, or exclusions. The only implied usage is a tracing scenario, but no explicit context is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 of behavioral disclosure. It says 'read' (suggesting non-destructive) and 'bounded' (implying limits), but does not disclose details about pagination, direction, max_changes, cursor behavior, or any side effects. The schema reveals parameters like direction and max_changes, but the description does not explain their behavioral implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundant information. It is front-loaded with the core action ('Read bounded waveform transitions') and then specifies key requirements. It is appropriately sized for the information it conveys, though it could be slightly more detailed without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple parameters, output schema, sibling tools), the description is severely under-specified. It does not explain return values, pagination behavior, direction semantics, or when to use this tool over alternatives. The output schema exists but does not compensate for the lack of context in the description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so the description must compensate, but it only names three required parameters (signals, start, end) without explaining their meaning or format. Other parameters such as cursor, wave_id, direction, and max_changes are not mentioned at all. The description adds minimal semantic value beyond the parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Read bounded waveform transitions.' This uses a specific verb ('read') and resource ('waveform transitions'), giving a clear purpose. While it doesn't explicitly contrast with sibling tools like wave_value or wave_compute, the phrase 'bounded' hints at a scoped read, which helps distinguish it from other wave-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description only states 'Request requires signals, start, and end,' which specifies input requirements but provides no guidance on when to use this tool versus alternatives like wave_value or wave_compute. There is no mention of use cases, exclusions, or alternative selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates a read operation but does not explain the bounded nature, required object resolution, or any side effects or limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, terse sentence with no wasted words. However, it is arguably too sparse for the tool's complexity, warranting a slight deduction.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the complex nested schema and no annotations, the description gives only a one-line summary. It does not cover usage context, parameter behavior, or output characteristics, leaving significant gaps for such a complex tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
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 does not explain any of the two top-level parameters (context_id, request) or the nested request fields, providing no semantic value beyond the schema's field 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 uses a specific verb ('Read'), names the resource ('bounded source context'), and specifies the anchor ('exact ObjectRef'), making it clear what this tool does and distinguishing it from sibling tools like trace or object_get.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 like trace or object_resolve. It does not state prerequisites or exclusions, leaving the agent to infer usage 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It mentions 'deterministic' and enumerates actions, but does not disclose side effects, permissions, or output behavior. The action list is already present in the schema, so the added behavioral transparency is limited to the word 'deterministic'.
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 a single, front-loaded sentence that conveys the core purpose efficiently. There is no wasted wording, and it provides a concise high-level summary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the rich, nested input schema (MappingRequest, MappingProfile, rules, etc.), the description is minimal and fails to explain important concepts like when to provide a profile versus pairs, what 'context_mode' means, or how actions differ. Even with an output schema, the tool's complexity demands more contextual guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no information about context_id, request, profile, pairs, or context_mode. The complex input schema requires explanation, but the description offers none, leaving the agent to interpret cryptic field names like 'request' without guidance.
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 clearly identifies the tool's purpose: resolving, validating, or explaining deterministic design-to-wave mappings. This specific resource ('design-to-wave mappings') distinguishes it from sibling tools like trace, catalog, and wave_manage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 like object_resolve or trace. It does not mention suitable contexts, exclusions, or preference over sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden. It does not disclose side effects, permissions, error behavior, or what 'resolve' does under the hood. The only behavioral detail is the default model, which is more of a parameter semantic.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded with the core purpose. The second sentence provides a concrete usage example without redundancy. It is efficient for the information it conveys.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values are covered. However, the description omits the role of context_id, the purpose of npi_type/object_id, and how this tool relates to sibling tools. It covers the main use case but is not complete for the full parameter space.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description compensates partially by explaining the model parameter (default netlist) and the waveform-specific requirements for wave_id and name. However, it leaves npi_type, object_id, and context_id unexplained, so coverage is incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action: 'Resolve an exact object', which implies a precise lookup rather than a query or traversal. It distinguishes from siblings like object_query or object_traverse by the word 'exact', though it doesn't explicitly contrast with object_get.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a specific usage pattern ('For waveform signals set model='waveform', wave_id, and name') but provides no guidance on when to use this tool versus alternatives like object_query or object_get. It does not mention exclusions or direct comparison to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only restates the action enum from the schema. It does not mention side effects, required context_id semantics, permission implications, or what happens when attach/reload/detach are performed.
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 a single concise, front-loaded sentence that efficiently enumerates the tool's operations. No filler or unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a multi-action tool with 4 parameters and no annotations, yet the description offers no parameter guidance, usage context, or behavioral details. The output schema exists but the description still leaves significant gaps for correct invocation (e.g., which parameters are needed for attach versus list).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
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, but it only lists actions already present in the schema enum. It gives no meaning for path, wave_id, or context_id, leaving the agent without clues about required or optional parameter combinations for each action.
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 clearly states the tool's purpose: managing waveform resources via attach, reload, detach, list, or status actions. This is specific and distinct from sibling tools like wave_value or wave_changes, which focus on reading values or changes rather than lifecycle management.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, nor any exclusions or prerequisites. While the action list implies usage, there is no explicit context about selecting wave_manage over wave_value or wave_compute for particular tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. The term 'bounded' hints at limit enforcement, but the description omits details about pagination, cursor, max_scan limits, read-only behavior, or return semantics. It adds little beyond parameter hints.
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?
Two short sentences lead with the core purpose and then provide parameter setup guidance. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complex input schema with recursive Where clauses and many optional parameters, plus no annotations, the description is far too sparse. It doesn't explain the query semantics, pagination, or role of context_id. Even with an output schema, the tool is under-described.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description names only model, scope, npi_types, semantic_classes, and wave_id, and omits the crucial 'where' filter, limit, cursor, max_scan, allow_global, and the nested request/context_id structure. The schema itself is highly detailed but description doesn't explain how to construct a query.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Run a bounded declarative object query,' specifying the verb and resource clearly. It distinguishes from siblings by describing a declarative, bounded query rather than a direct get/traverse, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides conditional guidance: 'waveform queries also require wave_id' and suggests which fields to set. However, it doesn't explain when to choose this tool over object_get/object_traverse or provide alternative tool names, leaving usage largely implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. The word 'bounded' hints at limits (max_depth/max_nodes), and 'Return' implies a read operation, but the description does not disclose edge cases, errors, cost, or what the evidence graph contains. This is insufficient for full transparency.
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 a single sentence, front-loaded with the verb 'Return'. It is concise and every word adds value (e.g., 'bounded', the enumerated kinds). No wasted content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the tool is complex with a nested request object containing six sub-parameters. The one-sentence description does not provide enough context for correct invocation, such as the role of roots, stop_at, or targets, or how the graph is constructed. It is far from complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should compensate by explaining parameters. It lists the 'kind' values (driver, load, path, fanin, fanout) but provides no explanation of 'roots', 'stop_at', 'targets', 'max_depth', or 'max_nodes'. It adds minimal value beyond the schema.
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 clearly states the tool's function: 'Return a bounded driver, load, path, fanin, or fanout evidence graph.' It names the specific resource (evidence graph) and enumerates graph types, distinguishing it from more specific siblings like trace_active_driver and trace_value_origin.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 use cases, prerequisites, or exclusions. The agent is left to infer applicability from the enum values in the schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits but only states the action without explaining what 'feasible' means, whether the operation is read-only, or what the output represents. The parameters max_depth and max_nodes hint at traversal limits, but these are not described, leaving significant ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words, making it concise and well-structured. However, it sacrifices necessary detail for brevity, so it does not achieve a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a complex schema with multiple parameters and an output schema, but the description gives no indication of the return format, the meaning of 'feasible,' or how max_depth and max_nodes affect results. It lacks critical context for an agent to handle complex trace scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions 'signals' and 'wave time,' which map to the 'signals' and 'time' fields, but it does not explain the purpose of 'context_id,' 'wave_id,' 'max_depth,' or 'max_nodes.' With 0% schema description coverage, the description fails to compensate for these parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Evaluate' and identifies the resource as 'active and feasible driver branches for signals at a wave time,' clearly indicating the tool's function. It does not explicitly differentiate from sibling tools like 'trace' or 'trace_value_origin,' but the focus on 'driver branches' provides some distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use the tool: when evaluating driver branches for signals at a wave time. However, it provides no explicit alternatives or exclusions, so it falls short of the highest score but is better than merely vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the transparency burden. It does disclose that the tool returns one-hop driver/load evidence and requires exact signal names, which are meaningful behavioral constraints. However, it does not mention error behavior, return format, or how bit_mode/npi_type affect results. The description provides basic transparency but lacks depth.
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 a single, clear, and front-loaded sentence with no unnecessary words. It conveys the essential information efficiently and is 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema (which covers return values), the description is too brief to be complete. With no annotations and zero schema parameter descriptions, the description does not explain the purpose of bit_mode or npi_type, nor does it provide guidance on how to construct the request object. The tool is simple, but the description leaves key usage gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 mentions 'exact design signal names' (relating to signals) and 'driver or load' (relating to kind), but these are already evident from the enum. The description provides no information about bit_mode, npi_type, context_id, or the request structure, leaving significant semantic gaps.
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 uses a specific verb ('Return') and a clear resource ('one-hop driver or load evidence for exact design signal names'). It explicitly scopes the operation to one-hop connectivity and exact signal names, distinguishing it from sibling tools like trace (which likely traverses multiple hops) and wave tools (which provide waveform data).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'one-hop' implies a use case: when you need only direct connectivity, not a full trace. However, there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions. The usage is implied by the description's scope rather than stated directly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It indicates a safe read operation but does not disclose behavior like error handling, truncation via max_chars, or behavior with invalid references. The constraint 'exact ObjectRef entries' adds some transparency about required inputs.
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 a single, compact sentence that immediately conveys the core action and scope. It uses no unnecessary words and is well-suited for quick parsing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a nested request schema and output schema, but the description gives only the core use case. It omits the optional configurable aspects (like property selection, character limits, relation inclusion), leaving the agent to infer those from the schema. While not incomplete to the point of unusability, more context would help.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, yet the description only vaguely references 'ObjectRef entries' and 'properties', aligning with two schema fields but omitting others like max_chars, include_available_relations, and wave_id. It does not compensate for the low coverage with parameter-specific details.
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 clearly states the tool reads properties for exact ObjectRef entries, using a specific verb ('Read') and resource ('properties for exact ObjectRef entries') and distinguishes from siblings like object_resolve and object_query by focusing on already-resolved entries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use it: after receiving ObjectRef entries from resolve or query. It does not explicitly list alternatives or exclusions, but the 'returned by resolve or query' provides clear context that narrows its purpose relative to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. The verb 'Read' implies a non-mutating operation, and it discloses the wave_id condition, but it does not explain error behavior (e.g., if wave_id omitted with multiple waves) or any other 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences cover the core purpose and key usage requirements without unnecessary detail. Front-loads the primary verb and object.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the presence of an output schema, the description provides sufficient context for standard usage. It omits explanation of context_id and the 'typed' aspect of values, but these are not critical for operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 adds meaning for times by giving a concrete unit-bearing example ('200ns') and explains when to set wave_id, but signals and context_id are left unnamed and unexplained.
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 opens with 'Read typed waveform values,' which clearly states the action (read) and the object (typed waveform values), distinguishing it from wave_manage (management) and wave_compute (computation). The mention of signals and times further specifies the scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear usage context by specifying required inputs (signals, unit-bearing times) and a conditional parameter (wave_id when multiple waves are attached). Does not explicitly name alternative tools or exclusions, but the usage is well-contextualized.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![silicon_truth_bridge MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/nomatic163/silicon_truth_bridge/badges/card.svg)](https://glama.ai/mcp/servers/nomatic163/silicon_truth_bridge)

Score Badge

Copy to your README.md:

[![silicon_truth_bridge MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/nomatic163/silicon_truth_bridge/badges/score.svg)](https://glama.ai/mcp/servers/nomatic163/silicon_truth_bridge)

shields.io Endpoint

For READMEs with an existing badge row. Append &style=flat-square (or any other shields.io style) to match the rest, and &metric=tools, &metric=maintenance or &metric=claim to badge a different dimension.

[![silicon_truth_bridge MCP server — quality and maintenance score on Glama](https://img.shields.io/endpoint?url=https%3A%2F%2Fglama.ai%2Fmcp%2Fservers%2Fnomatic163%2Fsilicon_truth_bridge%2Fbadges%2Fshields.json)](https://glama.ai/mcp/servers/nomatic163/silicon_truth_bridge)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/nomatic163/silicon_truth_bridge'

If you have feedback or need assistance with the MCP directory API, please join our Discord server