Contents
Get a scoped quote

AI agent observability and audit trails

For live LLM apps and agents: we add tested alerts and a checkable audit trail to the tracing you already run, or build the whole stack.

Get a scoped quote

First reply within 1 business day

See a sample drill report

Narrated video. It opens on what we build for live LLM apps and agents: three things you get, traces that show what produced each answer, alerts tested with planted faults, and an audit trail you can check, then an agent run traced span by span, with what produced each step. Then an example: a customer is told opened items get a full refund, the answer is wrong, and every alert rule reads OK until a column asks whether any was tested on a planted fault. A model provider's postmortem says it lacked a clear way to connect reports to its recent changes; those faults were inside the provider. Then what Veriprajna builds: traces joined to a ledger of your changes by version ID, every alert rule in scope drilled with a planted fault or listed with the reason, and the trail counted both ways against a gateway log with a random sample rebuilt. The example answer's trace ID opens its audit record in five groups, and the rebuild reports one missing field, the approver. It closes on the next steps and a free 30-minute discovery call.

Fee
Fixed scope and fee agreed in writing before work starts.
Where it lives
Work products in your repository as produced; records kept where you choose.
Duration
Review: 3 to 5 days. Build: 3 to 6 weeks per app or agent. Monthly review optional.

What is AI agent observability, and how does it differ from monitoring?

AI agent observability records each step an LLM app or agent takes (model calls, retrieval, tool calls, handoffs), so you can see why it behaved as it did. Monitoring watches for failures you expected; observability helps you answer why something is happening.

Read more

The same practice is also called LLM observability. The APM and logging you already run still matter, but APM measures speed and errors, not whether an answer is right. An AI trace adds what APM does not record: the model and version that answered, the prompt and settings version, the sources retrieved, each tool call and its result, and each guardrail decision.

The spans to record, and what to alert on, are set out in What to trace.

What is an AI audit trail?

An AI audit trail records who started a decision, which agent acted, with what permission; what it saw; which model and prompt versions produced it; what it did or was refused; the output, and when. It can be checked against independent request or action counts.

Read more

Three checks show whether a trail can be relied on. Coverage counts the decisions in the trail against an independent source for the same period, such as the gateway's request log or the system of record for the agent's actions, in both directions, so missing records and records with no matching request both show. Reconstruction rebuilds a random sample of past decisions from the trail alone, field by field. Integrity looks for later changes to stored records.

How the fields relate to the EU AI Act's logging rules is set out under Standards. An example record is shown under What you get, and why each field is kept is explained under What an AI audit trail must record.

How do LLM evaluation and observability fit together?

Evaluation decides what correct means and scores outputs against it; observability records what happened, turns signals into alerts and keeps the evidence. Alerts on wrong answers need a quality signal: user feedback, or grader scores from an evaluation suite.

Read more

For AI agents, observability and evaluation meet in the same traces: an evaluation suite can score them, and the scores become signals for alerts. Without a quality signal, alerts can watch changes and operations (errors, refusals, tool failures, latency, cost) but cannot tell a right answer from a wrong one.

Where your evaluation suite already scores production traces, we route those scores into quality alerts and dashboards. Building graders, test sets and evaluation gates is a separate service, LLM & Agent Evaluation.

A model provider lacked a clear way to connect reports to changes

Anthropic's postmortem, 17 Sep 2025: "Between August and early September, three infrastructure bugs intermittently degraded 's response quality."

Source: Anthropic, "A postmortem of three recent issues", 17 Sep 2025

If the model behind your app degrades on some requests, your traces should show whether anything changed on your side, and which routes or platforms served the answers users reported.

Read more

The same postmortem names a second obstacle: "Our internal privacy and security controls limit how and when engineers can access user interactions with , in particular when those interactions are not reported to us as feedback. This protects user privacy but prevents engineers from examining the problematic interactions needed to identify or reproduce bugs."

Your own system faces the same trade-off. In a build it is decided field by field in the redaction rules: what a trace keeps readable, what it keeps only as a pseudonymous reference, and who may read which.

The provider names the platforms it serves through: "our first-party API, Amazon Bedrock, and Google Cloud's Vertex AI." Those are choices a deployer makes too, and the platform and route that served each request are recorded in the traces we build.

