Rightshold™ Sign up

Answers · AI evidence

We already trace every LLM call in LangSmith or Langfuse. Is that an audit trail we can rely on if an AI answer is disputed?

Last updated

TL;DR: Not on its own. Tracing tools such as LangSmith and Langfuse are built for debugging and evaluation, and their defaults show it. LangSmith keeps base traces for 14 days and extended traces for up to 180 days on its cloud service, then deletes them, and traces can be deleted before then. Langfuse lets users delete a trace from the UI or with DELETE /api/public/traces/{traceId}, lets project owners and admins set a retention period as short as 3 days, and its SDKs can sample, so with a sample rate of 0.2 only 20% of traces are kept at all. An audit trail has to be complete (every answer, not a sample), protected from change or deletion by the people it may be used against, and kept for as long as a dispute can arrive. NIST SP 800-53 puts the second point plainly in AU-9: protect audit information from unauthorized access, modification and deletion. Keep the tracing tool for what it's good at, and add an append-only record at the point each answer goes out: a hash of the request and response, recorded outside the tracing tool, with the full trace exported to storage your team can't quietly edit.

What should I check, step by step?

1. Check sampling first. In Langfuse, LANGFUSE_SAMPLE_RATE or sample_rate below 1 (or an OpenTelemetry sampler) means some answers were never traced. An audit record needs every answer that reached a customer.

  1. Check retention. LangSmith cloud: base 14 days, extended up to 180 days. Langfuse: no automatic deletion unless a project retention period is set, but owners and admins can set one as short as 3 days. Compare that with how long complaints, chargebacks and claims can take to arrive.
  2. Check who can delete. In Langfuse anyone with delete rights can remove a trace in the UI or by API, and Langfuse says data removed by retention can't be recovered. In LangSmith traces can be deleted before they expire. List who holds those rights, including API keys used by apps and agents.
  3. Check what the trace holds: the exact request with system prompt, retrieved context and tool results, the raw output, the model value the provider returned, settings, and the provider's request id. Debug traces often truncate, redact or summarize, which is fine for debugging and not for evidence.
  4. Add a record that sits outside the tracing tool: at send time, hash the request and response and record the hash somewhere append-only that your own admins can't edit, with the trace id alongside so the two can be matched later.
  5. Export full traces to write-once storage on a schedule (Langfuse offers blob storage export to S3, GCS or Azure; S3 Object Lock in compliance mode or a locked Cloud Storage bucket stops early deletion).
  6. Keep evals and audit records apart. An eval dataset built from traces measures quality across chosen cases; it doesn't show what one customer was told. Saving a trace to a dataset copies selected fields, not the whole trace.

What are LLM tracing tools like LangSmith and Langfuse designed for?

Debugging, monitoring and evaluation: seeing why a chain failed, what it cost, how long it took and how answers score. For those jobs, sampling, short retention and easy deletion are features. They cut cost and make it simple to remove test traffic or a user's data on request.

What does an AI audit trail need that an observability trace doesn't provide?

Complete: one record for every answer that reached a person, written at the time, not a sample.

How do I use LLM tracing and an audit trail together?

Keep tracing as it is. At the point the answer goes out, compute a SHA-256 of the exact request and response the trace captured and record it, with the trace id, in an append-only record outside the tracing tool.

How do I ask Rightshold about this (free, no key)?

Add the MCP server https://www.rightshold.com/mcp to Claude, Cursor, ChatGPT, Grok or VS Code, then ask: “When this traced answer goes out, record a signed receipt with the model, hashes of the request and response the trace captured, and the trace id, so we can check later that the trace wasn't changed.”

One-click setup

{
  "tool": "record_ai_run",
  "arguments": {
    "model": "<model value from the response>",
    "provider": "openai",
    "prompt_sha256": "<sha256 of the request JSON in the trace>",
    "output_sha256": "<sha256 of the response JSON in the trace>",
    "params": {
      "trace_id": "<LangSmith or Langfuse trace id>",
      "request_id": "<x-request-id from the provider>",
      "sample_rate": 1
    },
    "ran_at": "2026-11-09T22:00:00Z"
  }
}

Rightshold doesn't connect to LangSmith, Langfuse or any tracing tool, and it doesn't store your traces. It signs and timestamps the hashes you send and lets anyone check them later. Retention and deletion details above are from each vendor's docs as of November 2026 and vary by plan and self-hosting; check your own settings. Not legal advice.

What are the sources?

Related

Not legal advice. JSON · Markdown · All answers

Get a free API key in one call

No card and no email needed. 100 free credits; the license and policy checks stay free without a key.

curl -s -X POST https://www.rightshold.com/v1/accounts/signup -H "Content-Type: application/json" -d '{"accept_terms":true}'
export RIGHTSHOLD_API_KEY=rs_...   # the api_key from the reply (shown once)
curl -s https://www.rightshold.com/v1/licenses/check -H "Authorization: Bearer $RIGHTSHOLD_API_KEY" \
  -H "Content-Type: application/json" -d '{"license":"MIT","intended_use":{"commercial_use":true}}'