Skip to main content
Glama

FaultKey · CausalLayer

submit_otel_trace

Convert an OpenTelemetry OTLP JSON trace into a FaultKey incident and return the same deterministic CausalCertificate as submit_incident. Each span becomes an event; service.name groups spans into agents; W3C trace_id and span_id propagate as evidence pointers on the causal graph edges. Cost: 50 credits (same as submit_incident). Three guardrails apply: PII scan, deterministic-only acknowledgement, and minimum evidence (auto-satisfied when the trace has at least 1 span).

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
otlpYesOTLP JSON payload with resourceSpans[]. See https://opentelemetry.io/docs/specs/otlp/#json-protobuf-encoding
titleYes
categoryNo
currencyNo
jurisdictionNo
pii_acknowledgedNoG1: Set to true ONLY if PII handling is permitted by your data agreement. OTLP traces frequently leak user/session ids in attributes.
deterministic_onlyYesG2: Must be true. Acknowledges CausalLayer is deterministic.
financial_impact_centsNo

TDQS

A4.4/5.0
Behavior5/5

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

With no annotations provided, the description carries the full burden and does an excellent job: it discloses the cost (50 credits), the three guardrails (PII scan, deterministic-only, minimum evidence), and the trace-to-incident mapping details (span/event, service.name grouping, evidence pointer propagation). This gives the agent critical behavioral context beyond the schema.

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

Conciseness5/5

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

The description is four sentences, each adding distinct value: primary purpose, mapping logic, cost, and guardrails. It is front-loaded with the main action, uses semicolons for compactness, and contains no filler or redundancy. Every sentence earns its place.

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 complexity and lack of output schema, the description covers the major aspects: purpose, mapping, cost, and guardrails. However, it leaves some ambiguity about behavior in edge cases (e.g., zero spans) and does not explain the return format beyond 'CausalCertificate' (though that is presumably covered by submit_incident). The schema fills some gaps, so the overall package is strong but not exhaustive.

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 only 38%, so the description needs to compensate. It adds meaningful context for some parameters via guardrails (PII scan aligns with pii_acknowledged, deterministic-only aligns with deterministic_only) and mentions OTLP payloads, but it does not explain the remaining parameters (title, category, currency, jurisdiction, financial_impact_cents). While it partially fills the gap, it falls short of fully compensating for low schema coverage.

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 converts an OpenTelemetry OTLP JSON trace into a FaultKey incident and returns a CausalCertificate, distinguishing it from submit_incident by referencing the same certificate. It also specifies the mapping behavior (spans to events, service.name to agents) and propagation of trace/span IDs, making the purpose specific and unambiguous.

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?

It implicitly tells when to use the tool (when you have an OTLP trace) by stating its core function, and it relates to submit_incident by noting it returns the same certificate. However, it does not explicitly state when not to use it or provide direct alternatives beyond mentioning submit_incident. This is clear enough for an agent to infer, but a more explicit comparison would improve it.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

TDQS

A4.2/5.0
Disambiguation4/5

Most tools have distinct purposes, but submit_incident and submit_otel_trace both create certificates from different input sources, and verify_certificate and verify_certificate_recompute both verify but via different methods. Descriptions and input types make them distinguishable, so ambiguity is low.

Naming Consistency4/5

All names use snake_case and generally follow a verb_noun pattern (e.g., submit_incident, verify_certificate). Deviations like verify_certificate_recompute (verb_noun_modifier) and evaluate_prospective_response (verb_adjective_noun) are minor and remain predictable.

Tool Count5/5

10 tools is well within the ideal 3-15 range and maps cleanly to the domain: incident submission, text extraction, pre-response gating, certificate verification, remediation simulation, jurisdiction analysis, and issuer/anchor metadata queries. Each tool serves a distinct workflow step without redundancy.

Completeness4/5

The core lifecycle (extract → submit → verify → analyze) is well covered. However, several tools reference external catalog endpoints (e.g., /jurisdiction/catalog, /remediation/catalog, /gate/thresholds) that are not exposed as MCP tools, forcing an agent to make separate HTTP calls to use these tools effectively. This is a minor workaround, not a critical gap.