Skip to content
HUIAHUB
VideointermediateEvaluation & observability

Three Questions Every Agent Engineer Should Be Able To Answer

by LangChain14:07 long8.1K views

Why watchA 14-minute LangChain talk on finding, reproducing and fixing agent failures using production traces, for engineers who run agents in production.

What this video covers

Jake Broekhuizen, from LangChain Labs, recorded this 14-minute talk during LangChain Presents: The Learning Loop, an evening event about continual learning hosted in San Francisco. His starting point (0:00) is the idea that a team should control the intelligence inside its product. At 0:38 he breaks that down into three checks: can you locate the failures, can you trigger them again on demand, and can you change something so they go away.

Locating failures comes first, from 1:30, by searching through traces from real usage. Using a large frontier model as the grader gets costly once traffic grows, so at 2:27 he describes training a smaller, fine-tuned grader to watch agent behavior in its place.

Reproduction is the subject from 4:10. Evals that only compare an input with an output fall short here. Starting at 5:25 he talks about specifying a simulated world plus a set of tasks that resemble real traffic. The worked example at 6:20 is the go-to-market agent LangChain runs internally. At 7:45 he discusses making those tasks difficult and resistant to reward hacking, and at 8:41 he shows how logged usage can feed the creation of new tasks and simulated worlds. From 9:15 he makes the case that product teams hold an advantage over frontier labs, because they observe how actual users work with their agents.

Fixes arrive at 11:08, applied both to the code wrapped around the model and to the model itself. The closing chapter at 12:34 looks at keeping up when the underlying models shift and user behavior changes.

Two links in the description add context: LangChain's blog post about building its GTM agent, and the LangSmith Observability product page.

Written by HuiaHub from the creator's title, description and chapters. All credit for the video goes to LangChain.

Key takeaways

  • Agent engineers need answers to three things: where failures happen, how to repeat them, and how to remove them.
  • A fine-tuned grader can scan production traces more cheaply than a frontier model acting as judge.
  • Simulated worlds and tasks modeled on real traffic reproduce failures that input-output evals miss.
  • Hard tasks matter, and they should be built to resist reward hacking.
  • Product teams see real user behavior, which lets them build environments frontier labs cannot.
  • Fixes belong in the agent code around the model, in the model itself, or both.

Chapters

  1. 0:00What it means to own your own intelligence (opens YouTube at this moment)
  2. 0:38The three questions every agent engineer should answer (opens YouTube at this moment)
  3. 1:30Question 1: mining production traces to find failures (opens YouTube at this moment)
  4. 2:27Fine-tuned judges for monitoring agents at scale (opens YouTube at this moment)
  5. 4:10Question 2: reproducing failures beyond input and output evals (opens YouTube at this moment)
  6. 5:25World specs and tasks that mimic production (opens YouTube at this moment)
  7. 6:20Example: the world and tasks for LangChain's GTM agent (opens YouTube at this moment)
  8. 7:45Keeping tasks hard and hard to reward hack (opens YouTube at this moment)
  9. 8:41Turning production data into tasks and worlds (opens YouTube at this moment)
  10. 9:15What app teams see that frontier labs can't (opens YouTube at this moment)
  11. 11:08Question 3: fixing failures at the harness and model layers (opens YouTube at this moment)
  12. 12:34Staying ahead as models and users change (opens YouTube at this moment)

More videos

All videos