"Each bug produced different symptoms on different platforms at different rates." "Although we were aware of an increase in reports online, we lacked a clear way to connect these to each of our recent changes." These were faults inside the provider, which your traces cannot see into.

Above the quote, four dashboard panels, Errors, Latency, Tool failures and Cost, each green with a check mark. A customer's screenshot of a chat lands on top of them, stamped "Wrong answer". The chat is an example: the customer asks "Can I return an opened item?" and the assistant replies "Yes, opened items get a full refund."

What you get: Monitoring, and an audit trail you can check

We build on the tracing tool you already run where it fits, or a stack you host, confirmed in the written scope. The record shown is an example.

  • From planted faults on a test environment or replayed traffic, never a production detection rate, your drill report states: decisions in the trail against an independent count, sampled decisions reconstructed, planted edits flagged, alert time per planted fault, rules not drilled, false alerts in a quiet period, and what happened with the trace pipeline or audit store down.
  • What the checks cannot see: faults on signals or routes not instrumented, or below the smallest share detected at your traffic; missing records beyond the independent sources in scope; a wrong value written at the time, since the integrity check finds later changes; and content that is redacted.
  • Giving trail extracts to an auditor or regulator? They are your own records. The drill report is labelled "Tests run by Veriprajna, which built this stack"; no third party may rely on it, and we issue no letters.
  • Traces that carry what produced them: Instrumentation, change ledger, dashboards

    Instrumentation code and configuration for your app or agent. A change ledger joined to the traces: model, prompt and configuration versions, deploys, provider, platform and route, with the principal, agent identity, permission scope, trace and session IDs and delegation on each run. Dashboard definitions as code. The ledger records what your app called and changed, never the provider's internal changes or routing.

  • Alerts tested with planted faults: Change, operational and quality rules, routing, runbooks

    Change, operational and quality alert rules as code, the threshold computation, routing to your on-call and a runbook per rule. The rule-to-fault map ties every rule in scope to the planted fault it was drilled against, and lists every rule not drilled with the reason.

  • An audit trail you can check: Audit store, integrity check, retention

    The audit store configuration: in-scope decisions kept as records that hold references, not content, with refused and denied actions recorded too. A content store with its deletion path. A coverage reconciler that counts in both directions. The integrity check. Retention set to your rules, a storage and sampling plan, and the failure mode for audit writes on each route.

  • Privacy in the traces: Redaction rules, pseudonymous IDs, access settings

    Redaction rules, a pseudonymous ID scheme for users, access settings, and access logging where your store supports it. Where it does not, the handover guide says so.

  • Drill report for your system

    Every figure states its n, its unit and the traffic it ran on: the agreed test environment, or replayed traffic at a stated rate. Each result also says how it was observed: seen by us, on a copy from your export, or confirmed by you.

    • Coverage, both directions: In-scope decisions missing from the trail, and trail records with no matching source record, by count and route; whether the planted gap was flagged.
    • Reconstruction: A random sample from a stated logged period; fields present, linked and version-matched; content checked only where unredacted; misses by field, each confirmed by a person (a miss a model or tool flagged and no person confirmed is listed apart as unconfirmed and not counted), and where none are found, the highest miss rate the sample size still allows at a stated confidence.
    • Integrity: How many planted edits were flagged, out of how many; deletions made on schedule are reported separately and never counted as a flag or a miss.
    • Alerts: For each rule, the planted fault, whether it fired, and the time to alert. For the intermittent fault, the smallest share of requests detected at the stated rate, which is a limit, not a rate. Quality rules count as drilled only where a planted fault moves the quality signal on replayed traffic. Rules not drilled are listed with the reason.
    • Your own faults: A few faults your engineer writes from past incidents and keeps from us, run with the delivered injectors before handover. They print as their own row, run by you, and we see counts only; the injectors and rules are ours. If you decline, the report says every planted fault was known to those who built the alerts.
    • False alerts over a quiet period, stated in requests and hours.
    • With the trace pipeline down, and with the audit store down: Latency, errors, and what happened to in-scope decisions.
    • Production check: Coverage and reconstruction on the early production export, reported separately from the drills.
  • Handover guide

    A handover session and a written guide: How each rule, threshold and runbook works, how to re-run the drills, and how retention and erasure run.

