See every step
AI agent observability from prompt to tool result
Follow reasoning, sub-agent delegation, tool calls, results, errors, and completion in real time—then retain an operational record for debugging and review.
- AI agent observability
- agent observability best practices
- LLM observability
- AI audit logs
The execution protocol is the trace
AI agent observability starts with a typed event stream
An agent that only returns a final answer is a black box. SyntheticBrew streams 13 typed SSE event kinds while the agent works — the same events power your product UI, the admin dashboard's tool-call log, and the persisted session log, so everyone debugs the same run. SSE keep-alive signals keep long-running streams open through proxies and load balancers.
| Event | What your UI shows |
|---|---|
thinking | A live reasoning indicator — the agent is working, and on what. |
message_delta | Tokens streaming into the reply as they are generated. |
message | A completed assistant message. |
tool_call | Which tool the agent invoked, with its arguments. |
tool_result | The outcome and status of that tool call. |
confirmation | An approval prompt before a gated, consequential action runs. |
user_input_required | The agent is paused, waiting on the user. |
agent_spawn | A sub-agent was delegated part of the task. |
agent_result | That sub-agent finished and handed its output back. |
structured_output | A typed payload you can render as native UI — tables, cards, forms. |
agent.state_changed | Agent status transitions during the run. |
done | The run is complete, with its session id. |
error | A failure, with detail — never a silent hang. |
The operating checklist
AI agent observability best practices
What separates an agent you can operate from an agent you can only restart:
- Stream progress, not spinners. Render the typed events as visible steps — users trust an agent they can watch reason, delegate, and call tools.
- Persist the full event log for replay. When a production answer looks wrong, step through the exact run — every reasoning step, tool call, and result — instead of guessing from the final message.
- Audit every consequential action with actor context. Record who (or what) acted, on which resource, in which session — so a review question has an answer, not a shrug.
- Alert on circuit-breaker state and tool failure rates. Use the Prometheus tool-call metrics, labeled by tool and status, to catch a degrading MCP server before your users do.
- Correlate by session id. Event log, audit log, and tool-call log all carry the session id, so one identifier walks you across every record of a run.
These practices are what regulated deployments audit against — see how they apply in AI agents for banking workflows and across the enterprise platform.
Production signals
LLM observability with Prometheus metrics and health checks
The engine emits the numbers your existing monitoring stack expects — no sidecar, no agent-of-the-agent. The Prometheus endpoint activates with an Enterprise Edition license; health checks ship in Community Edition.
- Six metric families cover HTTP traffic and latency, active sessions, tool calls by tool and status, and LLM requests by provider and model.
- Health endpoint at
/api/v1/healthreports status, version, uptime, agents count, and a database ping — returning 503 when degraded, so your load balancer reacts automatically. - Resilience is observable. Every tool call runs under a 30-second timeout; circuit breakers open after 3 failures in a 60-second window and retry after 120 seconds (closed → open → half-open, admin-resettable), and an LLM retry wrapper absorbs transient provider errors.
# Scraped by Prometheus
syntheticbrew_http_requests_total
syntheticbrew_http_request_duration_seconds
syntheticbrew_active_sessions
syntheticbrew_tool_calls_total{tool,status}
syntheticbrew_llm_requests_total{provider,model}
syntheticbrew_llm_request_duration_seconds
# GET /api/v1/health -> status, version, uptime,
# agents count, DB ping (503 when degraded) Operational evidence
AI audit logs with actor, action, and resource
Streaming tells you what is happening; the audit trail tells you what happened. Every consequential operation is recorded with actor type and subject, action, resource, a structured details JSON payload, session id, and task id.
- A queryable tool-call log filters by session, tool, agent, status, user, and time — “show every failed call to the billing tool this week” is a query, not an archaeology project.
- The persisted session event log captures the full run — every reasoning step, tool call, and result — and the admin dashboard makes every tool call across every session searchable and drill-in-able.
- Observability and agent security share the same records: the log that helps you debug is the log that answers your auditor.
Questions
AI agent observability: common questions
What exactly is traced for each agent run?
Everything the run emitted: reasoning steps, streamed message deltas, every tool call with its result and status, sub-agent delegation and results, confirmations, state changes, errors, and completion. The full session event log is persisted, and the audit log adds actor type and subject, action, resource, a details JSON payload, session id, and task id for consequential operations.
Can I replay a past agent session?
Yes. The complete event log of every session is persisted and replayable, so you can step through a production run after the fact — what the agent thought, which tools it called, what came back, and why it answered the way it did.
Does SyntheticBrew integrate with Prometheus and Grafana?
Yes, with an Enterprise Edition license. The licensed engine exposes Prometheus metrics — HTTP request counts and latency, active sessions, tool calls labeled by tool and status, and LLM requests labeled by provider and model — so you can build Grafana dashboards and alert rules on the monitoring stack you already run. Health checks, the session event log, the tool-call log, and the audit trail are included in Community Edition.
How long are event and audit logs retained?
As long as you decide. Logs live in the PostgreSQL instance of your deployment — Cloud or self-hosted — so retention is configurable in your environment rather than dictated by the platform.
Keep exploring
AI agent observability pairs with these capabilities
See every step your agents take
Run an agent, open the tool-call log, and read every call it made — then wire the metrics into the monitoring you already trust.