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.

Keep the whole
picture in view.

  • 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

The hard parts deserve
a better interface.

Black-box AI decisions

An answer alone cannot explain a decision. Reviewers need the tool activity, context, and human decisions that led to it.

No human gate before action

Sensitive workflows need a clear place for a person to review a proposed action. That decision belongs in the flow, with the context to make it.

Untestable agent behavior

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

Connected from
agent to interface.

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.

Explore Agent

json-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.

Explore json-render

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.

Explore Chat

Real code. Your starting point.

A focused Angular example, using the components and agent APIs behind this workflow.

Explore the implementation

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>

The approval gate, in the product

The agent proposes a destructive action, the graph pauses, and nothing runs until a human approves it.

Recorded from the live demo, which you can drive yourself.

demo.threadplane.ai

Field report

Build agents people can depend on.

Architecture, trade-offs and failure recovery

practical guidance

Angular and React implementation examples

both frameworks

Primary-source research and explicit API boundaries

free

We will never spam you or share your email address.

Ship compliant AI agents — without the compliance tax

Download the field report or start a pilot. Your compliance team will thank you.