Framework adapters

Turn detection is the only thing that differs per framework. All six adapters share identical self-healing: the same evaluation, the same repair agent, the same validation. Each Harness.for_<framework>() factory wires the framework’s natural turn boundary to on_turn_end and preserves its session resolution (session identity comes from the PandaProbe SDK’s session context, so harness evaluations and SDK traces line up automatically).

Factory	Framework	Turn detector	Extra
`Harness.for_langgraph()`	LangGraph	LangChain callback: root `on_chain_end` (via `harness.adapter.make_callback()`)	`[langgraph]`
`Harness.for_langchain()`	LangChain	Same root-chain-end callback	`[langchain]`
`Harness.for_deepagents()`	DeepAgents	Same root-chain-end callback	`[deepagents]`
`Harness.for_crewai()`	CrewAI	Patches `Crew.kickoff` (auto-`instrument()`)	`[crewai]`
`Harness.for_claude_agent_sdk()`	Claude Agent SDK	Patches `ClaudeSDKClient.receive_response` — one stream = one turn	`[claude-agent-sdk]`
`Harness.for_openai_agents()`	OpenAI Agents SDK	`TracingProcessor` — fires on trace end; one `Runner.run` = one turn	`[openai-agents]`

Adapters are optional, import-guarded extras:

pip install "pandaprobe-harness[langgraph]"   # or [all]

uv add "pandaprobe-harness[langgraph]"

Every factory accepts the same keywords: session_id= (a fixed session for single-conversation processes), config=, cli=, and replay= for closed-loop validation. To wire a ground-truth outcome oracle, use Harness.create(verifier=...) — the for_* factories do not take verifier=.

Turn granularity matters

Each adapter’s turn detector defines what a “turn” is, and that is what the trajectory gate sees. A detector that fires once per task — one Runner.run that internally takes 20 steps, one Crew.kickoff for a whole workflow — gives the gate a single sample per session, so gate_window is never reached and nothing can fire.If your framework’s natural boundary is coarse, either drive the loop in smaller units (one Runner.run per user turn) or call harness.on_turn_end(...) yourself at the granularity you want. The adapters wire the natural boundary; they cannot know whether it is the right one for your agent.

The barrier with an adapter

Adapters call on_turn_end for you, which is fire-and-forget. To get in-session healing, await the barrier after the framework’s turn returns:

with pandaprobe.session(session_id):
    await graph.ainvoke(state, config={"callbacks": [handler], ...})

await harness.settle(session_id)   # evaluation + one bounded repair attempt have landed

harness.turn(session_id, settle=True) is the equivalent when you own the boundary; with an adapter, the explicit settle() after the framework call is the same thing. See the barrier.

LangGraph (LangChain & DeepAgents work the same way)

import pandaprobe
from pandaprobe_harness import Harness
from pandaprobe_harness.agent_tools.native import as_langchain_tools

harness = Harness.for_langgraph()
handler = harness.adapter.make_callback()          # the turn detector

graph = build_graph(
    # one stable capability sentence — no rule bodies, no index
    system=harness.system_context(session_id) + PROMPT,
    tools=my_tools + as_langchain_tools(harness.task_tools),
)

with pandaprobe.session(session_id):               # harness + SDK traces share the session
    await graph.ainvoke(
        state,
        config={"callbacks": [handler],
                "configurable": {"thread_id": session_id}},
    )

Like the SDK’s LangGraph tracing integration, the handler must be passed via config["callbacks"] on each invocation — the LangChain family has no instrument() pattern.

CrewAI

import pandaprobe
from pandaprobe_harness import Harness

harness = Harness.for_crewai()      # instruments Crew.kickoff automatically

crew = build_crew(
    system=harness.system_context(session_id) + PROMPT,
    # wrap harness.task_tools ops as CrewAI tools if the agent should read rules
)

with pandaprobe.session(session_id):
    crew.kickoff(inputs=...)        # each kickoff = one evaluated turn

Claude Agent SDK

import pandaprobe
from pandaprobe_harness import Harness
from pandaprobe_harness.agent_tools.native import as_anthropic_tools

harness = Harness.for_claude_agent_sdk()   # instruments receive_response

specs, dispatch = as_anthropic_tools(harness.task_tools)

with pandaprobe.session(session_id):
    async with ClaudeSDKClient(options) as client:
        await client.query(user_input)
        async for message in client.receive_response():   # stream end = turn end
            ...

OpenAI Agents SDK

import pandaprobe
from pandaprobe_harness import Harness
from pandaprobe_harness.agent_tools.native import as_openai_function_tools

harness = Harness.for_openai_agents()      # registers the tracing processor

agent = Agent(
    instructions=harness.system_context(session_id) + PROMPT,
    tools=my_tools + as_openai_function_tools(harness.task_tools),
)

with pandaprobe.session(session_id):
    result = await Runner.run(agent, user_input)   # one run = one evaluated turn

Rebuilding the preamble per turn

You no longer need to. The task preamble is a constant — one sentence naming four read-only tools — so a prompt fixed at construction time is identical to one rebuilt every turn. Frameworks that pin the system prompt lose nothing. What the agent reads is always current regardless, because harness_rules_read and harness_rules_list render from the live store at call time. Runnable end-to-end sketches for every framework live in the repository’s examples/misc/ directory.

Get Started

The Self-Heal Loop

Closing the Loop

Integrations

Reference

Turn granularity matters

The barrier with an adapter

LangGraph (LangChain & DeepAgents work the same way)

CrewAI

Claude Agent SDK

OpenAI Agents SDK

Rebuilding the preamble per turn

​Turn granularity matters

​The barrier with an adapter

​LangGraph (LangChain & DeepAgents work the same way)

​CrewAI

​Claude Agent SDK

​OpenAI Agents SDK

​Rebuilding the preamble per turn

Turn granularity matters

The barrier with an adapter

LangGraph (LangChain & DeepAgents work the same way)

CrewAI

Claude Agent SDK

OpenAI Agents SDK

Rebuilding the preamble per turn