Skip to content
Sentynel

#technical6 min readBy Sentynel

Trace the case, not the agent: what end-to-end agent tracing has to carry

Microsoft now traces requests across agents, models and tools. A trace ends when the request ends. Here is how to make it follow the whole case.

Share

At Ignite on 17 November 2026, Microsoft put cross-agent debugging in Azure Monitor into public preview and made observability for agents built outside its own platform generally available, including agents hosted on AWS and Google Cloud. The data underneath is OpenTelemetry and its GenAI semantic conventions, so one trace can follow a request through several agents, models and tools. That answers why one request was slow or wrong. It does not answer why a customer waited three days, because a case is many requests, several people and a lot of waiting. Make the case identifier the thread that ties every trace, every human step and every wait together.

A trace ends when the request ends. A case does not.

Distributed tracing was built for software. A request arrives, passes through services, and returns. The W3C Trace Context standard defines the traceparent header that carries one request's place in a trace from service to service. When the response goes back, that trace is complete.

An operation does not work in requests. A supplier invoice arrives on Monday, an agent extracts it, a person approves an exception on Wednesday, the agent posts it on Thursday, and the supplier asks about payment the following week. That is one case and at least four separate traces, plus two people and several days in which nothing ran at all.

If each trace stands alone, your observability tool can tell you every call was fast and successful while the case sat still for most of the week. Microsoft's own post says it plainly: "A successful tool call doesn't necessarily produce a useful answer." Healthy spans and a stuck case can sit side by side, and only the case record shows the difference.

Put the case ID on every span

The fix is a join key. The record that already exists in your system of record (the ticket, the order, the enquiry) gets an identifier at intake, and every piece of telemetry that touches it carries that identifier.

  1. Create the ID where the work enters, not inside the agent. The CRM, the queue or the intake form issues it. The agent receives it.
  2. Propagate it inside your boundary. OpenTelemetry baggage exists for exactly this: a key-value store that travels with the context across services. Its documentation suggests it for information available at the start of a request, such as account or product IDs.
  3. Write it onto the span explicitly. Baggage entries do not appear on spans, metrics or logs unless you read them and add them as attributes. If nobody does that, the ID travels but never lands where you search.
  4. Strip it at the edge. The same documentation warns that automatic instrumentation adds baggage to most outgoing network requests, where it can reach third-party APIs. Send a case number to a vendor only on purpose.

With that in place, "show me everything that happened to case 4471" becomes one query across agent runs, model calls and tool calls, whichever runtime they happened in.

One case, one thread
  1. 01Intake issues IDCRM, queue or form
  2. 02Agent runsCase ID on every span
  3. 03People actStage changes on the record
  4. 04Waits loggedWho holds the case, since when
  5. 05End stateResolved, with the reason

Every trace, step and wait is searchable by the same case ID.

Record the human steps and the waits in the same story

Agent telemetry only covers the parts an agent ran. The rest of the case lives in stage changes: who took it, when it moved, why it went back. Those belong on the case record, with timestamps and an owner, so they can be lined up next to the traces.

Microsoft says its new Trace Analytics "separates active work from waiting" inside a trace. Apply the same split one level up, to the case:

  • Active time: an agent or a person is working on it.
  • Waiting on us: the case sits in a queue we own.
  • Waiting on them: we need something from the customer or a supplier.

The second bucket is the one no span will ever show, because nothing is running. You cannot shorten a wait you never recorded.

Log the decision, not only the call

A span that says "tool called, 200 OK, 1.2 seconds" is useful for an engineer. The operations owner needs to know what the agent decided and what happened next. For each agent step, add a small set of business attributes:

  • case ID and the step name from the written procedure;
  • the version of the procedure, prompt or rule the agent applied;
  • the decision taken (approved, escalated, asked for more information);
  • the resulting stage and the next owner, person or agent.

These four fields turn a trace into an audit trail someone outside engineering can read. They also make the review after an incident much shorter: the question "which rule did the agent apply, and who had the case next?" has a one-line answer.

Keep content out of the trace by default

Microsoft's post notes that agent telemetry "can contain prompts, responses, and sensitive information", and its new access controls for that content are in preview. Do not wait for a platform feature to decide this.

  • Store references in the trace (case ID, document ID, message ID), not the customer's text.
  • Keep full prompts and responses in a separate store with shorter retention and named readers.
  • Decide which roles can open content and which see only metadata, before the first incident makes the decision for you.

Managed agents: ask for it before you sign

The same post points out that for managed agents "you can't instrument the platform's internal code yourself". If an agent runs on someone else's runtime, its visibility is whatever the provider exposes. Three questions belong in the evaluation, not after launch:

  1. Does it emit OpenTelemetry traces you can export to the tool you already use?
  2. Does it accept incoming trace context, so its work joins your trace instead of starting a new one?
  3. Can you attach your own case ID to its runs, and get it back in the output?

If the answer to the third is no, that agent's work will always be an island in your operation.

A Sentynel example

In the Rodo service operation, WhatsApp, social and web enquiries were brought into one operation with a measurable resolution path. The reported figure is that 82% of live-created enquiries reached Resolved. That number exists because each enquiry became a pipeline record with a stage, so its path could be followed from creation to end state. The source is Rodo's operational report of 24 September 2026; the resolution cohort covers 31 August to 24 September, and the figures describe pipeline records, not all conversations.

Rodo · first measured window
of live-created enquiries resolved

Source: Rodo operational report, 24 September 2026. The resolution cohort covers 31 August–24 September. Figures describe pipeline records, not all conversations.

A test for this week

Pick one case your team closed last week that an agent touched. Try to rebuild its full story from your tools: every agent run, every person who held it, every wait and why it ended. Time how long that takes and note where you had to ask someone instead of searching.

Each place you had to ask is a missing field. Which one would you add first?

Sources

  1. https://techcommunity.microsoft.com/blog/azureobservabilityblog/agent-observability-in-azure-monitor-at-ignite-2026/4573966
  2. https://www.w3.org/TR/trace-context/
  3. https://opentelemetry.io/docs/concepts/signals/baggage/
Share
← All sygnals