One decision, rebuilt from its audit record
Who and with what permission
principalu_5c1e (pseudonymous ID)present
agentsupport-agent v14present
permissionorders:read, refunds:createpresent
trace, sessiont_91d2, s_40aapresent
delegationfrom triage-agentpresent
What it saw
requestref msg_a17 (content store)present
retrievedkb/returns-policy rev 12present
redactedcard number, addressper your rules
What produced it
modelpinned version IDpresent
promptsupport-prompt v31present
settingsconfig c_208present
platform, routeprovider API, /refundpresent
What it did
tool callrefunds.create, result okpresent
refusedorders.cancel, deniedpresent
guardrailover-limit rule: Holdpresent
approvernone recordedmissing
Output and time
outputref msg_a18 (content store)present
timestart, end (UTC)present
Read more

Drill scripts, delivered with the build. Coverage with one planted gap; a reconstruction sampler; an integrity check with planted edits and a scheduled-deletion control; planted-fault injectors, including an intermittent fault on a share of one route's requests; a false-alert counter; and the pipeline-down and audit-store-down runs. They stay in your repository for re-runs. Any private tooling we use to build and drill stays ours and is not delivered.

How an engagement runs

Start with a review of the records you already keep, or go straight to a build. After a build, a monthly review checks which alerts still fit your app.

Observability and audit-trail review (optional)A reconstruction and coverage check on an export of past decisions, plus a gap map, in a memo you keep.3 to 5 days
Details

Run on a redacted or pseudonymised export of your logs and traces: a random sample of past decisions rebuilt from the records (each counted miss confirmed by a person); coverage in both directions where an independent count source is exported too; a gap map against the audit record's fields and the standards on this page; and gaps in alerts, sampling, retention and erasure. The review is an optional way to try us; the build can always be quoted directly.

Monitoring and audit-trail buildDefaultThe four pillars for one app or agent, drilled on an agreed test environment, then checked on an export of early production records.3 to 6 weeks
Details

What it costs your app: Latency and error results with the trace pipeline down, the expected volume and the running cost at that volume, the storage and sampling plan, the failure mode for audit writes on each route, and the content store and erasure path, all fixed in the written scope.

Production check: It runs on an export covering the first 2 weeks after your go-live and is reported within 5 business days of receiving it, outside the build weeks. If go-live has not happened within 8 weeks of handover, the check is reported as not run and can be quoted separately.

Further apps or agents on the same stack are scoped together in the written scope.

Findings from an audit, ours or another firm's, become alert rules at build, each drilled like any other rule; quality findings are watched only where a quality signal exists. If we validated or independently assured the system, we do no build work on it, monitoring included, for 12 months.

No test environment that can replay traffic? Setting one up as code in your repository is part of the build, quoted in the written scope. Or your engineers set one up to our written specification, and the build weeks start when it is ready. A route still without one is listed as not drilled.

Monthly monitoring reviewAlerts stay with your on-call rota; each month we report which changes moved which alerts, rules gone stale, and proposed threshold changes with false-alert counts.Monthly, scoped in writing
Details

You apply the proposed changes; we hold no repository or alerting access after handover. False-alert counts come from your alert history, using your on-call's acknowledgement or resolution labels. Each quarter you re-run the drills with the delivered scripts, and we review the output; those results are marked as confirmed by you. The data we receive is set out under Working with us. Help investigating an incident is quoted separately in writing.

  • Review: A redacted trace export. Build: A test environment (or we set one up), redacted samples, an independent request or action count, and changes applied.
  • Expect about 2 to 4 hours a week from your platform owner for exports and applying changes, plus PR reviews; fixed in the written scope.
  • Monthly review follows a build, or a review that confirms your change ledger and alert history can be used.
  • Fees are staged in the written scope, so halting costs only the stages reached.

Is this for you?

A fit

  • You already run a tracing tool, but have never checked that its alerts fire on the faults you fear or that its records are complete.
  • When answers go wrong, nobody can say what changed or where.
  • An agent can act or reach customer data, and an auditor, regulator or customer will ask you to reconstruct what it did.

Not a fit

  • Using AI to run your IT operations and infrastructure: a different kind of service.
  • Building graders and evaluation gates: LLM & Agent Evaluation.
  • Investigating an incident that already happened: AI Incident Response.
  • A one-off measurement of how often answers are wrong: AI Hallucination & Output Verification Audit.

