Proposal: export a redacted, replayable run bundle from Foundry agent traces

[m.aliarslan (Kewe63)]

Technical feedback

Microsoft Foundry traces are useful for inspecting an individual run, but reproducing or sharing a failure across developers, environments, and support cases still requires manually collecting information from several places.

Would it make sense for Foundry to support exporting a redacted, replayable run bundle from an agent trace?

The bundle could be a documented JSON or ZIP format containing:

• agent name and immutable agent version
• model deployment and model version, when available
• hashes or version identifiers for instructions, prompts, and tool schemas
• the ordered span and tool-call sequence
• tool arguments and results, subject to redaction settings
• approval, policy, and authorization decisions
• token usage, latency, status, and error details
• trace, response, conversation, and correlation identifiers
• relevant runtime capability and SDK/API-version metadata

Why this would help

A trace explains what happened, but a portable run bundle could also help answer why two apparently identical runs behaved differently. It would make it easier to:

1. attach a self-contained diagnostic artifact to a support case;
2. compare two runs and identify configuration drift;
3. distinguish configuration changes from model nondeterminism;
4. reproduce orchestration failures without invoking live tools again;
5. build regression tests from production failures.

An optional replay mode could use recorded tool results instead of re-executing external actions. This would keep replay safe and deterministic while still exercising the agent or workflow path.

Redaction and safety

The export should not include secrets, credentials, or hidden chain-of-thought. Useful redaction modes might include:

• metadata only;
• inputs and outputs automatically redacted;
• custom field-level redaction;
• hashes only for prompts and tool schemas.

Desired outcome

• Export a run bundle from the Foundry trace UI and through an API/SDK.
• Import it into a local inspector or Foundry project for comparison and safe replay.
• Provide a documented, versioned schema that external observability tools can support.

Current workaround

The current workaround is to manually combine trace data, application logs, agent definitions, deployment details, and tool configuration. That process is easy to get wrong and often misses the exact configuration that was effective when the run occurred.

Is any part of this already possible through the current trace APIs or OpenTelemetry export? If not, would a portable run-bundle format fit the Foundry observability roadmap?

[imax (imax500tr)]

Strong +1. As someone who does security reviews of agent runs, this is exactly the artifact that's missing today: a trace tells you what happened, but a versioned, redacted, replayable run bundle is what lets you prove why it happened.

The parts I'd emphasize:

• Immutable agent version + hashes of instructions/prompts/tool schemas is the critical piece — "identical" runs diverge most often because of silent configuration drift, not model nondeterminism.
• The replay mode using recorded tool results is the big win: deterministic reproduction without re-invoking live tools or touching production systems.
• Defaulting to hashes-only redaction for prompts and tool schemas (with field-level overrides) is the right safety posture — secrets and chain-of-thought should never be exportable.
• A documented, versioned schema matters as much as the export API itself: third-party observability tooling and regression harnesses can't build on an unstable format.

One addition worth considering: include the effective config snapshot (feature flags, approval/policy engine version, SDK semantic-convention version) alongside the hashes, so "which policy actually fired" is auditable rather than inferred. And for replay, a schema migration story as the agent runtime evolves would make this durable beyond a single version.

Happy to help validate a draft schema if the team wants another set of eyes on it.