Recommended: the openclaw-localtrace plugin. OpenClaw's own built-in exporter (@openclaw/diagnostics-otel) strips every session and write signal this analysis relies on most; the plugin exists specifically to keep them, writing straight to a local directory instead of a network endpoint. No redundo collect step for this source.

openclaw plugins install clawhub:@cogentwizards/openclaw-localtrace
openclaw plugins enable openclaw-localtrace
openclaw config set plugins.entries.openclaw-localtrace.config.enabled true
openclaw config set plugins.entries.openclaw-localtrace.config.captureIdentifiers true   # opt-in; off by default
openclaw config set plugins.entries.openclaw-localtrace.config.captureContent true       # opt-in; off by default
openclaw config set plugins.entries.openclaw-localtrace.hooks.allowConversationAccess true
openclaw gateway restart

# drive real turns through the Gateway, then:
redundo adapt "$(openclaw config get plugins.entries.openclaw-localtrace.config.outputDir)" \
  --summary | redundo analyze --format html > report.html

captureIdentifiers and hooks.allowConversationAccess unlock a real conversation-scoped task_id and a real per-call write signal. Read the plugin's own README before turning them on. Without the plugin at all, docs/openclaw.md covers the built-in exporter instead, at the cost of that missing signal.

Needs the community hermes-otel plugin installed first:

hermes plugins install briancaffey/hermes-otel/hermes_otel
# import into the SAME venv that runs `hermes`. Check `hermes --version`'s
# "Install directory" for the real path if this doesn't match yours:
/path/to/hermes-agent/venv/bin/pip install -r ~/.hermes/plugins/hermes_otel/requirements.txt
export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318/v1/traces"   # note the /v1/traces suffix

# restart Hermes, drive real turns through it, then:
redundo adapt ./otlp_traces --source openinference --summary | redundo analyze --format html > report.html

Full content and a real conversation-scoped task_id both work out of the box, no permission opt-in needed. See docs/openinference.md.

Instrument it with the community openinference-instrumentation-openai-agents package, pointed at a redundo collect receiver:

pip install openinference-instrumentation-openai-agents opentelemetry-exporter-otlp-proto-http

from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")))
OpenAIAgentsInstrumentor().instrument(tracer_provider=provider)

# run your agent(s), then:

redundo adapt ./otlp_traces --source openinference --summary | redundo analyze --format html > report.html

In-trace handoffs work out of the box. Cross-trace correlation (the SDK's own group_id) is dropped by this translator today, an upstream gap, not something this adapter can fix. See docs/openinference.md's per-source table.

Instrument it with the community openinference-instrumentation-google-adk package, pointed at a redundo collect receiver:

pip install openinference-instrumentation-google-adk opentelemetry-exporter-otlp-proto-http

from openinference.instrumentation.google_adk import GoogleADKInstrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")))
GoogleADKInstrumentor().instrument(tracer_provider=provider)

# run your agent(s), then:

redundo adapt ./otlp_traces --source openinference --summary | redundo analyze --format html > report.html

ADK's own session id maps onto the standard session.id attribute, so a real conversation-scoped task_id works out of the box. Subagent delegation via AgentTool reuses the parent's own session id, so delegated work lands in the same task automatically, no extra link needed. See docs/openinference.md's per-source table.

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1
export OTEL_TRACES_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_METRICS_EXPORTER=none   # not consumed by this adapter
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
export OTEL_TRACES_EXPORT_INTERVAL=1000   # the default 5s can lose a short -p session to an early exit
export OTEL_LOGS_EXPORT_INTERVAL=1000
export OTEL_LOG_USER_PROMPTS=1      # first-of-turn llm_call content
export OTEL_LOG_TOOL_DETAILS=1      # built-in tool arguments + MCP tool_input
export OTEL_LOG_TOOL_CONTENT=1      # tool.output content (needs tracing on)

# run your claude session(s), then:
redundo adapt ./otlp_traces --source claude-code --summary | redundo analyze --format html > report.html

MCP tool call arguments only ever appear on the logs signal; tool output content only ever appears in a span event gated by OTEL_LOG_TOOL_CONTENT=1. Full detail in docs/claude-code.md.

Same env vars as the CLI above. The SDK launches the claude binary as a subprocess, which inherits its parent's environment, so set these in whatever process calls query(), shell export before running your script, or os.environ/process.env before the SDK import, rather than anywhere inside the SDK's own options.

python your_agent_script.py   # anything that calls claude_agent_sdk.query()
redundo adapt ./otlp_traces --source claude-code --summary | redundo analyze --format html > report.html

Same --source claude-code as the CLI; the SDK is detected as the same source. One thing genuinely differs: the SDK always launches the CLI in streaming mode, which never emits the span the CLI normally uses to attach a turn's prompt text. This adapter recovers that content automatically via a time-window correlation against the logs signal. See "Agent SDK content recovery" in docs/claude-code.md.

Nothing to capture. Pi emits no OTLP, but it already keeps every conversation as a session file with real per-call cost, and redundo adapt reads those directly. Point it at one session file, or one project's session directory (named after the working directory):

redundo adapt ~/.pi/agent/sessions/--Users-me-src-myproject--/ --summary | redundo analyze --format html > report.html

Forked and cloned sessions are linked back to the session they came from, without counting the copied history twice. See docs/pi.md.

Nothing to capture either. OpenCode stores every session locally, with real per-step cost, and redundo adapt reads that directly: one exported session, or the whole database (opened read-only).

opencode export ses_XXXXXXXX > session.json
redundo adapt session.json --summary | redundo analyze --format html > report.html

# or every stored session:
redundo adapt "$(opencode db path)" --summary | redundo analyze --format html > report.html

Subagent sessions are linked to the session that spawned them. OpenCode 1.x only for now. See docs/opencode.md.