Working with us: Your repository, your records, your production data

Here is what we commit to, and how your systems and production data stay protected while we build.

  • A mutual NDA and the written scope are signed before we read your code.
  • Before we read anything, your engineer scans the repository, git history included, and each export for keys and personal data; anything we still find, we report and do not use.
  • No role that can push until your engineer protects the main branch and moves production secrets, CI secrets included, out of its reach, or gives us a separate repository.
  • Changes arrive as pull requests you merge; credentials you issue reach only your repository, CI without production secrets or deploy rights, and staging or test; you revoke them at handover.
  • We ask for production data only as redacted or pseudonymised exports or aggregates; anything identifying that still reaches us is reported to you and not used.
  • Code, exports, samples and test material we receive are deleted on request, or 30 days after our last included work; agreed third-party services follow their data settings, and contract and billing records stay.
  • Drills run only on the agreed test environment or replayed traffic; a route whose only source or tool is shared with production uses a test copy or is listed undrilled.
  • Drill model calls use a non-production key you issue, with a spend limit.
  • We never name you, reference the engagement or publish findings without your written consent.
Read each control in full
  1. 1. A mutual NDA and the written scope are signed before we read your code.
  2. 2. Before we read anything, your engineer scans the repository, git history included, and each export for keys and personal data. Anything we still find is reported so you can rotate or remove it; we do not use it and pause on that file until it is cleaned, and we name any agreed AI tool that had already processed it.
  3. 3. Before we get a role that can push, your engineer protects the main branch and moves production secrets, CI secrets included, out of that role's reach, or gives us a fork or a separate repository. Where a branch cannot be protected, our work goes into a separate private repository you own.
  4. 4. Changes arrive as branches and pull requests you review and merge. Credentials you issue reach your repository, CI without production secrets or deploy rights, and staging or test only, never production stores. You revoke them at handover and issue fresh ones for the 30-day re-run.
  5. 5. We ask for production data only as redacted or pseudonymised exports, aggregates, alert history or change-ledger IDs and metadata, and hold no standing access. Anything identifying that still reaches us is reported to you and not used.
  6. 6. Code, exports, samples and test material we receive are deleted on request, or 30 days after our last included work ends: for a build, the later of the re-run and the production check; for monthly reviews, the last report. Agreed third-party services follow the data settings in the written scope; contract and billing records stay.
  7. 7. Drills run only on the agreed test environment or on replayed traffic. The rules of engagement list every source and tool it reads or writes; a route whose only source or tool is shared with production is drilled on a test copy or listed as not drilled.
  8. 8. Drill model calls use a non-production key you issue, with a spend limit.
  9. 9. We never name you, reference the engagement or publish findings without your written consent.

Access drawing. On your side: your production, with no standing access from us; your repository, where pull requests wait for you to merge; CI without production secrets or deploy rights; and staging or test, where drills run. A route whose only source or tool is shared with production is drilled on a test copy or listed as not drilled. Credentials you issue reach the repository, CI and staging or test only, never production stores, and you revoke them at handover. We ask for production data only as redacted or pseudonymised exports and aggregates.

You get

  • Review memo within 5 business days of receiving your export.
  • Drill report within 5 business days of the build ending; the production check is reported separately.
  • One drill re-run within 30 days of handover, including fixes to defects in what we delivered.
  • Liability capped at the fees paid for the engagement.

A tracing tool alone, or a tested monitoring build

Having a tracing tool leaves this work to your team. Here is what we deliver for each part, confirmed in the written scope.

QuestionLeft to your teamWhat we deliver

Your team picks the decisions and fields, and keeps personal content out of the checked record.

A separate audit store of references, keeping refused and denied actions as records.

You find out when a real fault happens.

Each rule drilled with a planted fault, including a partial fault on one route; undrilled rules listed with the reason.

Your team builds and runs any count against an independent source.

Counts in both directions against your gateway log or system of record, and sampled decisions rebuilt.

Your team joins deploys and other changes to each trace by version.

A change ledger, linked to each trace by version ID.

Your team designs redaction and an erasure path.

Traces redacted before they leave your app, and a content store that can be erased without breaking the integrity check.

How we build monitoring and an audit trail into your app

