# Navigating the AI Frontier: The Power of Synthetic Data and Agent Evaluations in LLM Development Boris Selitser, Okareo | MLOps Podcast | Episode 241 | 57:22 Hosted by Demetrios Brinkmann Source: https://www.youtube.com/watch?v=YOClk49Cy2o Channel: MLOps Community, now AAIF Live (https://www.youtube.com/@AAIFLive-x1r). Summarised by MLOps Talks. Page: https://mlopstalks.com/talks/navigating-the-ai-frontier-the-power-of-synthetic-data-and-agent-evaluations-in Published: 2024-06-18 Tags: agents, evals, rag, synthetic-data ## TL;DR - LLM application development has shorter iteration cycles, so software engineers need stronger data and metric-driven development skills. - Synthetic data can describe application-specific behaviors, generate evaluation scenarios, expose rare failures, and support fine-tuning. - Agent evaluations should focus on task completion, user feedback, control metrics, and fast application-specific tests rather than generic model benchmarks alone. ## Summary Boris Selitser describes how LLM application development is bringing software engineering and machine learning closer together. Foundation models shorten experimentation cycles, while production quality still depends on data work, retrieval design, and application-specific evaluation. He explains how synthetic data can turn expected behaviors into test scenarios, including negative cases such as application-specific jailbreaks and routing failures. For agents, Boris prefers offline analysis of production traces in many cases because agents can recover from errors in ways developers did not anticipate. He separates overall task completion and user feedback from control metrics such as turn limits and error loops. He also describes agent patterns including reflection, tool use, planning, routing, and multi-agent collaboration. Boris is candid that agent systems are still early and often require defensive prompts, controls, and careful domain selection. He expects simpler state machines to be easier to reason about than large graph-based designs. ## Key ideas ### LLM development is moving toward shorter software-style iteration cycles [03:38](https://www.youtube.com/watch?v=YOClk49Cy2o&t=218s) Boris says traditional machine learning projects could spend two to six months building a model without knowing the final result. Foundation models make iteration look more like software development, since prompt tuning and other changes can produce useful results much faster. That shift changes how teams build systems. Mechanical coding work is increasingly automated, while software engineers need to develop data skills and use metric-driven development. Demetrios Brinkmann adds that people can often move quickly from an initial idea to a useful prototype, but reaching higher quality requires work on data pipelines, vector databases, chunking, updates, cleanliness, and access controls. ### Synthetic data can define the behaviors an application must support [08:22](https://www.youtube.com/watch?v=YOClk49Cy2o&t=502s) Boris says many new LLM applications do not have enough historical production data because they enable use cases that were not possible before. Synthetic data lets teams generate expected scenarios and behaviors. Teams can describe what the system should do, including negative cases, and make those behaviors part of the evaluation flow. A routing application, for example, can test requests that are off-topic or that try to push the router outside its purpose. The tests should reflect the application rather than generic jailbreak prompts used against foundation models. Evaluations establish baselines, after which the same synthetic-data loop can support iteration and fine-tuning. ### Online intervention can stop agents from recovering in useful ways [13:02](https://www.youtube.com/watch?v=YOClk49Cy2o&t=782s) Boris describes a customer using a multi-turn agent system for DevOps automation. The system executes shell commands and Python scripts, provisions Kubernetes clusters, and updates Jira tickets. Since failures can occur at many levels, interrupting the agent at a particular generation can be counterproductive. Agents may find workarounds that the author did not anticipate, and some of those recoveries may be valuable. Boris therefore often favors offline post-processing of production activity. Teams can measure whether the task was completed, connect that result to user feedback, and inspect control metrics such as excessive turns or error loops. Online checks still make sense when latency is acceptable, such as checking whether generated code compiles before showing it to a user. ### Application value should guide metric selection [18:16](https://www.youtube.com/watch?v=YOClk49Cy2o&t=1096s) Boris argues that generic model benchmarks are useful as a starting index, but they do not determine whether an application works. The main metric should connect to user or business value. For customer support, issue resolution rate may be a useful top-level measure, although teams may also need to track resolution time, frustration, or repeat contacts. Boris describes metrics as something teams often get wrong at first and then revise. He recommends a second layer of fast, unit-test-style checks that prefer pass or fail results over vague scores. For generated JSON, these checks can verify the format, required sections, structure, and components before more expensive evaluations run. ### Retrieval evaluation needs relevance data from the application domain [29:34](https://www.youtube.com/watch?v=YOClk49Cy2o&t=1774s) Boris says retrieval has familiar information-retrieval measures such as MRR and NDCG, but the difficult question is what counts as relevant for a particular user and query. A recommendation can score well under a standard measure and still fail to match a user's taste. Synthetic data can help create initial retrieval sets from enterprise knowledge, allowing teams to isolate retrieval inside a larger pipeline and measure it. Subject matter experts are still needed to judge whether the generated material is relevant and suitable for evaluation. The data set has to reflect the field and the application rather than rely only on generic retrieval examples. ### Synthetic users can probe multi-turn agent behavior [33:01](https://www.youtube.com/watch?v=YOClk49Cy2o&t=1981s) For customer support systems, Boris suggests turning historical conversations into templates for scenarios such as complicated returns or policy questions. A language-model generator can then create simulated users with different personalities and behaviors, including aggressive customers. Those users can drive many-turn interactions against the system under evaluation. The approach can test a simple model or an agent-based system, and it lets teams expand the scenarios they want to probe. Boris presents this as a way to create a starting evaluation set, tune the application, and examine how it behaves across different user types and task conditions. ### Agents divide complex systems into collaborating modules [43:27](https://www.youtube.com/watch?v=YOClk49Cy2o&t=2607s) Boris describes agents as a software-like abstraction for splitting a large task into modules that collaborate and pass messages. He names several patterns: reflective agents inspect their own output for errors, tool-using agents call search or retrieval functions, planning agents decide how to break down a task, and multi-agent systems coordinate several specialized agents. A routing agent might choose between meeting retrieval, meeting summarization, and document retrieval. In systems that act on a compute environment, agents also need to handle unexpected outputs, recover from errors, and avoid endless loops. Controls and defensive prompts can impose safety thresholds. ### Agent architectures are early, and simpler control may be easier to reason about [48:27](https://www.youtube.com/watch?v=YOClk49Cy2o&t=2907s) Boris says agent deployment is still at an early stage despite the amount of attention it receives. He expects the architecture to evolve as teams learn which patterns work. He sees a natural progression from a RAG system toward routing and control loops, then toward more complex agent coordination. Boris is cautious about graph-based designs with many edges and messages because they can become difficult to design and reason about. A simpler state machine may be a safer starting point. He also advises choosing a focused domain and delivering a clear application outcome rather than building a generic framework aimed at every possible use case. ## Notable quotes - Boris Selitser: "I think synthetic data plays a huge role." (08:21) - Boris Selitser: "You definitely don't want to intervene in an online fashion." (14:07) - Boris Selitser: "It has to be application specific, it has to be use case specific." (18:16) - Boris Selitser: "Agents becomes like a nice abstraction that people can reason about and write code around." (43:49) - Boris Selitser: "A simpler state machine will probably be a safer start for a lot of people." (56:24) ## Tools & references mentioned - Okareo - Meta - Facebook - Jira - Kubernetes - MRR - NDCG - OpenAI Evals - Spotify - RAG - LatticeFlow AI - Andrew Ng ## Who should watch - You are building an LLM application and need to replace generic benchmarks with tests tied to user or business value. - Your agent handles multi-turn tasks, tools, or external compute, and you need a way to inspect failures without interrupting useful recovery behavior. - You are deciding whether to use synthetic users, routing, planning, or multi-agent patterns and want a cautious view of their current tradeoffs. ## Related talks - [Iterating on Your AI Evals](https://mlopstalks.com/talks/iterating-on-your-ai-evals) (Mariana Prazeres, 13:47) - [Making AI Reliable is the Greatest Challenge of the 2020s](https://mlopstalks.com/talks/making-ai-reliable-is-the-greatest-challenge-of-the-2020s) (Alon Bochman, RagMetrics, 1:01:38) - [Holistic Evaluation of Generative AI Systems](https://mlopstalks.com/talks/holistic-evaluation-of-generative-ai-systems) (Jineet Doshi, Intuit, 56:04) - [From Building Self-driving Cars to Building LLM Applications](https://mlopstalks.com/talks/from-building-self-driving-cars-to-building-llm-applications) (Effy Zhang, Baserun, 10:45) - [The Science of Improving AI Agents](https://mlopstalks.com/talks/the-science-of-improving-ai-agents) (, 26:43)