Theme: The Responsibility

Length: ~800 words

Hook: Practical — show the actual structure, not abstract concepts

Everyone talks about agent audit trails. Almost nobody shows what one actually looks like.

So here's a concrete audit trail from an agent that processes customer support tickets. Not abstract concepts — the actual fields, the actual structure, the actual questions it answers.

The scenario: A customer submits a complaint about a double charge. An agent investigates, determines it's a billing error, and issues a refund.

The audit trail:

{
  "trace_id": "trc_8f3a2b1c",
  "timestamp": "2026-06-30T10:14:32Z",
  "agent_id": "agt_support_resolver_v3",
  "agent_version": "3.2.1",
  "sponsor": "[email protected]",
  "session_id": "ses_4d2e1f",
  "goal": "Investigate customer complaint about double charge",
  "perception": {
    "input": "Customer reports $49.99 charged twice on June 28",
    "context": {
      "customer_id": "cust_8842",
      "account_tier": "premium",
      "history": "3 prior complaints, all resolved"
    }
  },
  "reasoning": {
    "model": "claude-4-sonnet",
    "prompt_hash": "sha256:a1b2c3...",
    "decision": "Check billing system for duplicate charges, then issue refund if confirmed",
    "alternatives_considered": [
      "Escalate to human agent",
      "Check payment processor directly"
    ],
    "confidence": 0.92
  },
  "actions": [
    {
      "step": 1,
      "tool": "BillingAPI.lookup",
      "parameters": {"customer_id": "cust_8842", "date_range": "2026-06-27 to 2026-06-29"},
      "result": "Two charges of $49.99 on June 28",
      "policy_check": "allowed",
      "timestamp": "2026-06-30T10:14:35Z"
    },
    {
      "step": 2,
      "tool": "BillingAPI.refund",
      "parameters": {"charge_id": "ch_7721", "amount": 49.99},
      "result": "Refund processed, ref_3341",
      "policy_check": "require_approval",
      "approval": {
        "approved_by": "auto-approval-rule:refund_under_100",
        "rule_id": "pol_refund_auto_100"
      },
      "timestamp": "2026-06-30T10:14:38Z"
    },
    {
      "step": 3,
      "tool": "NotificationAPI.send",
      "parameters": {"channel": "email", "template": "refund_confirmed"},
      "result": "Email sent",
      "policy_check": "allowed",
      "timestamp": "2026-06-30T10:14:40Z"
    }
  ],
  "outcome": {
    "status": "success",
    "cost_usd": 0.034,
    "duration_seconds": 8,
    "tokens": {"input": 1240, "output": 380}
  },
  "hash": "sha256:f4e5d6...",
  "previous_hash": "sha256:c3b4a5..."
}

What this audit trail answers:

"What happened?" The agent received a complaint about a double charge, looked up the billing system, confirmed the duplicate, issued a refund, and notified the customer. Three tool calls, eight seconds, $0.034 in LLM costs.

"Why did it make this decision?" The reasoning block shows the model used, the decision made, alternatives considered (escalate to human, check payment processor), and confidence level (92%). The prompt hash lets you verify the exact prompt that produced this reasoning.

"Was it allowed to do this?" Each action has a policy check. The billing lookup was allowed. The refund required approval — and the approval is logged with the rule that authorized it. The notification was allowed. No action was taken without a policy check.

"Who is responsible?" The sponsor field identifies the human who approved this agent's deployment. If something goes wrong, Priya is the accountable human. Not "the AI did it."

"Can I verify this wasn't tampered with?" Each trace has a hash, and each hash includes the previous trace's hash. This is a tamper-evident chain — the same technique blockchains use. If someone modifies a trace, the hash breaks.

"How much did this cost?" The outcome block shows $0.034 in LLM costs, 1,620 tokens, 8 seconds duration. You can aggregate this across all traces to calculate total agent spend.

What most teams have today vs. what they need:

Most teams have: LLM call logs (input, output, tokens). Maybe some tool call logs. Maybe some error logs.

What they need: the full trace above. Perception (what the agent saw), reasoning (what it thought), actions (what it did), policy checks (was it allowed), outcome (what happened), and tamper-evidence (can you prove it wasn't altered).

The gap between "we have logs" and "we have an audit trail" is the gap between "we can debug" and "we can defend."

The practical takeaway:

If your agent audit trail doesn't include: perception, reasoning, alternatives considered, policy checks per action, approval provenance, cost tracking, and tamper-evident hashing — you don't have an audit trail. You have logs.

Logs tell you what happened. Audit trails tell you why, whether it was allowed, who's responsible, and whether you can prove it.

What does your current agent audit trail look like — and does it answer all seven questions?