Skip to content

For AI agents: this site's index is at /llms.txt, and each docs page comes as Markdown at its URL plus .md.

Articles · November 20, 2026

AI agent monitoring: what to watch in production

An agent can answer every request with a 200 and still do the wrong thing. It tells a customer an order shipped while the tracker says processing. It promises a refund no tool issued. It calls the same failing tool three times and answers anyway. Uptime, latency and error rates show none of that. Monitoring an agent means reading what it did. This article lists what to watch, what a trace needs for it, and how to alert without noise.

What goes wrong that a dashboard doesn't show

Problem Example What catches it
A step failed A tool call ended in an error, and the run went on Each step's error in the trace
Retry loop The agent called a tool 3 times with the same arguments, and each call failed Each tool call's name, arguments and error
Made-up fact "Your order shipped", while the tracker returned processing The tool's result next to the answer
Overpromise A refund, a discount or a date that no tool call and no instruction backs The tool calls and the instructions next to the answer
Private data Someone else's details, a secret or the agent's own instructions in an answer The answer's text
Frustrated user The user says the answer was wrong, or asks for a person The session's later messages
No answer, or a refusal The run ended with nothing a user can use The answer's text

The first two are plain rules, as is an empty answer. The others need the text read next to what the agent's tools returned, which is why a count of errors misses them.

What a trace needs

  1. One trace per run. Give every step of a run the same trace id, its own span id and its parent's span id. A monitor can then show the run as a tree and mark the step that failed.
  2. Tool calls as their own steps, with what each got and what it returned. Without the tool's result, nothing can tell a made-up fact from a true one.
  3. The text. Most GenAI instrumentations for OpenTelemetry leave out the prompt and the answer until you turn on content capture. A call that arrives without them can't be checked.
  4. A name per AI call, the same each time, such as support-chat. With the span's default name, such as ChatCompletion, every call lands in one pile.
  5. The session and the user. A frustrated user shows in the next message, not in the answer. Send a hash of your user id, never a name or an email.
  6. The release. With the commit the running app was built from, you see which deploy an issue started with, and whether a fix reached production.
  7. Model, tokens, cost and duration, when you have them.

Rules first, a model for what only reading can tell

Rules cost nothing and never guess: an error, an empty answer, a retry loop, output that isn't valid JSON. Run them on every call.

A model reads what rules can't: an answer that contradicts a tool's result, or a promise nothing backs. Model checks are wrong some of the time, and a wrong alert costs more than a missed one, because people stop reading the alerts. Three habits keep them useful.

  1. Make the model quote. Keep a flag only when it quotes the call word for word. A flag without a quote is a guess.
  2. Flag nothing when unsure.
  3. Wait for a second case on the weakest signals. One frustrated user is the likeliest flag to be wrong. Two sessions are a pattern.

Alert on issues, not on calls

A thousand calls with the same problem are one thing to fix. Group calls with the same flag on the same AI call into one issue, and alert when an issue opens. Send the urgent ones at once: a failed call, no answer, an overpromise, private data. Send the rest once a day, the issue that hits the largest share of its call's traffic first.

Turn what you find into evals

An issue in production is a test case you didn't have. Add the call to your evals with what the answer should have been, fix the prompt or the code until it passes, and the next change that breaks it fails a pull request before it reaches a user. The same works in reverse: the rules your evals test are the checks to run in production.

Where the tools sit

  • Application monitoring tools, such as New Relic and Splunk, offer AI agent monitoring next to their infrastructure dashboards. They fit when the team that watches the servers watches the agents too.
  • LLM platforms, such as Langfuse, Braintrust and LangSmith, keep traces and score them with the evaluators you set up (Langfuse and Braintrust next to evalship).
  • evalship checks every AI call in a run with no evaluator to write, and ties each issue to your evals.

How evalship does this

Monitor takes an agent's traces over OpenTelemetry, from the Vercel AI SDK, LangChain, the OpenAI Agents SDK, Pydantic AI and Mastra, or from one HTTP call in your own code. It shows each run as a tree, with the steps that failed or were flagged marked. Rules check every call. A model checks what only reading can tell, each call next to the tool calls in its trace, and its flag stands only when it quotes the call word for word. Calls with the same flag make one issue, emailed when it opens, with a line for your coding agent to fix it. From a call's trace, one line to your coding agent adds it to your evals as a test case.

The Free plan takes 10,000 calls and steps a month. Monitor starts once your evals run, and setup is one line to your coding agent: Set up https://evalship.com/setup.md (quickstart).

Further reading