LangSmith is genuinely good at what it does. If you run agents in production you already know the value: traces, token counts, prompt versions, evaluator scores, a timeline of every call. That data lives in one place, under your account, and it helps you debug, ship faster, and keep cost under control. Most teams use it for exactly those reasons, and they should keep doing so.

The limit appears the moment someone outside your team needs to believe the record.

Observability assumes trust; evidence doesn’t

Observability tools are built for the operator. The data model, the storage, the access controls — all of it assumes the person looking at the dashboard is you, or someone you authorized. That assumption breaks the instant the counterparty is a regulator, an insurer, a plaintiff, or another company with every incentive to doubt you.

A LangSmith trace answers “what did the agent do on this run?” for someone who already trusts the platform. It cannot answer “can a hostile third party verify that this exact decision — this input, this output, this model, at this time — was produced and hasn’t been altered since?” without that third party also trusting LangSmith’s database, its employees, its backup procedures, and its willingness to produce the record on demand.

By evidence I mean a cryptographically verifiable record that anyone can check independently, without relying on — or trusting — the system that produced it. Observability and evidence are different jobs.

What changes when the record has to stand alone

Marturia is built for the second job. At the decision points you choose to protect, the agent emits a receipt that carries its own proof:

The verification doesn’t depend on Marturia staying in business or on you granting access. Ed25519 (RFC 8032) gives deterministic signatures at a 128-bit security level with 32-byte keys and 64-byte signatures — small enough for high-frequency receipts — and hashing is SHA-256. None of it is exotic; that’s the point. Evidence shouldn’t rest on anything you can’t independently check.

flowchart LR
    R1[Receipt 1] -->|hash| R2[Receipt 2]
    R2 -->|hash| R3[Receipt 3]
    R3 -->|chain head| Merkle[Merkle root]
    Merkle -->|cosign| Witness[Independent witnesses]

Where each tool belongs

Question LangSmith (or similar) Marturia
Why did the agent choose this tool? Yes No
What was the prompt at version 17? Yes No
Token usage over the last week? Yes No
Prove to a third party that the input, output, model, and time of this decision haven’t changed No Yes
Require the verifier to create an account? Usually No
Survive the vendor deleting the project? Depends Yes — the receipt is portable

You keep LangSmith for the first three rows. You add Marturia only for the rows that decide disputes.

The scope is deliberately small

Marturia does not replace tracing. It doesn’t store prompts, doesn’t run evals, doesn’t give you a UI for exploring runs. That’s the observability platform’s job, and it’s a good one. Marturia’s only job is to turn a small number of high-stakes decisions — money moving, a compliance-relevant action, a safety-critical call — into independently verifiable facts. Most runs will never touch it.

The integration is small. Where your agent commits to an action you care about, you log it:

import marturia

receipt = marturia.log(decision)   # returns a signed, chained receipt

The receipt is a serializable object you can store next to your normal logs or hand straight to the other party. Later, they (or their auditor) verify it without you:

pip install marturia-verify
marturia-verify --receipt receipt.json --pubkey-hex <tenant-public-key>

It walks the hash chain, checks the Ed25519 signature, confirms the witness-cosigned Merkle root, and either prints a clean pass or shows exactly which link failed.

One honest caveat: this assumes your tenant signing key stays uncompromised and that the witness set keeps its independence. Those are the load-bearing assumptions, and they’re the ones worth scrutinizing.

Why this matters now

Teams are moving from “the model answered a question” to “the agent took an action that can’t be undone without cost.” When that action is later questioned, the question stops being “can we find the trace?” and becomes “can we show the trace wasn’t rewritten after the fact?”

LangSmith will still be where you go to understand the trace. Marturia is where you go when someone else needs to accept that it’s real.

Closed beta is open. You can see what a minimal, independently verifiable receipt looks like in about fifteen minutes:

Related Marturia resources - /guides/marturia-vs-langsmith-vs-sigstore.html - /docs/quickstart.html - /docs/