Framework Integrations

AGT — not Wytness — owns the framework adapters. AGT-Python 4.1.0 ships 12 first-party framework integrations (LangChain, LangGraph, CrewAI, Haystack, MCP, +7 others); AGT-TS ships GenericFrameworkAdapter only. Those adapters perform trust verification, not audit emission — but once the wrapper is initialised, every entry AGT's AuditLog chains is forwarded to Wytness regardless of how the framework was wired in.

How it works

1. AGT-Python ships a framework integration (LangChain callback, CrewAI hook, etc.) that hooks into the framework's lifecycle. These integrations perform trust verification — they gate tool execution against a trust score. They do not automatically emit AGT AuditEntry records on their own.
2. You still call AGT's AuditLog().log(...) from your framework's handler (or use AGT's HTTP middleware which does both gating and logging).
3. The wrapper's init() hooks AGT's audit log cleanly — the entries flow through the Wytness PII + envelope path. You write zero Wytness-specific framework code.

Supported frameworks (AGT-Python 4.1.0)

These are the 12 framework / middleware integrations AGT-Python ships first-party as of 4.1.0. TypeScript ships GenericFrameworkAdapter only — see Custom adapter (TypeScript). Refer to the AGT repo for class names and full wire-up.

Example: LangChain (Python)

AGT-Python's LangChain integration is a trust-gating callback. To capture each tool call as an audit entry, also write to AGT's AuditLog from the handler — the simplest pattern is a thin wrapper that does both.

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()

Each audit.log(...) call produces one AGT AuditEntry — wrapped by the Wytness envelope and POSTed to /ingest. Alternatively, use AGT's agentmesh.integrations.http_middleware which does both gating and audit emission on its own.

Custom adapter (TypeScript)

AGT-TS 5.0.0 ships GenericFrameworkAdapter only — implement one method against your framework's tool-call lifecycle and write to AuditLogger.log(). The wrapper picks up everything the logger chains.

1import { init, shutdown, setNextEntryExtras, AuditLogger } from "@wytness/ai";
2 
3await init({ piiFields: ["customer.email"] });
4 
5const audit = new AuditLogger();
6 
7// Call this from your framework's tool-end / on-step handler.
8function recordToolCall(toolName: string, params: object, result: object) {
9  setNextEntryExtras({ data: { params, result }, outcome: "success" });
10  audit.log({
11    agentId: "research-agent",
12    action: `tool_invocation:${toolName}`,
13    decision: "allow",
14  });
15}
16 
17// ... run your agent, calling recordToolCall(...) on each tool invocation ...
18 
19await shutdown();

Framework not on the list?

Two options:

1. Write to AGT's AuditLog directly. AGT is framework-agnostic — any code path can call AuditLog().log(...). With the wrapper initialised, those entries get pseudonymised, envelope-signed, and POSTed. See the Python quickstart for the call shape.
2. Use direct ingest. If you can't or don't want to install AGT — for example, you're emitting from a Lambda that doesn't run agent code — POST CloudEvents 1.0 batches directly to api.wytness.ai/ingest with the appropriate Content-Type. See Built on AGT — Path B.

Manual sink write (Python)

1import wytness_ai
2from wytness_ai import AuditLog
3 
4wytness_ai.init()
5 
6audit = AuditLog()
7 
8# Your code — emits to AGT's chain, then forwarded to Wytness.
9audit.log(
10    event_type="tool_invocation",
11    agent_did="custom-agent",
12    action="my_tool",
13    policy_decision="allow",
14    data={"query": "..."},
15)
16 
17wytness_ai.shutdown()

Version pinning

AGT is a hard dependency of the wrapper SDK — Python 4.1.0 / TypeScript 5.0.0, one Microsoft release train (the differing numbers are Microsoft's per-registry publish cadence, not a compatibility split). Pin both versions in your requirements.txt / package.json so a framework upgrade doesn't silently pull a newer AGT before the wrapper supports it.

AGT framework-adapter versions track AGT's release cadence — see the AGT changelog.

Related

• Quickstart (Python)
• Quickstart (TypeScript)
• SDK API reference
• Built on AGT — wrapper vs direct ingest