ABCDEFGHIJKLMNOPQRSTUVWXYZ

The EvalManifesto

Before Braintrust, I led the AI team at Figma. And before that, I founded Impira, a startup focused on ML-powered document extraction. At both companies, we'd change a model or tweak a prompt, something would silently break in production, and we'd discover it later through user pain, not through our tools. To fix this, we had to get really good at evals.

We built internal systems to continuously eval our models and prompts, understand regressions, and tie real user behavior back into how we measured quality. But once you start building evals, you immediately run into the problem of where the evaluation data comes from. You need agent observability to know what's actually happening in production. You need evals to know whether your agents are performing. And you need a tight feedback loop between the two if you want to move fast without breaking your users. At both companies, we built this stack from scratch, and spent a lot of time doing so.

Then, in a conversation with Elad Gil, one of our now-investors, he asked: "Why did you build the same internal tooling twice?"

Every serious AI team was reinventing the same internal tools for observability and evals. None of it was productized in a way that teams could just pick up and use. So we started Braintrust.

A lot has changed since then. Models keep improving. Agents have exploded. The amount of data agents generate and the amount of queries they send has strained the limits of many traditional databases. "Observability" as a category has started to become more porous as apps and agents blur together. Most of all, it's clear that observability for agents needs to be proactive, rather than a set of static dashboards or pre-set alerts.

The Braintrust of 2023 and the Braintrust of today are very different. Agents are the critical paradigm, and agent observability means being able to understand their behavior and improve their performance. We now support application logs in addition to agent traces. And we've built and rebuilt a custom database to make sure our customers can do all of this fast, at scale.

We've learned some things, both in building our own product and from working with customers. We've also developed some strong opinions about what to do, what not to do, and what it all means. I've benefited throughout my career from folks who pass on their knowledge and try to make the industry as a whole smarter. So to return the favor we're publishing everything we know about evals and agent observability.

These are our beliefs about how to eval agents. These are the terms and definitions you need to know to do them right. And these are the best practices for building quality agents.

Ankur Goyal

Principles

Evals and agent observability are AI infrastructure

The eval is as important as the model, harness, etc. It should be treated as part of the stack, not an afterthought.

If you’re building agents, you need to consider the infrastructure stack the same way you would for any software. What cloud provider, database, what IaC framework? What experiments, which scorers, which rubrics?

Agents are now in production, supporting products used by millions. We are past the point of toy demos and neat experiments. Serious products need serious infrastructure. And real infrastructure is observable.

Agents need to be evaled and monitored

Every agent needs to be developed with success criteria in mind from inception, so it can be properly evaled once in production.

Agents win or lose based on measures of quality that cannot be reduced to simple metrics, but which must complement existing methods of understanding application performance.

Testing and experimentation are new observability paradigms.

Agent observability is observability

Agent observability lets you see what your agents did, measure whether it was good, and systematically improve it.

It connects formerly disparate processes of tracing production behavior, evaluating output quality, and iterating on system configuration.

Traditional application observability is no longer separate from this workflow. Logs and metrics should be considered alongside agent traces. Debugging an app and debugging an agent are often part of the same process, and even if they’re not, it’s valuable to see logs and traces in the same place.

Agent observability should be proactive

Teams building agents deserve more from observability.

An observability platform should be one connected place for instrumentation, investigation, and measurement, enhanced with intelligence.

Teams need to automatically see behavior that needs attention, understand why it happened, turn the evidence into datasets, evaluators, and product changes, and measure the next version.

If observability isn’t proactive, then it isn’t agent observability.

Agent observability demands a Trace Lake

Agent traces are the authoritative record of how agents behave. Improving agents means learning from the sum of those traces.

Traditional tracing was built for deterministic software. It samples heavily, focuses on individual traces, and discards data fast. Once a trace is gone, you can’t return to it when a new question comes up.

Agent traces are massive. A typical trace is around 10 MB, and outliers reach tens of GB. Each one mixes text, prompts, tool calls, model outputs, and nested metadata.

Agents are now being used to answer questions about other agents, which has drastically increased the volume of queries. Those queries need to return in hundreds of milliseconds, on traces ingested seconds ago.

Existing databases and data warehouses are too slow and too expensive, and don’t understand agent structure. A Trace Lake keeps every trace searchable, stores it affordably in your own cloud, and continuously turns what it finds into evals.

Observability and product development are no longer separate

Evals are the new PRD, and should be considered at the start of any agent development lifecycle.

If you don’t know what success means for an agent, and can’t define the datasets for measuring this success, then you aren’t properly building for AI.

This doesn’t stop once the agent is live and in production.

Production data feeds into evals, which in turn feed into new product capabilities.

Observe, eval, optimize. The feedback loop is continuous.

Great agents are built by cross-functional teams

Evals are how these teams collaborate and iterate on their agents.

Software engineers ship and debug agents.

PMs define golden datasets, success criteria, and evals.

Data scientists and ML engineers plug into the same system to add rigor and depth.

Subject matter experts validate ground-truth for product and engineering teams.

Get started with Evals

Braintrust is the observability platform for agents in production. By actively applying intelligence to agent traces and automatically surfacing critical patterns, Braintrust helps teams at Notion, Stripe, Box, OpenAI, and Cloudflare ship quality agents at scale.

Start building
Encyclopedia Evalica →