Four parts, one per pillar, built through pull requests you merge. Select one to see where it sits in the pipeline.

The pipeline: your app or agent sends spans through the trace pipeline to the trace store; in-scope decisions go to a separate audit store, with content in its own store; alert rules read the change ledger and the trace store. Each pillar highlights its part.

Tap a pillar to zoom the map to it.

Pillars

  1. Traces that carry what produced themOpenTelemetry instrumentation where it fits; a ledger entry written on each deploy and configuration change made through your pipeline, joined to traces by version ID.

    Each run gets a trace ID, and each conversation or session an ID that links its runs; a sub-agent handoff carries the parent trace and the scope delegated to it. Model, prompt and settings versions sit on each model call, so a shift in behaviour can be narrowed to a change, route or platform in your ledger. OpenTelemetry's generative AI conventions are still marked as in development, so the attribute names used are pinned in the written scope.

  2. Alerts tested with planted faultsThresholds from your production aggregates; dashboards and alert rules delivered as code you apply.

    Thresholds are computed from a baseline of production aggregates you export, or from a baseline script you run. Signals watched, depending on what your app emits: model, prompt, index and configuration changes from the ledger; errors, refusals, tool failures, latency, cost per feature, guardrail block and approval rates; for scoring models, input drift and outcome rates as labels arrive; and user feedback or grader scores where they exist.

    Each rule is then drilled: a planted fault on the test environment or on replayed traffic, including one that hits only a share of one route's requests, and a quiet period to count false alerts.

  3. An audit trail you can checkA separate store keeps in-scope decisions as references; content sits in a store you can delete from; debug traces sampled per the written plan.

    Each audit record holds pseudonymous IDs and references to content, never the content itself. Records are hash-chained, and the chain head is kept where the application cannot rewrite it. The check finds changes to stored records, not a wrong value written at the time, and it cannot detect a consistent rewrite by someone who controls both the store and the place the chain head is kept.

    How content is deleted without breaking the check is explained under What an AI audit trail must record. What a request does when an audit write fails is decided for each route in the written scope.

  4. Privacy in the tracesRedaction runs before traces leave your app; raw content is readable by the roles you name.

    Pseudonymous IDs replace user names and account numbers in traces. OpenTelemetry's conventions make prompt and response content opt-in, and warn that it "is likely to contain sensitive information including user/PII data". Which fields stay readable, which are kept only as a reference and which are dropped is your decision, field by field.

Trace attributes: OpenTelemetry semantic conventions for generative AI, status "Development".

How the audit trail maps to the EU AI Act and NIST

The rules and frameworks that ask for logs and audit records, mapped to the audit-trail pillar; each row supports the obligation, and meeting it depends on your system and how you run it.

The audit-trail pillar

One pillar of the build, mapped to these frameworks.

  • EU AI Act, Regulation (EU) 2024/1689, high-risk systemsArticle 12; Article 19(1); Article 26(5) and (6); Article 72
  • NIST AI RMF 1.0 (NIST AI 100-1)MEASURE 2.4; MANAGE 4.1
  • NIST SP 800-53 Rev. 5AU-3; AU-9; AU-11
  • If your system is high-risk under Annex III of the EU AI Act, Articles 12, 19 and 26 apply from 2 December 2027 (Article 113, as amended by Regulation (EU) 2026/1744). Systems placed on the market or put into service before then are covered only if their design changes significantly afterwards; systems intended for use by public authorities must comply by 2 August 2030 in any case (Article 111(2)).
  • Whether your system is high-risk, and whether a change to it counts as significant, are legal questions for your counsel; this page does not answer them. The EU AI Act Compliance & Technical Evidence Pack service covers the documentation.
Read more

EU AI Act, Article 12. High-risk systems "shall technically allow for the automatic recording of events (logs) over the lifetime of the system." Article 12(2) gives logging three purposes: identifying situations that may present a risk or a substantial modification, post-market monitoring under Article 72, and monitoring operation under Article 26(5).

Only for remote biometric identification does Article 12(3) list minimum fields. Our audit record's fields are our design, chosen to serve those three purposes; the Act gives no field list for other systems and does not use the term "audit trail". The coverage and integrity checks are our additions, not requirements in the Act's text.

