Instrumenting a LangChain agent in 5 minutes

LangChain agents are where many teams' first real agents live — and where the audit question first gets awkward, because the framework orchestrates tool calls your logging never sees coherently. Here's the honest five minutes: wire the Wytness wrapper in once, add one callback, and every tool call your LangChain agent makes lands on the tape — signed, sealed, verifiable.

How the pieces fit

Three layers cooperate, and it helps to name them before the code. LangChain runs your agent and exposes lifecycle callbacks around every tool invocation. Microsoft's AGT ships a LangChain integration — a trust-gating callback that can gate tool execution against an agent's trust score. And the Wytness wrapper, initialised once at process start, turns everything written to AGT's audit log into signed, PII-sealed events on your tape. One honest detail the setup depends on: AGT's LangChain callback does trust verification — it does not emit audit entries by itself. The recording half is a thin callback you add, and it's shorter than this paragraph.

The whole setup

1# 1. Wytness wrapper — wire in once at process start.
2import wytness_ai
3from wytness_ai import AuditLog
4wytness_ai.init(pii_fields=["customer.email"])
5 
6# 2. AGT's LangChain trust callback — Microsoft's pattern.
7from langchain.agents import AgentExecutor
8from agentmesh.integrations.langchain import AgentMeshTrustCallback
9 
10trust_cb = AgentMeshTrustCallback(agent_did="billing-agent")
11audit = AuditLog()
12 
13# 3. Wrap tool-call lifecycle to write an AuditEntry per invocation.
14class WytnessAuditCallback:
15    def on_tool_end(self, tool_name, params, result, **_):
16        audit.log(
17            event_type="tool_invocation",
18            agent_did="billing-agent",
19            action=tool_name,
20            policy_decision="allow",
21            data={"params": params, "result": result},
22        )
23 
24agent_executor = AgentExecutor(
25    agent=my_agent,
26    tools=my_tools,
27    callbacks=[trust_cb, WytnessAuditCallback()],
28)
29 
30agent_executor.invoke({"input": "Send the Q1 invoice to Acme Corp"})
31 
32wytness_ai.shutdown()

That's the entire integration. init() reads your WYTNESS_* environment values — API key, signing key, sealing keys — exactly as in the Python quickstart, and every audit.log(...) call becomes one signed event on its way to ingest. Declare the personal fields your tools handle in pii_fields and they cross the wire as tokens, never as values.

What you get per tool call

Run the agent and open Events: one row per tool invocation, in order, inside one session — the lookup, the invoice creation, the send, each with its parameters, result, duration, and verification mark. Because the callback sits on the framework's lifecycle rather than inside any single tool, new tools your agent gains are recorded the day they're added, without anyone remembering to instrument them. And the model calls LangChain makes underneath are captured too — init() wraps the OpenAI and Anthropic clients automatically, so the reasoning steps appear on the tape between the tool calls they caused, token counts included.

Beyond LangChain

The same pattern covers the rest of the framework zoo — AGT ships integrations for LangGraph, CrewAI, Haystack, MCP, and more, plus a framework-agnostic HTTP middleware when you'd rather capture at the request boundary. The full matrix, and this example in copy-paste form, live in the Framework Integrations docs. The shape is always the same: initialise the wrapper once, hook the framework's lifecycle, and let the tape do the rest.

This guide replaces the original v1-SDK version that lived at this address; the v1 package it covered is in security-only maintenance and new integrations should follow the pattern above.

Questions about your framework mix? Ask us.