To export agent runs, start where the runtime writes them. Agno keeps sessions and an agno_runs table in your own database. AWS Bedrock AgentCore writes traces and prompts to the agent's CloudWatch log group. Agentforce records sessions in its Session Tracing Data Model. The OpenAI Agents SDK sends traces to OpenAI unless you add your own processor. MLflow searches and exports traces, including as OpenTelemetry GenAI spans.
- Runtimes are not observability tools: each keeps runs in a different place, often split across two stores.
- Check what was offloaded, cleared or never captured before you call an export complete.
- Retention decides what is left: CloudWatch keeps logs until you set a limit, AgentCore memory events expire.
- Copy runs into a store you control going forward, then backfill what the platform still holds.
Is an agent platform the same as an observability tool?
No. A runtime or platform runs the agent and keeps what it needs to resume a session; an observability tool receives spans to display them. The export guide covers LangSmith, Langfuse, Phoenix, Braintrust, Helicone, Weave, Datadog, OpenHands and LangGraph checkpoints. This page covers the runtimes.
The difference matters because a runtime's store is built for the next turn, not for the record. It may keep messages but not model-call spans, keep spans but not the prompts, or keep both in different places. A complete run usually means joining two sources on a session or trace ID.
How do I export Agno agent sessions and runs?
Read them from your own database. Agno says "AgentOS runs in your cloud and your data, traces and metrics live in your database" (Agno), so there is no vendor export to request.
Version 3 changed the layout. "Each run is now a row in a dedicated agno_runs table with real columns" such as session ID, run type, status and agent ID, alongside a JSON payload (Agno changelog). Any export written for 2.x needs updating: "If you query the sessions table's runs column from SQL, a dashboard, or an export, point those at agno_runs instead." In code you can "fetch runs directly with db.get_runs(session_id=...) without loading the whole session" (Agno).
To pick sessions first, AgentOS "answers POST /sessions/search", filtering on fields such as user, agent, session type and dates (Agno changelog). Then check offloading: "Tool result and media offloading keep large data out of the model's context and the database" (Agno). An offloaded result sits elsewhere, so an export of the table alone holds a reference, not the result.
curl -X POST "$AGENTOS_URL/sessions/search" -H "Content-Type: application/json" \
-d '{"filter": {"op": "and", "conditions": [{"op": "eq", "key": "agent_id", "value": "support"}]}}'
# then, per session, in Python: db.get_runs(session_id=SESSION_ID)Where does Amazon Bedrock AgentCore store agent traces?
In Amazon CloudWatch. Since July 2026 "Amazon Bedrock AgentCore now delivers agent traces and prompts to the same log group as your agent's logs" (AWS). Runs from before that are split: "Previously, AgentCore split agent telemetry across multiple destinations", with spans in a shared aws/spans group and prompts and outputs in a resource log group.
Spans only exist if they were switched on. AWS says "you first need to complete a one-time setup to turn on Amazon CloudWatch Transaction Search" (AWS docs). If nobody did, you have logs but no trace tree. AgentCore memory is separate again: you "set eventExpiryDuration to control how long raw events persist (between 7-365 days)" (AWS), so old memory events may be gone.
To get runs out, export the log group. CloudWatch lets you "export log data from your log groups to an Amazon S3 bucket for custom processing and analysis" (AWS docs). Check the group's retention first: it keeps data until someone sets a limit, and then deletes anything older (AWS docs).
aws logs create-export-task --log-group-name "/aws/bedrock-agentcore/runtimes/AGENT_ID" \
--from 1767225600000 --to 1768435200000 --destination "your-bucket" --destination-prefix agentcore-runsHow do I get Agentforce session traces out of Salesforce?
Through your Salesforce org, with an admin. Agentforce's Session Tracing Data Model "structures every logged event in a session down to a single conversation turn, capturing user input, planner decisions, prompt and action flows, gateway inputs and outputs, errors and final output" (Salesforce). It lives in your Data 360 (formerly Data Cloud) tables.
Salesforce adds that without the model "session data arrives as raw JSON that teams have to transform before building any reporting". So the export is a query of those tables, run by someone with access, for the sessions you choose. Salesforce's own help and developer pages on the model are not readable without a browser session, so we do not quote field names here; ask your admin for the tables and the retention your edition keeps.
Two things differ from a runtime you host. You cannot see the model's full internals or swap the harness, and the conversations contain your customers' words. The vendor agent logs guide covers whose data that is.
Can I export traces from the OpenAI Agents SDK dashboard?
Plan to keep your own copy instead. "Tracing is enabled by default" and the default processor sends traces to OpenAI's backend (OpenAI Agents SDK docs).
Two settings decide what you can have. "By default, trace_include_sensitive_data is true", so model and tool inputs and outputs are in the spans. And "Tracing is unavailable for organizations that use OpenAI's APIs under a Zero Data Retention (ZDR) policy", so those organisations have no hosted traces at all.
"add_trace_processor() lets you add an additional trace processor that will receive traces and spans as they are ready", which keeps OpenAI's copy and adds yours. "set_trace_processors() lets you replace the default processors with your own trace processors", which stops sending to OpenAI. The docs warn that a redaction processor added beside the default exporter does not stop that exporter receiving the data if redaction fails; put redaction and delivery in one exporter you own.
from agents import add_trace_processor
from agents.tracing.processors import BatchTraceProcessor
add_trace_processor(BatchTraceProcessor(JsonlExporter("runs/"))) # your exporter writes one JSONL file per traceHow do I export MLflow traces in OpenTelemetry GenAI format?
Search first, then export. "The search_traces API helps you find specific traces based on their execution characteristics, metadata, tags, and other attributes" (MLflow docs), so you can pull runs by status, time or tag into a dataframe.
For a standard format, "By default, exported traces use MLflow's internal attribute format"; to get gen_ai.* attributes, "set the MLFLOW_ENABLE_OTEL_GENAI_SEMCONV environment variable" and point the OTLP exporter at your collector (MLflow docs). That setting applies to traces exported from then on.
import os, mlflow
traces = mlflow.search_traces(filter_string="trace.status = 'OK'")
os.environ["MLFLOW_ENABLE_OTEL_GENAI_SEMCONV"] = "true"What about Pydantic Logfire and other OpenTelemetry tools?
Query them. Logfire stores spans in a records table you can query with SQL, and "The API can return data in various formats, including JSON, Apache Arrow, and CSV" (Logfire docs). On Logfire Cloud, "Logfire limits the queries that each organization can send with read tokens", so page a large export by time window.
Frameworks that emit OpenTelemetry spans, such as CrewAI or a LangGraph app with an exporter, follow the same rule: the run lives wherever the spans were sent. Find that backend, then use its export.
Agent platforms compared: where runs live and what is often missing
Read the row for your platform, then check the last column before you call a set complete.
| Platform | Where runs live | How to get them out | Often missing |
|---|---|---|---|
| Agno (v3) | Your database: sessions and agno_runs | SQL or db.get_runs; AgentOS session search | Offloaded tool results and media |
| AWS Bedrock AgentCore | CloudWatch log group per agent (since July 2026) | Export the log group to S3 | Spans if Transaction Search was off; expired memory events |
| Salesforce Agentforce | Session Tracing Data Model in Data 360 | Query by an org admin | Model internals; anything outside retention |
| OpenAI Agents SDK | OpenAI dashboard by default | Your own trace processor | Everything for ZDR organisations; runs before you added a processor |
| MLflow | Tracking server | search_traces; OTLP export | gen_ai.* names unless the setting is on |
| Pydantic Logfire | Logfire records table | Query API: JSON, Arrow, CSV | Runs past your plan's query limits in one pass |
Worked example: one AgentCore run, rebuilt
A fictional invoice agent runs on AgentCore. The team exports a week of its log group to S3, groups records by session ID and finds 1,900 sessions. For the 1,200 sessions after the July change, prompts, tool calls and outputs sit in one group. For the 700 before it, spans are in the shared group and need a second export joined on trace ID.
They then check three things: every tool call has a result, the final step has an outcome, and the run count per day looks like the agent's real volume. Sessions with gaps are labelled partial, not dropped.
Common mistakes when exporting from agent platforms
Most failed exports look complete until someone replays a run.
- Exporting the sessions table only, after an upgrade moved runs to their own table.
- Assuming tool results are inline when the runtime offloaded them.
- Exporting logs with no spans because tracing was never switched on.
- Letting a retention limit or memory expiry delete runs while the export is planned.
- Copying sensitive spans to a new place before redaction. Scrub first; see the redaction checklist.
Complete runs are also a data asset
A clean export is useful on its own: replay, evaluation, debugging. It is also what a buyer would ask to see. Here is what buyers Origin works with asked for in November 2026: real production runs on a company's own systems, long and complete with nothing cut from the middle, with the model and harness stated and an outcome that shows whether the job was done. A few hundred such runs is enough to start, and five to ten samples, described in writing, open the conversation. See licensing agent traces for provider terms and who can sign.
We help you license your data. Origin Data Partners is an independent data partner: we tell you what your records could be worth and prepare the records, the terms and the license with you. The AI company that licenses them pays your company; a buyer may pay Origin when a deal closes.
Does your company hold records like these? See what your data is worth.
Common questions
Agno stores sessions in my database. Is that a full agent trace?
It holds the messages and runs. Model-call spans need tracing switched on, and offloaded tool results and media live outside the session row, so collect them too. Check one exported run end to end before you export the rest.
We use Agentforce. Do we own the session traces?
Your Salesforce agreement sets your rights in data stored in your org, and the customers in those conversations are covered by your own customer terms and privacy notices. Read both before anything leaves the org. This is general information, not legal advice.
Our OpenAI Agents SDK traces are only in the OpenAI dashboard. Can we get them out?
Going forward, yes: add your own trace processor so every span is written to a store you control. For past runs, check what the dashboard lets you view or download. Organisations under Zero Data Retention have no hosted traces to export.
Does CloudWatch keep AgentCore traces forever?
Only if nobody set a limit. CloudWatch keeps log data until a retention period is set on the log group, then deletes anything older. AgentCore memory events are separate and expire after the 7 to 365 days configured for them.
Which file format should exported agent runs use?
One JSON Lines file per run, or OpenTelemetry GenAI spans with an index that lists each run's trace ID. Keep tool results inline, keep timestamps with time zones and record the model and harness version on every run.
Can we export runs from several agent platforms into one set?
Yes, if each run keeps a field naming its platform, model and harness. Normalise to one format and keep the original export beside it, so anyone can check a converted run against its source.
Sources and further reading
- Agno changelog: runs now have their own database table (SDK v3.0.0, 24 August 2026)
- Agno: what actually breaks agents in production (Agno v3.0)
- Agno changelog: search AgentOS sessions with nested filters (SDK v3.1.11, 27 October 2026)
- Agno: AgentOS overview and FAQ
- AWS What's New: AgentCore traces and logs in a single log group (23 July 2026)
- AWS docs: enabling AgentCore observability (CloudWatch Transaction Search)
- AWS Machine Learning Blog: optimizing production agents with AgentCore observability
- AWS docs: exporting CloudWatch log data to Amazon S3
- AWS docs: working with log groups and log retention in CloudWatch Logs
- Salesforce blog: Agentforce Observability and the Session Tracing Data Model
- OpenAI Agents SDK (Python) docs: tracing
- MLflow docs: search traces
- MLflow docs: export traces through OTLP, GenAI semantic convention format
- Pydantic Logfire docs: query API
