Spans for what an agent did, receipts for proof it did it. This hub covers OTLP/JSON gen_ai trace tooling: composing a resourceSpans/scopeSpans/spans trace by hand with gen_ai attribute presets for invoke_agent, chat, and execute_tool spans, and linting any OTLP/JSON trace against a pinned semantic-convention snapshot. Runs entirely in your browser: no OTLP collector, no network export, no account.
A composer and a linter for OTLP/JSON gen_ai traces, in one page.
Snapshot-pinning caveat: the gen_ai semantic-convention namespace (open-telemetry/semantic-conventions-genai) has no tagged upstream releases. The linter checks your trace against an attribute set pinned as of the tool's semconv_snapshot value, not against a released standard. Every artifact this tool emits stamps its snapshot version so a lint result stays traceable to the rules it was actually checked against, but expect upstream churn: re-check older traces if the snapshot moves.
Compose a hand-rolled OTLP/JSON trace: resource attributes, spans with hex traceId/spanId, nanosecond timestamps, parent links, attributes, and events. gen_ai presets build an invoke_agent span with child chat/execute_tool spans carrying the pinned gen_ai.* attribute set (request.model, usage.input_tokens/output_tokens, tool name, and more). Paste in existing OTLP/JSON to edit it, or switch to linter mode to validate structure and gen_ai attribute conformance against the pinned snapshot. Zero network export: everything stays in the browser and exports to a file.
v1.0 · Jul 2026 · 1 Tool · Cat-MCP · Agent Observability
A 2026 paper on the Sello protocol (arXiv 2606.04193, "Notarized Agents: Receiver-Attested Confidential Receipts for AI Agent Actions") names a failure class this estate has documented internally under a different name: a self-consistent writer validating its own claim about itself. Its framing is worth restating plainly, because the OTLP spans this hub composes above sit squarely inside the problem it describes.
The critique, quoted from the paper's spec: "the entity producing the activity log is the same entity whose activity is being logged." An OTLP trace composed above is exactly that: the agent (or its own instrumentation) writes the spans describing what the agent did. A compromised or buggy agent can omit, alter, or fabricate that trace, and nothing structural in OTLP catches it. The composer and linter on this page validate a trace's shape and semconv conformance, never the truth of its contents, and the tool has never claimed otherwise.
The agent's own runtime emits the trace. Structurally sound, semconv-checkable, but the writer and the subject are the same party. Good for debugging and dashboards; not evidence against a disputed claim.
The called service signs a receipt of what it observed (COSE_Sign1 / Ed25519), HPKE-encrypts it to the agent owner's key, and publishes it to a witness-cosigned Merkle transparency log. The owner discovers and decrypts independently of the agent or its operator. Proves the call happened as the receiver saw it.
Every OCG kernel emits an execution_hash over a canonical (JCS) preimage that anyone can recompute from the same inputs, then anchors that digest to third-party time via Sigsum's witness-cosigned transparency log (12 pinned cosigners). Proves the computation is re-derivable by anyone, not just attested by one party who saw it happen.
{
"receipt_body": {
"agent-identifier": "9f2c...redacted",
"action-type": "invoke_agent.execute_tool",
"action-input-hash": "sha256:3a7e...(synthetic)",
"action-output-hash": "sha256:c091...(synthetic)",
"result-status": "success",
"timestamp": "2026-08-30T00:00:00Z"
},
"cose_sign1_header": {
"alg": "EdDSA",
"kid": "svc-key-01 (synthetic)",
"sello_version": "0.1.0",
"sello_token_ref": "sha256:71bd...(synthetic)",
"sello_log_url": "https://example-log.invalid/v1"
},
"jws_payload": {
"owner_hpke_pk": "base64url-x25519-pk (synthetic)",
"sello_logs": ["https://example-log.invalid/v1"]
}
}
Field names quoted verbatim from the Sello reference spec (SPEC.md §3.1, §5.1, §5.3), attributed to arXiv 2606.04193; every value above is invented for illustration and matches no real Sello deployment. This estate does not implement Sello, does not call any Sello log, and this fixture never leaves this page.
These are complementary, not competing. Sello's receiver-attestation answers a question deterministic recompute cannot: what did a third party actually observe at call time, when the "correct" output is not independently recomputable (a discretionary approval, a human-in-the-loop decision, a call to an opaque external system). Recompute-based anchoring answers a different question: given fixed inputs and a public kernel, is this exact output the one a fixed procedure produces, checkable by anyone, forever, with no reliance on any single receiver staying honest or online. A workflow that combines both, an opaque call receiver-attested via Sello, chained into a deterministic kernel anchored the way this estate anchors, would close gaps neither covers alone. Read more on how this estate's anchoring model works on the evidence estate explainer.
Open T556 and build an OTLP/JSON trace from a gen_ai preset, or paste in a trace exported from your own agent run. The composer fills in hex traceId/spanId, nanosecond timestamps, and parent-span links so the output loads clean in any external OTLP viewer.
Switch to linter mode and paste in any OTLP/JSON trace. The tool checks structural validity and gen_ai attribute conformance against its stamped semconv_snapshot, flagging missing or malformed attributes before the trace goes anywhere near a dashboard.
Build a reference OTLP/JSON gen_ai trace for a new agent workflow before wiring up a real collector, or lint traces your agents already emit to catch missing gen_ai attributes early.
Check third-party or in-house agent instrumentation against the pinned gen_ai attribute set without standing up an OTel collector. Useful for reviewing a vendor's trace export before it enters your pipeline.