Article 19(1) and Article 26(6). Providers and deployers keep the logs "to the extent such logs are under their control", "for a period appropriate to the intended purpose of the high-risk AI system, of at least six months, unless provided otherwise in the applicable Union or national law, in particular in Union law on the protection of personal data".

Financial institutions keep them as part of the documentation required by financial services law. Retention in the build is set to your rules.

Article 26(5). Deployers "shall monitor the operation of the high-risk AI system on the basis of the instructions for use"; the alerts and the monthly review support that monitoring.

Article 72. Providers run a post-market monitoring system based on a plan that is part of the technical documentation in Annex IV; the trail and the alert history are data that system can use. Writing the plan belongs to the EU AI Act Compliance & Technical Evidence Pack service.

NIST AI RMF 1.0. MEASURE 2.4: "The functionality and behavior of the AI system and its components ... are monitored when in production." MANAGE 4.1: "Post-deployment AI system monitoring plans are implemented", including mechanisms for "incident response, recovery, and change management".

NIST SP 800-53 Rev. 5. AU-3 asks that audit records establish what type of event occurred, when and where, its source, its outcome, and the identity of the individuals, subjects or entities involved. AU-9 asks that audit information be protected from unauthorized access, modification and deletion. AU-11 asks that audit records be retained to support after-the-fact investigations of incidents.

In development. prEN 18229-1, "AI trustworthiness framework, Part 1: Logging", is a European draft standard (DIN Media record, issued 5 June 2026), not yet a published standard.

Questions buyers ask

8 questions

Is this MLOps or LLMOps?

Searching for MLOps consulting, MLOps managed services or MLOps for LLMs? This is closer to LLMOps. MLOps, as Google Cloud defines it, unifies ML system development and operation. This service starts after deployment, on an LLM app or agent already live, or a scoring model in production: what it records, what it alerts on, and whether its audit trail holds up. It does not build training pipelines or run your platform.

We already use Datadog, Langfuse or Phoenix. What does an engagement add?

The checks set out under A tracing tool alone. We build on the tool you run where it can carry the extra trace attributes and keep its alert rules as code, confirmed in the written scope. We are not affiliated with any other company or product named here, and take no commission from any model or tool vendor.

Does the EU AI Act require logs, and how long must they be kept?

For a high-risk system, once those obligations apply, yes: it must allow automatic logging (Article 12), and providers and deployers keep the logs under their control for a period appropriate to its intended purpose, of at least six months, unless other EU or national law, notably data-protection law, provides otherwise (Articles 19(1), 26(6)). Systems on the market or in service before then are covered only if their design changes significantly afterwards; public-authority systems must comply by 2 August 2030 regardless.

How do you handle personal data and erasure in traces and the audit trail?

Redaction runs before traces leave your app, users appear as pseudonymous IDs, and raw content is readable only by roles you name. Personal content stays out of the integrity-checked record, in a separate store, so erasure (GDPR Article 17) and retention expiry (Article 5(1)(e)) delete it without breaking the check. The mechanism is agreed in the written scope.

What drifts in an LLM app or a scoring model, and is that the same as a hallucination?

In an LLM app: what users ask about, the model behind a provider alias, the retrieval corpus, and your own prompts and settings. In a scoring model: input distributions, and outcome rates as labels arrive. Drift is change over time; a hallucination is one unsupported answer. Drift can raise the hallucination rate, and only a quality signal shows that.

Can we give the audit trail and drill report to our auditor or regulator?

Yes. The trail is your record. The drill report is labelled "Tests run by Veriprajna, which built this stack"; no third party may rely on it. What you tell others is your decision; we issue no attestation, certification or summary letters, and name ourselves to your customers only with written consent. For 12 months we answer your regulator's written questions on the method; new analysis is quoted separately.

Will this slow down or break our app, and what if something goes wrong?

Every change arrives as a pull request you review and merge. The drill report measures latency, errors and what happened to in-scope decisions with the trace pipeline down and with the audit store down, on the test environment. What a request does when an audit write fails is agreed per route in the written scope. Liability is capped at the fees paid for the engagement.

How is a quote scoped?

Through a free 30-minute discovery call: which apps or agents, what you already trace, which decisions need a trail, and whether a test environment exists. You get a written scope and a fixed fee within 2 business days of the call. The earliest start date is in the written scope; the fixed fee does not change if the schedule slips on our side, and you can halt or end the engagement at any time.

