By Bruno Alho and Gonçalo Lourenço
Seven of us went to LangChain's conference. We came back talking about evals.
On Tuesday, we spent the day at Interrupt, LangChain's conference on AI agents.
We work as FDEs at Indicium AI, a global, AI-native data and AI consultancy, where we help clients build and ship AI agents. So naturally we went in curious about what was new, and came out thinking mostly about what it takes to put agents in production.
There were product announcements, and we'll cover those first. But talk after talk kept circling back to the same three topics: evals, traceability and governance. Spoiler: none of them depend on which framework you pick.
What LangChain Announced
Most of the product news was about LangSmith, LangChain's platform for observing and evaluating LLM applications. Two announcements stood out to us.
Agents can now run inside LangSmith. Using Deep Agents, LangChain's newest package, you can build, run and monitor an agent in one place. Fewer moving parts between "it works on my laptop" and "it's live" is always welcome.
Bring Your Own Cloud (BYOC). Until now you had two options: self-host LangSmith, or use LangChain's cloud. BYOC adds a third, where the platform runs in your own cloud account. If you've ever sat through a data residency conversation with a client's security team, you'll know why this matters.
It was a vendor conference, so yes, there was a healthy amount of selling the LangChain stack. But the products weren't what we were discussing on the way home.
The Framework Is the Easy Choice
The conversation has moved on from "can we build an agent?" to "can we trust it in production, and prove it?". That second question looks the same whether you use LangGraph, another framework or your own code. Every team runs into three problems:
- Evals: how do we know the agent does the right thing, before and after release?
- Traceability: when it gets something wrong, can we see why?
- Governance: can we show a client, an auditor or a regulator what the agent did, and who signed off?
Good tooling makes all three easier. Building the habit is still on us.
The agent can be built with anything. What makes it production-ready is what sits around it: a trace of every step, feeding both evals and governance.
Evals Are Your Agent's Test Suite
Nobody merges code without tests (well, nobody admits to it). Agents deserve the same treatment, with one twist: LLM outputs vary from run to run, so a single check before release isn't enough. The talks described evals at three stages:
- Offline evals run before every release against a curated dataset of inputs and expected behaviour. Change a prompt, a model or a tool, and they tell you what broke.
- Online evals score real production traffic continuously, using LLM-as-judge, simple heuristics and user feedback. They catch the drift and edge cases your dataset never imagined.
- Human review sends the tricky cases to domain experts. Their labels go back into the offline dataset, so every failure becomes a future test.
That feedback loop is the part teams most often skip, and it's the part that makes the agent actually improve.
Offline evals gate each release, online evals watch production, and human review turns the hard cases into new entries in the dataset.
The announcement that fit this theme best was Red Teaming in LangSmith Engine. It reads your agent's traces and code to learn what the agent is for, then probes it for failures that haven't happened in production yet, like hallucinations or ignored system-prompt rules. Each confirmed issue arrives with a root cause, a suggested fix and test cases for your eval dataset. In other words, it writes the tests you forgot to. It's still in private beta and only for agents on LangSmith Deployment, but it's the right direction.
A probe only becomes an issue once the failure is confirmed, so you aren't flooded with false alarms. Each issue then splits two ways: a fix that's tested before you see it, and new test cases that go straight into your eval dataset.
Traceability: Show Your Working
Remember maths teachers asking you to show your working? Agents need the same rule. A final answer is the end of a chain of retrievals, tool calls and LLM calls. Log only the answer and a wrong one is a mystery. Trace every step and it becomes a bug with an address.
A useful trace records, for every run:
- each LLM call, with its inputs, outputs, latency and cost
- each tool call and what came back
- each retrieval and the documents it surfaced
- the decision the agent took at each branch
With that in place, you can follow a bad answer back to its cause, whether that's the retriever pulling the wrong document or a tool returning stale data. Fix it, then add the case to your eval set so it can't sneak back in.
With only the final answer logged, the bad retrieval is invisible. With every step traced, it is the first thing you see.
Governance: Keeping the Receipts
This is where evals and traceability pay off for the business. The traces you collect for debugging double as an audit trail: a record of what the agent saw, what it did and why.
The other half is keeping people in control where it counts. Human-in-the-loop checkpoints let an agent pause before a high-impact action (sending an email, changing a record, approving a payment) and wait for someone to confirm.
For clients in regulated industries, this is often what decides whether a pilot ever makes it to production.
Low-impact actions run straight away. High-impact ones wait for a person. Either way, the action ends up in the audit trail.
What We're Taking Back to Our Projects
At Indicium AI we put agents in front of clients, so these practices belong in the delivery from day one. Here's the checklist we left Interrupt with:
- Start an eval dataset on day one, even a small one, and grow it with every failure you find
- Run offline evals on every change to a prompt, model or tool
- Score production traffic continuously, not only at launch
- Trace every step of every run, not just the final answer
- Add human approval before any action that's hard to undo
- Agree with the client up front what "good" looks like and how you'll measure it
None of this needs a particular vendor. It needs the discipline to treat agents like any other production software.
What We'd Love to See at Interrupt 2027
We'll be back next year. Two wishes for the organisers:
- More "what broke, and how we fixed it" stories. Next year, we'd love to swap some of the "what went right" stories for "what went wrong, and how we fixed it" ones. Those are the talks we learn the most from.
- More room in the eval workshops. The hands-on eval workshops were the right idea, but they filled up so fast that we couldn't get into any. Bigger rooms, more sessions or a waitlist would let more people actually attend.
Final Thoughts
Interrupt confirmed something we already suspected: the agents that reach production are the ones people can test, explain and audit. Frameworks will keep coming and going. Those three habits will stay.
If we had to put what we learned in one sentence: choose your framework in an afternoon, then spend the rest of the project on evals and traces.
Working on agents yourself? We'd love to compare notes on evals or traceability in the comments.
Written by Bruno Alho, Senior FDE, and Gonçalo Lourenço, Senior FDE, at Indicium AI. Follow us on LinkedIn: Bruno Alho · Gonçalo Lourenço. All views are our own.
If you enjoyed this, subscribe to the Indicium AI blog to keep up with what our technologists publish next.
