Agentforce observability: what Command Center actually shows you, and what it doesn't
You can't manage a digital workforce you can't see. Agentforce Observability went GA with Command Center, Agent Analytics, and OpenTelemetry session traces. Here's the telemetry you actually get, how to export it, and the metrics that tell you an agent is failing quietly.
The agent passed its tests, deflected 60% of tickets in the pilot, and went live to applause. Six weeks later, CSAT on agent-handled conversations is sliding and nobody can say why. Was it the model? A knowledge article that went stale? A topic that started misrouting after someone added a new action? An upstream API that got slower and pushed the agent into timeouts? The team has the same visibility into their production agent that they’d have into a black box: they can see what goes in and what comes out, and nothing in between.
This is the problem Salesforce named directly when it launched Agentforce 3 in June 2025 — the two blockers to scaling AI agents, in their framing, were visibility and control. Testing tells you an agent works before it ships. It tells you nothing about the thousand conversations it had yesterday. As agent fleets grow from one pilot to a dozen production agents spanning service, sales, and internal ops, “we deployed it and hoped” stops being a strategy and starts being an incident waiting for a root-cause meeting.
Agentforce Observability is Salesforce’s answer, and it reached general availability in November 2025. This post is a practitioner’s read on what it actually gives you — Command Center, Agent Analytics, session tracing over OpenTelemetry — how it fits with the testing discipline that comes before it, and the honest limits of watching an agent you still have to fix by hand.
The agentic SDLC has an operate phase now
The useful mental model is that Agentforce now spans a full software lifecycle: you build an agent in Agent Builder, you test it in Testing Center, you deploy it, and — the piece that was missing until recently — you observe it in production and feed what you learn back into the build. Observability is what closes that loop. Without it, the lifecycle is a one-way street: you ship and you’re blind.
That’s why treating observability as a launch-day afterthought is the wrong instinct. It’s the instrument panel for the operate phase, and you want it reading before the agent carries real traffic, not bolted on after the first quiet failure. The teams that scale agents past a single pilot are the ones that stood up the monitoring alongside the testing, so that “is this agent healthy” has an answer that isn’t a hunch.
Command Center: the fleet view
Command Center is the top-level surface — Salesforce describes it as the single source of truth for your digital labor force, rolling every agent’s activity, metrics, and telemetry into one dashboard. Its job is the question an ops lead actually asks: across all my production agents, is anything on fire right now?
What it surfaces in near real time:
- Agent health — a live read on whether agents are performing normally or degrading.
- Error rates — how often agents are failing to complete, hitting action errors, or falling over.
- Escalations — how often conversations are handed to humans, and whether that rate is climbing.
- Latency — how long agents are taking, which is the metric that most directly maps to customer patience.
- Alerts — flags that fire when something crosses a threshold, so you find out from the dashboard rather than from a complaint.
The distinction from testing matters. Testing Center asks “does this agent do the right thing on these cases?” against synthetic inputs you wrote. Command Center asks “is this agent actually doing the right thing right now?” against real traffic you didn’t script. The first is a gate; the second is a heartbeat. You need both, and they answer different questions — a fleet can pass every regression test and still be quietly degrading in production because reality sent it inputs your test set didn’t imagine.
Agent Analytics: the outcome metrics that matter
Underneath the health view sits Agent Analytics, a Tableau-powered analytical layer that shipped into Agentforce Studio at GA. This is where you move from “is it up” to “is it working,” and the metrics it centers on are the ones that actually tell you whether an agent is helping:
- Deflection — sessions the agent resolved on its own without escalating to a human. Worth being precise here, because it’s the metric most often misread: in Agentforce Observability, a deflected session is not a failure or an abandonment — it’s a success, a conversation the agent closed out without needing a person.
- Abandonment — sessions the customer left before resolution. This is the one that quietly kills CSAT, and it’s the counterweight to deflection: an agent can post a high “resolved without escalation” number while customers are actually giving up in frustration. Read the two together or you’ll congratulate yourself on deflection that’s really abandonment.
- Escalations — how often and, more usefully, from where conversations hand off to humans. A spike in escalations from one topic is a map straight to the thing that broke.
- Volume trends — how traffic is distributed across agents and topics over time, which is how you spot a topic that’s suddenly eating disproportionate load.
- Quality scores — an automated read on answer quality, typically an LLM grading the agent’s responses, so you’re not relying only on hard outcomes but on whether the answers were actually good.
The reason to care about the combination is that any single number lies. High deflection with rising abandonment is a failing agent wearing a success metric. Flat escalations with falling quality scores is an agent that’s confidently getting worse without tripping the obvious alarm. Agent Analytics exists so a service leader can see the business impact — is this thing reducing workload or generating rework? — while IT watches the health and latency side. Same telemetry, two audiences.
A deflection rate on its own is a vanity metric. Deflection next to abandonment, escalation source, and quality score is a diagnosis. Never report the first without the other three.
Session tracing: reading the reasoning chain
When an alert fires or a quality score drops, aggregate dashboards tell you that something’s wrong; they don’t tell you why. That’s what session tracing is for — the per-conversation record of what the agent actually did: which topic it classified the request into, which actions it called, what those actions returned, where the latency accumulated, and where the reasoning went off the rails.
This is the single most valuable tool for debugging a production agent, because most agent misfires aren’t the model saying something dumb — they’re the Atlas reasoning engine classifying a request into the wrong topic, or an action returning an error the agent then papered over, or grounding that came back empty. A trace makes those visible. Instead of re-reading the customer transcript and guessing, you watch the agent’s decision path step by step and see the exact point it chose wrong. In practice that turns a root-cause investigation from a half-day of speculation into a few minutes of reading the trace.
The architecturally important detail: Agentforce Observability uses an OpenTelemetry (OTEL)-compatible data model. That’s not a checkbox — it’s what lets you export session traces and telemetry out of Salesforce into the monitoring platforms your ops team already runs, whether that’s Datadog, Splunk, or an AI-specific tool like Arize. If you’re running a dozen agents next to a hundred microservices, you do not want agent health stranded in a Salesforce-only pane of glass. OTEL is the seam that lets agent telemetry sit in the same dashboards, alerting, and on-call rotation as everything else you operate.
# Conceptual shape of an exported session trace (OTEL spans)
session span: conversation_id=8x9..., agent=service_help, duration=4.2s
├─ span: topic_classification -> "order_status" (0.3s)
├─ span: retriever.knowledge -> 3 chunks (0.6s)
├─ span: action.getOrderStatus -> ERROR 504 timeout (3.1s) ⚠
└─ span: response_generation -> "Let me check..." (0.2s)
# The 504 in the action span is the root cause the transcript hides.That timeout span is the kind of thing no amount of transcript-reading surfaces cleanly and a trace makes obvious in one line. Trace storage and telemetry lean on Data Cloud under the hood, which is worth knowing for two reasons: it’s why the traces are queryable and joinable with the rest of your Data 360 estate, and it’s a reminder that retention isn’t free — telemetry is data, and data in Data Cloud meters.
What’s GA, what’s coming, and the honest gaps
Being precise about status matters here because this area is moving fast and it’s easy to demo a roadmap as if it shipped. At the November 2025 GA, Agent Analytics and Agent Optimization landed directly in Agentforce Studio, with the live Agent Health Monitoring capability scheduled to follow in Spring 2026. Summer ‘26’s Agentforce 360 push has continued deepening observability across teams, folding continuous performance insight into the studio experience. Check the current release notes before you commit an architecture to a specific capability — the difference between “GA” and “coming next release” is the difference between a plan and a wish.
Now the limits, because observability is diagnosis, not treatment:
- It tells you what’s wrong, not how to fix it. A trace showing a misrouted topic points at the problem; rewriting the topic’s instructions so Atlas classifies correctly is still your job, and it’s the same instruction-and-description craft that decides whether an agent works at all. Observability shortens the find loop dramatically and does nothing for the fix loop.
- Quality scores are a model grading a model. LLM-as-judge scoring is genuinely useful for catching drift at scale, but it’s an approximation with its own biases. Treat a falling quality score as a signal to go read traces, not as ground truth. Don’t wire an automated action to a quality number you haven’t validated against human review.
- Metrics without ownership rot. A dashboard nobody watches is theater. Deflection, abandonment, escalation source, and quality need an owner and a cadence — the same weekly-review discipline that keeps a Data 360 credit bill from drifting keeps an agent fleet honest. The tool makes the data available; someone still has to look.
- Observing multi-agent teams is harder than observing one agent. When an orchestrator routes across specialist agents, the interesting failures live in the seams — context dropped across a handoff, a misroute that burns actions before anyone notices. Session tracing across a handoff is exactly what you need to debug those, but it also means a single “conversation” is now a trace that spans multiple agents. Budget for the added complexity; a team is not a bigger agent.
The failure mode observability is really for
Step back and the reason this category exists is a specific, expensive failure pattern: agents fail quietly. A crashed microservice pages someone. An agent that started giving subtly worse answers because a knowledge article changed, or an upstream action got slower, or a topic began misrouting after an unrelated edit — that just erodes. CSAT drifts, deflection quietly converts to abandonment, and the first hard signal is a complaint escalation or a quarterly number that’s off. By then the damage is weeks deep.
Gartner’s projection that over 40% of agentic AI projects get cancelled by 2027 gets quoted for its shock value — and a meaningful share of those deaths aren’t dramatic. They’re pilots that shipped, drifted, lost trust, and got quietly switched off because nobody could prove they were working or catch them when they stopped. Observability is the instrument that turns quiet degradation into a caught, named, fixable event. It doesn’t make agents good. It makes them governable — and an ungovernable agent is one you eventually turn off, no matter how well it demoed.
What to actually do this quarter
Stand up Command Center before your next agent goes live, not after. Wire the OTEL export into whatever your ops team already watches, so agent health lives next to the rest of your production surface instead of in a tab nobody opens. Pick your metric set deliberately — deflection and abandonment, escalation by source, quality trend — and give it an owner with a weekly cadence. When something drifts, go to the traces first and the transcripts second. And keep the loop closed: what observability surfaces in production is the highest-signal input to your next round of testing and instruction tuning. Build, test, deploy, observe, and back to build. The agents that survive are the ones you can actually see.
Understanding the basics
What is Agentforce Observability?
Agentforce Observability is Salesforce’s toolset for monitoring, analyzing, and optimizing production AI agents. It reached general availability in November 2025 and includes Command Center for fleet-wide health monitoring, Agent Analytics for outcome metrics like deflection and escalation, and session tracing that records each conversation’s reasoning chain. It uses an OpenTelemetry-compatible data model so telemetry can be exported to external monitoring tools.
What is Agentforce Command Center?
Command Center is the top-level observability dashboard that Salesforce positions as the single source of truth for your digital workforce. It rolls every production agent’s activity, metrics, and telemetry into one near-real-time view of agent health, error rates, escalations, and latency, with alerts that flag issues as they cross thresholds. It answers the operational question of whether anything across your agent fleet is degrading right now.
How is observability different from testing an Agentforce agent?
Testing, in Testing Center, validates an agent against synthetic cases before deployment — it’s a gate. Observability watches the agent against real, unscripted production traffic after deployment — it’s a heartbeat. An agent can pass every regression test and still degrade in production because reality sends inputs the test set never imagined. The two are complementary phases of the agentic lifecycle: test before you ship, observe after.
Scaling past your first Agentforce pilot and realizing you can’t see what the fleet is doing? Talk to us — standing up observability and the operate-phase discipline around it is exactly the work we do.
