Compliance & Audit

AI agents your compliance team will actually approve

Human-in-the-loop approvals, auditable thread history, and deterministic testing — built into the framework, not bolted on.

Read the field report See the program

The problem

Why this is hard today.

Black-box AI decisions

Regulators require explainability. Most agent frameworks stream opaque outputs with no tool-call history.

No human gate before action

SOX, HIPAA, and GDPR demand human approval before consequential actions. Retrofitting interrupts is a rewrite.

Untestable agent behavior

Compliance needs reproducible test evidence. Non-deterministic LLM calls make that nearly impossible without the right tooling.

Architecture

How the three libraries compose.

Three libraries give your compliance team what they need — without slowing your engineering team down.

Agent

@threadplane/langgraph

Production agent state with first-class interrupt support. Every agent action can require human approval before execution. Durable thread persistence preserves the full record of every tool call and state transition.

See Agent docs →

Render

@threadplane/render

Approval workflows rendered as structured UI — not chat messages. The agent proposes an action, renders a confirmation card, and waits for the human gate before proceeding.

See Render docs →

Chat

@threadplane/chat

Debug overlay shows every tool call, interrupt, and state transition. Your compliance team can review exactly what happened, when, and why — in a UI they can understand.

See Chat docs →

What you ship

Capabilities the framework delivers.

Every

Agent action recorded — tool calls, interrupts, and state transitions captured in the thread record

Evidenced

Each approval is written into the checkpoint beside the action it gated — the decision and the proposal are one record

Replayable

Thread persistence preserves the full decision path for review by auditors and your compliance team

In practice

What it looks like in your codebase

audit-trail.component.ts — reading the thread record

export class AuditTrailComponent {
  private readonly agent = injectAgent(REVIEW_AGENT);

  // Runtime-neutral timeline: every checkpoint the thread passed through.
  readonly checkpoints = computed(() => this.agent.history());

  // Raw LangGraph ThreadState[], for the fields an auditor asks about.
  private readonly raw = computed(() => this.agent.langGraphHistory());

  // The decisions themselves, lifted out of the checkpoint values. Each row
  // pairs what was proposed with what a human answered, and when.
  readonly approvals = computed(() =>
    this.raw()
      .filter((state) => state.values?.['approval_result'])
      .map((state) => ({
        at: state.created_at,
        action: state.values['proposed_action'],
        decision: state.values['approval_result'],
      })),
  );
}

audit-trail.component.html

<table class="audit">
  @for (row of approvals(); track row.at) {
    <tr>
      <td>{{ row.at | date: 'medium' }}</td>
      <td>{{ row.action.description }}</td>
      <td>{{ row.decision.approved ? 'Approved' : 'Rejected' }}</td>
      <td>{{ row.decision.reason }}</td>
    </tr>
  }
</table>

<p class="muted">{{ checkpoints().length }} checkpoints on this thread.</p>