What to trace, and what an audit trail must record

Two small charts share a time axis, and a fault starts partway along. Top, the site-wide average barely moves. Bottom, one route's line rises past an alert rule cut by route.

What to trace in an LLM app or agent, and what to alert on

A trace follows one request through your app. Each step becomes a span, with its timing, its status and the attributes that explain it:

  • Model call: The provider, the model requested and the model that answered, settings, token counts, the finish reason, and the version of the prompt template that built the input.
  • Retrieval: The query, the index and its version, and the IDs of the documents returned.
  • Tool call: The tool, its arguments, its result or error, and whether a guardrail allowed, held or blocked it.
  • Sub-agent handoff: Which agent handed work to which, and the scope it delegated.
  • Guardrail or approval decision: The rule, the outcome, and the approver where one is needed.

A trace ID ties the spans of one run together, and a session or conversation ID ties runs together. Token counts and your provider's prices give a cost per request; summed by feature, that becomes a spend signal. Reducing the spend is a separate service, LLM Cost Optimization & Model Migration.

OpenTelemetry's semantic conventions for generative AI define span names and attributes for model calls, agent invocations and tool execution, such as gen_ai.request.model, gen_ai.response.model, gen_ai.conversation.id and gen_ai.tool.call.id. They are still marked as in development, so names can change between releases.

What to alert on. Three kinds of signal, each catching a different failure:

  • Change alerts fire when something the app depends on differs from the last known good: the model version, a prompt, the retrieval index or the configuration. They read the change ledger, not traffic, so they fire on the change itself rather than waiting for its effects.
  • Operational alerts watch rates: errors, refusals, tool failures, latency, cost per feature, and how often guardrails block or wait for approval. For scoring models they watch input drift, and outcome rates as labels arrive.
  • Quality alerts watch correctness, and need a quality signal: user feedback, or grader scores from an evaluation suite.

Intermittent faults. A fault that hits a share of one route's requests barely moves a site-wide average. That is why alert rules are cut by route and platform, and why the drill plants such a fault to find the smallest share each rule catches at your traffic.

Sampling decides what the trace store keeps, and a rare fault can drop out of a heavily sampled store. In-scope decisions go to the audit store regardless; the sampling plan in the written scope says what else is kept.

What an AI audit trail must record

An AI agent's audit trail holds five groups of fields. Each field is there because a question cannot be answered without it.

Who and with what permission. The principal who started the decision, as a pseudonymous ID; the agent's identity and version; the permission scope it acted under; the trace and session IDs; and, for a sub-agent, who delegated to it and with what scope. Without these, "who did this?" has no answer, and neither does "was it allowed to?". Designing the identities themselves (tokens, OAuth, service accounts) is a separate service, Agent Identity & Access Control.

What it saw. The request and the retrieved sources, as references into the content store, with redactions applied by your rules. Without them, a bad answer cannot be told apart from a bad source.

What produced it. The model and its version, the prompt and settings version, the platform and the route. Without them, a change in behaviour cannot be tied to a change on your side.

What it did. Tool calls with their arguments and results, actions refused or denied, the guardrail decision, and the approver where one was required. Refusals and denials are records too: a trail that keeps only what happened cannot show what was stopped.

Output and time. The output, as a reference, and when the decision started and ended.

Why references, not content. The integrity check covers the records. If personal content sat inside them, an erasure request or a retention deadline would force a choice between deleting it and keeping the check intact. With content in a separate store, linked by reference, it can be deleted on its own schedule while the record and its check stand. For you, the records stay personal data: pseudonymised data that can be linked back is personal data (Recital 26).

Why reasoning text is not the record. Some models write out their reasoning. It can be kept as a reference, but it is not treated as the account of why the agent acted: in a 2025 study, Chen and colleagues found that reasoning models' written reasoning often left out a hint the model had in fact used. The record keeps what can be checked: inputs, tool calls, decisions and outputs.

Know what your LLM app or agent did, and be able to show it

Whether you run a tracing tool you have never tested, an agent about to act on customer data, or audit findings you want watched, start with a short conversation.

  1. Email or WhatsApp us
  2. Reply within 1 business day
  3. Free 30-minute discovery call
  4. Written scope and fixed fee within 2 business days of the call