What it is
Observability is being able to see what an AI system actually did. Not what it said it did, and not what you hoped it did, but the real sequence of steps: what went in, what the model decided, which tools it called, what came back, how long each part took, what it cost, and where it went wrong.
Think of a parcel delivery tracking page. You don't see the driver, but you see every stage: label created, collected, arrived at depot, out for delivery, delivered at 14:32 with a photo of your doorstep. When the parcel goes missing, the page tells you exactly where the trail stops. Or think of an aircraft's flight recorder, which quietly writes down everything so that, if something goes wrong, investigators can reconstruct the flight step by step instead of guessing.
A simple chatbot conversation barely needs this. You asked, it answered, and you can see both. But an agent, an AI that takes actions toward a goal, might search the web, read three pages, call a calculator, write a draft, check it, rewrite it and send an email, all in one go. If the final email is wrong, you need to know which of those eleven steps went wrong. Without a record, all you have is a bad result and a confident summary.
Observability is built from a few kinds of record:
- Logs. A diary of events, one line at a time: "10:02 search started", "10:02 search returned 8 results", "10:03 error: page could not be read". Logs are the oldest and simplest kind of record in software.
- Traces. A trace follows one request from start to finish and shows every step inside it, nested like an outline. For an AI system, each step (called a span) records its inputs and outputs: the exact prompt sent to the model, the model's reply, the arguments passed to a tool and the tool's result. A trace is the tracking page for one job.
- Cost and token tracking. AI models charge by tokens, the small chunks of text they read and write. A trace that records tokens per step shows where the money goes, which is often a surprise: a single step that pastes a huge document into every call can cost more than everything else combined.
- Latency. How long each step takes. A slow answer is usually one slow step, and the trace shows which.
- Errors. Which steps failed, and how. Some errors are loud (the tool crashed). The dangerous ones are quiet: the tool returned nothing and the model carried on anyway, or the answer came back well-formed but wrong.
It helps to separate observability from a neighbouring idea. Observability tells you what happened: the model received this, called that tool, and produced this answer. Interpretability tries to explain why the model did it, by looking inside the model's internal workings. A trace can show you that an agent picked the wrong hotel. It can't show you what went on inside the model that made that choice. The two work together, but they're different jobs, and most people building with AI only ever need the first.
Why it matters
You can't fix what you can't see. When a multi-step AI system gives a bad result, the cause is usually one early step: a search that returned the wrong page, a tool that silently failed, a document that was cut off because it didn't fit. Everything after that step can be perfectly sensible and still wrong. The orchestration article makes the same point: logging each step is how you find which one broke. With a trace, debugging takes minutes. Without one, you rerun the whole thing and hope it misbehaves in the same way.
It's how trust is earned, gradually. Nobody should hand an agent their inbox or their payments on day one. The sensible path is to watch it closely, then less closely, as it proves itself. That only works if there's something to watch. Observability is what lets a human in the loop move from approving every step to reviewing a daily summary, and it's what the autonomy levels idea depends on: more freedom for the AI should come with better records, not fewer.
It keeps costs from creeping. AI bills are paid per use, and agents can loop. A bug that makes an agent retry a failed search forty times doesn't crash anything, it just costs forty times as much. Cost tracking per run, per step and per day turns that from a nasty surprise at the end of the month into an alert on the first afternoon.
It catches the failures that don't look like failures. Normal software fails loudly. AI systems often fail politely: a fluent answer built on an empty search result, a summary of a file that was never actually read. The tool use article's rule applies here: no trace, no tool. If the log doesn't show the tool ran and returned something sensible, don't believe the answer relied on it.
It feeds your tests. Every failure you find in a trace is a new case for your evals, the private test set you rerun whenever you change a prompt or a model. Observability is where you find out what really happens in live use; evals are where you make sure it doesn't happen again.
It matters more as systems run unattended. A chatbot you're typing into is observed by definition, because you're reading every reply. Scheduled tasks and workflow automation run at night while you sleep. The log is the only witness.
What ordinary users can see, and what they can't. Chat apps now show a thin slice of observability. Many display a tool log ("Searched the web", "Ran code", "Read file") that you can expand, cite the web search sources they used, and show a running summary of the model's "thinking". These are genuinely useful, and they're worth opening. But they aren't the full record. As the extended thinking article explains, the visible thinking is often a shortened summary written by a separate model, and research on chain of thought shows that even the full reasoning text doesn't always reflect what really drove an answer. Developer tools go much further: every prompt, every raw response, token counts, timings and errors, step by step. If you build anything that runs without you watching, you'll want the developer view.
Real-world examples
Google's four golden signals: the classic framework (2016 onwards)
Long before AI agents, engineers running huge websites had to decide what to watch. Google's book Site Reliability Engineering, published in 2016 and free online, gave an answer in its chapter on monitoring distributed systems that is still quoted everywhere. It names four "golden signals" and says that if you can only measure four metrics of a user-facing system, these are the ones:
- Latency: how long it takes to serve a request, keeping slow failures separate from slow successes.
- Traffic: how much demand the system is under.
- Errors: the rate of requests that fail. The book notes that some failures are explicit, while others are implicit, such as a response that reports success but carries the wrong content.
- Saturation: how full the system is, and how close it is to its limits.
That note about implicit errors is exactly the AI problem. A model that returns a confident, well-formatted, wrong answer is a success by every technical measure and a failure by the only one that matters. So AI observability adds signals of its own on top of the classic four: token usage and cost, and some measure of answer quality, whether that's user thumbs-down clicks, automated checks or an eval run against live samples.
Anthropic's postmortem: three bugs that the tests missed (August to September 2025)
In August 2025, users of Anthropic's Claude models began reporting that answers had got worse. On 17 September 2025, Anthropic published a detailed engineering postmortem explaining what had happened. It found three separate infrastructure bugs, not a change to the models. It stated plainly that it never reduces model quality because of demand, time of day or server load.
The first bug, starting on 5 August, sent some requests for its Sonnet 4 model to servers configured for a much longer context window. A routine load-balancing change on 29 August made it far worse: at the worst hour, on 31 August, 16 percent of Sonnet 4 requests were affected, and the company said roughly 30 percent of Claude Code users who made requests in that period had at least one message routed to the wrong kind of server. A second bug, from 25 August to 2 September, corrupted output so that some English prompts got Thai or Chinese characters in the reply. A third, a compiler problem on Google's TPU chips, affected its Haiku 3.5 model and was suspected in others.
What makes this a lesson in observability is Anthropic's account of why the bugs were hard to find. Its standard evaluations didn't catch the degradation, partly because Claude often recovers well from isolated mistakes. Each bug showed different symptoms on different platforms at different rates, so the reports looked like random noise. And internal privacy and security controls limited how and when engineers could look at users' conversations, which is a deliberate protection, but it meant they couldn't simply read the failing transcripts. The fixes the company listed were observability fixes: more sensitive evaluations, quality checks running continuously on the live production system, faster debugging tools that still respect privacy, and more weight on user feedback. If a company with a large engineering team can miss problems for weeks, a small business running an AI workflow without any logs certainly can.
Tracing becomes a standard feature (2023 to 2026)
In 2023, as developers began chaining model calls together, a group of tools appeared whose main job was to record traces of AI applications. LangChain, the company behind a popular framework for building AI apps, launched LangSmith in closed beta in July 2023, describing it as giving visibility and debugging information at each step of a sequence of model calls. Langfuse, started by founders who went through Y Combinator's Winter 2023 batch, launched publicly in July and August 2023 as an open-source tool for the same job. Arize AI released an open-source library called Phoenix in April 2023 for evaluating and monitoring model outputs. These tools, and others like them, change often, so check their current features and terms before choosing one.
By 2025 the big model providers were building tracing in. On 11 March 2025, OpenAI announced its Agents SDK, a toolkit for building agents, with integrated tracing. Its documentation says tracing is turned on by default and records model calls, tool calls, handoffs between agents and guardrail checks, all viewable in a traces dashboard. The same documentation is candid about privacy: by default the traces include potentially sensitive data such as the actual inputs and outputs, there's a setting to leave that out, and tracing isn't available at all to organisations using OpenAI's zero data retention option.
Meanwhile the wider software world was working on a common format so that traces from any tool could be read by any other. OpenTelemetry is the main open standard for recording what software does, backed by the Cloud Native Computing Foundation. On 5 December 2024, its blog introduced work on "semantic conventions" for generative AI: agreed names for things like the model used, the provider and token counts, so a trace means the same thing everywhere. Notably, recording the actual text of prompts and replies is switched off unless you turn it on, a privacy-first default. At the time of writing, these conventions have moved to their own dedicated project and are still evolving, with agent-level steps such as tool execution and agent runs being added. It's an emerging standard, not a finished one, but it's the direction the industry is heading: AI steps recorded in the same way as every other kind of software.
An everyday scenario: the missing product descriptions
This is an illustration, not a real case. Sam runs an online shop and has an automated workflow that writes product descriptions overnight: it reads each new product's spreadsheet row, looks up the supplier's page, drafts a description and posts it to the shop as a draft. One Monday, twelve of the forty descriptions are bland and generic, and three mention features the products don't have.
Sam's first instinct is to rewrite the prompt. Instead, he opens the run log the workflow tool keeps. Every one of the bad descriptions has the same pattern: the "look up supplier page" step returned a short error page, because the supplier had changed its website, and the writing step carried on with nothing but the product name. The model did what models do when they have no facts and are asked for a description: it produced something plausible, and in three cases invented details, a classic hallucination. The prompt was fine. The fix was a rule: if the supplier page returns fewer than 200 words, stop and flag the product for a person. The log also showed the lookup step was the slowest and most expensive part of the run, which he hadn't known.
Try it yourself
You don't need developer tools to start. The habit of observability is writing down what happened, every time, so that patterns become visible. This exercise takes five minutes a day for a week.
- Pick one AI workflow you use regularly. Drafting emails, summarising meetings, writing social posts, researching, coding. One workflow, used at least a few times this week.
- Make a log sheet. Open a spreadsheet or a note and create these columns: “
Date | Task | Tool/model | Time taken (min) | Cost (if known) | Result (good/bad) | What went wrong | Did I fix it by hand?“ For cost, use what the tool shows you. If you're on a flat monthly plan, leave it blank or note how many messages or credits you used. Plans and limits change, so check your own account for current details. - Log every run, including the good ones. A log of only failures tells you what goes wrong but not how often. Write one row per run, straight after you finish. Keep "what went wrong" short and specific: "invented a statistic", "ignored word limit", "search found an outdated page", "took four rewrites".
- Open the tool log each time. Whenever the app shows one, expand it. Did it actually search the web, run the code, or read the file you uploaded? Note in your sheet whenever the answer seemed to rely on a tool that the log shows didn't run or returned an error.
- Check the sources. If the answer cites sources, click two of them each time. Note in the sheet if a source doesn't say what the answer claimed.
- At the end of the week, analyse the log. Paste the whole sheet into a chatbot with this prompt: “` Below is a one-week log of how I used AI for one task. Each row is one run. Please analyse it and tell me:
- My overall success rate (good results out of total runs).
- The most common types of failure, grouped and counted.
- Any pattern in when failures happen (type of task, length of input, tool used, day, time taken).
- How much time I spent fixing results by hand in total.
- The single change most likely to reduce failures, and how I could test whether it worked next week. Only use what is in the log. If the log does not contain enough information to answer a question, say so. [paste your log here] “`
- Make one change and keep logging. Take the suggested change, or your own better idea, apply it, and log another week. Compare the two weeks' success rates. That comparison is the core loop of observability: see, change, see again.
- Turn failures into tests. Copy the inputs that produced bad results into a separate list. That list is the start of an eval set for this workflow, and next time you change your prompt or switch models you can rerun those cases first.
If you use an automation tool, look in its settings for a run history or execution log; most have one. Open a recent run and click through each step. You'll see the inputs and outputs of every step, which is a trace in all but name.
Common mistakes and misunderstandings
Treating the final summary as the record. Agents usually finish with a tidy message saying what they did. That message is written by the model and can be wrong. The record is the log of what actually ran.
Reading the "thinking" as a full explanation. The visible thinking in chat apps is often a summary, and even the full reasoning text may not reflect the real causes of an answer. Use it to spot obvious wrong turns, not as proof. For the deeper question of why a model behaves as it does, that's interpretability, a research field, not a feature you can switch on.
Logging everything, forever, without thinking about privacy. A trace that records inputs and outputs contains whatever your customers typed: names, addresses, health details, complaints. That makes logs one of the most sensitive things an AI system produces. Record only what you need, hide or remove personal details where you can, restrict who can read the logs, delete them on a schedule, and check where your tracing tool stores data. The privacy rules that apply to your customer data apply to your logs too.
Logging nothing because it feels like overhead. The opposite mistake. The first time a workflow fails and you can't tell why, you'll wish you had even a one-line-per-step record. Start small.
Only watching for crashes. An AI system can have zero errors in its logs and still be producing wrong answers. Watch quality too: sample some outputs every week and read them, track thumbs-down or complaints, and run your evals against real recent inputs.
Ignoring cost until the bill arrives. Track tokens or credits per run from the start, and set a spending alert if your provider offers one. Loops and retries are the usual culprits, and they're easy to spot in a trace.
Confusing observability with control. Seeing that an agent is about to do something harmful is only useful if something can stop it. Logs tell you what happened; guardrails and approval steps decide what's allowed to happen. You need both.
Assuming the tool you chose will stay the same. AI tracing products and standards are still changing quickly. Where possible, keep your records in a form you can export, and prefer tools that support open formats such as OpenTelemetry, so you're not locked in.
Related elements
- Agent: the multi-step systems that most need observability, because their mistakes hide inside the steps.
- Orchestration: coordinating steps and tools, where logging each step is how you find which one broke.
- Tool Use: the tool log is the only proof that a tool actually ran.
- Evals: the tests that failures found in your logs should turn into.
- Human in the Loop: people reviewing AI work, which depends on having a clear record to review.
- Autonomy Levels: how much freedom to give an AI, which should grow only as fast as your ability to see what it does.
- Scheduled Tasks: jobs that run while nobody is watching, where the log is the only witness.
- Extended Thinking: why the visible "thinking" is a summary, not the full story.
- Interpretability: the research into why a model does what it does, as opposed to what it did.
- Privacy: why logs full of customer data need the same care as the data itself.
- Tokens: the unit that AI cost tracking counts.
- Hallucination: the invented answer that a trace often reveals was built on an empty or failed step.