The Future of AI: Structured Vibe Coding - An Improved Approach to AI Software Development
In this post from The Future of AI series, the author introduces structured vibe coding, a method for managing AI agents like a software team using specs, GitHub issues, and pull requests. By applying this approach with GitHub Copilot, they automated a repetitive task—answering Microsoft Excel-based questionnaires—while demonstrating how AI can enhance developer workflows without replacing human oversight. The result is a scalable, collaborative model for AI-assisted software development.How Microsoft Evaluates LLMs in Azure AI Foundry: A Practical, End-to-End Playbook
Deploying large language models (LLMs) without rigorous evaluation is risky: quality regressions, safety issues, and expensive rework often surface in production—when it’s hardest to fix. This guide translates Microsoft’s approach in Azure AI Foundry into a practical playbook: define metrics that matter (quality, safety, and business impact), choose the right evaluation mode (offline, online, human-in-the-loop, automated), and operationalize continuous evaluation with the Azure AI Evaluation SDK and monitoring. Quick-Start Checklist Identify your use case: Match model type (SLM, LLM, task-specific) to business needs. Benchmark models: Use Azure AI Foundry leaderboards for quality, safety, and performance, plus private datasets. Evaluate with key metrics: Focus on relevance, coherence, factuality, completeness, safety, and business impact. Combine offline & online evaluation: Test with curated datasets and monitor real-world performance. Leverage manual & automated methods: Use human-in-the-loop for nuance, automated tools for scale. Use private benchmarks: Evaluate with organization-specific data for best results. Implement continuous monitoring: Set up alerts for drift, safety, and performance issues. Terminology Quick Reference SLM: Small Language Model—compact, efficient models for latency/cost-sensitive tasks. LLM: Large Language Model—broad capabilities, higher resource requirements. MMLU: Multitask Language Understanding—academic benchmark for general knowledge. HumanEval: Benchmark for code generation correctness. BBH: BIG-Bench Hard—reasoning-heavy subset of BIG-Bench. LLM-as-a-Judge: Using a language model to grade outputs using a rubric. The Generative AI Model Selection Challenge Deploying an advanced AI solution without thorough evaluation can lead to costly errors, loss of trust, and regulatory risks. LLMs now power critical business functions, but their unpredictable behavior makes robust evaluation essential. The Issue: Traditional evaluation methods fall short for LLMs, which are sensitive to prompt changes and can exhibit unexpected behaviors. Without a strong evaluation strategy, organizations risk unreliable or unsafe AI deployments. The Solution: Microsoft Azure AI Foundry provides a systematic approach to LLM evaluation, helping organizations reduce risk and realize business value. This guide shares proven techniques and best practices so you can confidently deploy AI and turn evaluation into a competitive advantage. LLMs and Use-Case Alignment When choosing an AI model, it’s important to match it to the specific job you need done. For example, some models are better at solving problems that require logical thinking or math—these are great for tasks that need careful analysis. Others are designed to write computer code, making them ideal for building software tools or helping programmers. There are also models that excel at having natural conversations, which is especially useful for customer service or support roles. Microsoft Azure AI Foundry helps with this by showing how different models perform in various categories, making it easier to pick the right one for your needs. Key Metrics: Quality, Safety, and Business Impact When evaluating an AI model, it’s important to look beyond just how well it performs. To truly understand if a model is ready for real-world use, we need to measure its quality, ensure it’s safe, and see how it impacts the business. Quality metrics show if the model gives accurate and useful answers. Safety metrics help us catch any harmful or biased content before it reaches users. Business impact metrics connect the model’s performance to what matters most—customer satisfaction, efficiency, and meeting important rules or standards. By tracking these key areas, organizations can build AI systems that are reliable, responsible, and valuable. Dimension What it Measures Typical Evaluators Quality Relevance, coherence, factuality, completeness LLM-as-a-judge, groundedness, code eval Safety Harmful content, bias, jailbreak resistance, privacy Content safety checks, bias probes Business Impact User experience, value delivery, compliance Task completion rate, CSAT, cost/latency Organizations that align model selection with use-case-specific benchmarks deploy faster and achieve higher user satisfaction than teams relying only on generic metrics. The key is matching evaluation criteria to business objectives from the earliest stages of model selection. Now that we know which metrics and parameters to evaluate LLMs on, when and how do we run these evaluations? Let’s get right into it. Evaluation Modalities Offline vs. Online Evaluation Offline Evaluation: Pre-deployment assessment using curated datasets and controlled environments. Enables reproducible testing, comprehensive coverage, and rapid iteration. However, it may miss real-world complexity. Online Evaluation: Assesses model performance on live production data. Enables real-world monitoring, drift detection, and user feedback integration. Best practice: use offline evaluation for development and gating, then online evaluation for continuous monitoring. Manual vs. Automated Evaluation Manual Evaluation: Human insight is irreplaceable for subjective qualities like creativity and cultural sensitivity. Azure AI Foundry supports human-in-the-loop evaluation via annotation queues and feedback systems. However, manual evaluation faces scalability and consistency challenges. Automated Evaluation: Azure AI Foundry’s built-in evaluators provide scalable, rigorous assessment of relevance, coherence, safety, and performance. Best practice: The most effective approach combines automated evaluation for broad coverage with targeted manual evaluation for nuanced assessment. Leading organizations implement a "human-in-the-loop" methodology where automated systems flag potential issues for human review. Public vs. Private Benchmarks Public Benchmarks (MMLU, HumanEval, BBH): Useful for standardized comparison but may not reflect your domain or business objectives. Risk of contamination and over-optimization. Private Benchmarks: Organization-specific data and metrics provide evaluation that directly reflects deployment scenarios. Best practice: Use public benchmarks to narrow candidates, then rely on private benchmarks for final decisions. LLM-as-a-Judge and Custom Evaluators LLM-as-a-Judge uses language models themselves to assess the quality of generated content. Azure AI Foundry’s implementation enables scalable, nuanced, and explainable evaluation—but requires careful validation. Common challenges and mitigations: Position bias: Scores can skew toward the first-listed answer. Mitigate by randomizing order, evaluating both (A,B) and (B,A), and using majority voting across permutations. Verbosity bias: Longer answers may be over-scored. Mitigate by enforcing concise-answer rubrics and normalizing by token count. Inconsistency: Repeated runs can vary. Mitigate by aggregating over multiple runs and reporting confidence intervals. Custom Evaluators allow organizations to implement domain-specific logic and business rules, either as Python functions or prompt-based rubrics. This ensures evaluation aligns with your unique business outcomes. Evaluation SDK: Comprehensive Assessment Tools The Azure AI Evaluation SDK (azure-ai-evaluation) provides the technical foundation for systematic LLM assessment. The SDK's architecture enables both local development testing and cloud-scale evaluation: Cloud Evaluation for Scale: The SDK seamlessly transitions from local development to cloud-based evaluation for large-scale assessment. Cloud evaluation enables processing of massive datasets while integrating results into the Azure AI Foundry monitoring dashboard. Built-in Evaluator Library: The platform provides extensive pre-built evaluators covering quality metrics (coherence, fluency, relevance), safety metrics (toxicity, bias, fairness), and task-specific metrics (groundedness for RAG, code correctness for programming). Each evaluator has been validated against human judgment and continuously improved based on real-world usage. Real-World Workflow: From Model Selection to Continuous Monitoring Azure AI Foundry's integrated workflow guides organizations through the complete evaluation lifecycle: Stage 1: Model Selection and Benchmarking Compare models using integrated leaderboards across quality, safety, cost, and performance dimensions Evaluate top candidates using private datasets that reflect actual use cases Generate comprehensive model cards documenting capabilities, limitations, and recommended use cases Stage 2: Pre-Deployment Evaluation Systematic testing using Azure AI Evaluation SDK with built-in and custom evaluators Safety assessment using AI Red Teaming Agent to identify vulnerabilities Human-in-the-loop validation for business-critical applications Stage 3: Production Monitoring and Continuous Evaluation Real-time monitoring through Azure Monitor Application Insights integration Continuous evaluation at configurable sampling rates (e.g., 10 evaluations per hour) Automated alerting for performance degradation, safety issues, or drift detection This workflow ensures that evaluation is not a one-time gate but an ongoing practice that maintains AI system quality and safety throughout the deployment lifecycle. Next Steps and Further Reading Explore the Azure AI Foundry documentation for hands-on guides. Find the Best Model - https://aka.ms/BestModelGenAISolution Azure AI Foundry Evaluation SDK Summary Robust evaluation of large language models (LLMs) using systematic benchmarking and Azure AI Foundry tools is essential for building trustworthy, efficient, and business-aligned AI solutions Tags: #LLMEvaluation #AzureAIFoundry #AIModelSelection #Benchmarking #Skilled by MTT #MicrosoftLearn #MTTBloggingGroupWant Safer, Smarter AI? Start with Observability in Azure AI Foundry
Observability in Azure AI: From Black Box to Transparent Intelligence If you are an AI developer or an engineer, you can benefit from Azure AI observability by gaining deep visibility into agent behavior, enabling them to trace decisions, evaluate response quality, and integrate automated testing into their workflows. This empowers you to build safer, more reliable GenAI applications. Responsible AI and compliance teams use observability tools to ensure transparency and accountability, leveraging audit logs, policy mapping, and risk scoring. These capabilities help organizations align AI development with ethical standards and regulatory requirements. Understanding Observability Imagine you're building a customer support chatbot using Azure AI. It’s designed to answer billing questions, troubleshoot issues, and escalate complex cases to human agents. Everything works well in testing—but once deployed, users start reporting confusing answers and slow response times. Without observability, you’re flying blind. You don’t know: Which queries are failing. Why the chatbot is choosing certain responses. Whether it's escalating too often or not enough. How latency and cost are trending over time. Enter Observability: With Azure AI Foundry and Azure Monitor, you can: Trace every interaction: See the full reasoning path the chatbot takes—from user input to model invocation to tool calls. Evaluate response quality: Automatically assess whether answers are grounded, fluent, and relevant. Monitor performance: Track latency, throughput, and cost per interaction. Detect anomalies: Use Azure Monitor’s ML-powered diagnostics to spot unusual patterns. Improve continuously: Feed evaluation results back into your CI/CD pipeline to refine the chatbot with every release. This is observability in action: turning opaque AI behavior into transparent, actionable insights. It’s not just about fixing bugs—it’s about building AI you can trust. Next, let’s understand more about observability: What Is Observability in Azure AI? Observability in Azure AI refers to the ability to monitor, evaluate, and govern AI agents and applications across their lifecycle—from model selection to production deployment. It’s not just about uptime or logs anymore. It’s about trust, safety, performance, cost, and compliance. Observability aligned with the end-to-end AI application development workflow. Image source: Microsoft Learn Key Components and Capabilities Azure AI Foundry Observability Built-in observability for agentic workflows. Tracks metrics like performance, quality, cost, safety, relevance, and “groundedness” in real time. Enables tracing of agent interactions and data lineage. Supports alerts for risky or off-policy responses and integrates with partner governance platforms. Find details on Observability here: Observability in Generative AI with Azure AI Foundry - Azure AI Foundry | Microsoft Learn AI Red Teaming (PyRIT Integration) Scans agents for safety vulnerability. Evaluates attack success rates across categories like hate, violence, sexual content, and l more. Generates scorecards and logs results in the Foundry portal. Find details here: AI Red Teaming Agent - Azure AI Foundry | Microsoft Learn Image source: Microsoft Learn CI/CD Integration GitHub Actions and Azure DevOps workflows automate evaluations. Continuous monitoring and regression detection during development Azure Monitor + Azure BRAIN Uses ML and LLMs for anomaly detection, forecasting, and root cause analysis. Offers multi-tier log storage (Gold, Silver, Bronze) with unified KQL query experience. Integrates with Azure Copilot for diagnostics and optimization. Open Telemetry Extensions Azure is extending OTel with agent-specific entities like AgentRun, ToolCall, Eval, and ModelInvocation. Enables fleet-scale dashboards and semantic tracing for GenAI workloads. Observability as a First-Class Citizen in Azure AI Foundry In Azure AI Foundry, observability isn’t bolted on—it’s built in. The platform treats observability as a first-class capability, essential for building trustworthy, scalable, and responsible AI systems. Image source: Microsoft Learn What Does This Mean in Practice? Semantic Tracing for Agents Azure AI Foundry enables intelligent agents to perform tasks using AgentRun, ToolCall, and ModelInvocation. AgentRun manages the entire lifecycle of an agent's execution, from input processing to output generation. ToolCall allows agents to invoke external tools or APIs for specific tasks, like fetching data or performing calculations. ModelInvocation lets agents directly use AI models for advanced tasks, such as sentiment analysis or image recognition. Together, these components create adaptable agents capable of handling complex workflows efficiently. Integrated Evaluation Framework Developers can continuously assess agent responses for quality, safety, and relevance using built-in evaluators. These can be run manually or automatically via CI/CD pipelines, enabling fast iteration and regression detection. Governance and Risk Management Observability data feeds directly into governance workflows. Azure AI Foundry supports policy mapping, risk scoring, and audit logging, helping teams meet compliance requirements while maintaining agility. Feedback Loop for Continuous Improvement Observability isn’t just about watching—it’s about learning. Azure AI Foundry enables teams to use telemetry and evaluation data to refine agents, improve performance, and reduce risk over time. Now, Build AI You Can Trust Observability isn’t just a technical feature—it’s the foundation of responsible AI. Whether you're building copilots, deploying GenAI agents, or modernizing enterprise workflows, Azure AI Foundry and Azure Monitor give you the tools to trace, evaluate, and improve every decision your AI makes. Now is the time to move beyond black-box models and embrace transparency, safety, and performance at scale. Start integrating observability into your AI workflows and unlock the full potential of your agents—with confidence. Read more here: Plans | Microsoft Learn Observability and Continuous Improvement - Training | Microsoft Learn Observability in Generative AI with Azure AI Foundry - Azure AI Foundry | Microsoft Learn About the Author Priyanka is a Technical Trainer at Microsoft USA with over 15 years of experience as a Microsoft Certified Trainer. She has a profound passion for learning and sharing knowledge across various domains. Priyanka excels in delivering training sessions, proctoring exams, and upskilling Microsoft Partners and Customers. She has significantly contributed to AI and Data-related courseware, exams, and high-profile events such as Microsoft Ignite, Microsoft Learn Live Shows, MCT Community AI Readiness, and Women in Cloud Skills Ready. Furthermore, she supports initiatives like “Code Without Barrier” and “Women in Azure AI,” contributing to AI Skills enhancements. Her primary areas of expertise include courses on Development, Data, and AI. In addition to maintaining and acquiring new certifications in Data and AI, she has also guided learners and enthusiasts on their educational journeys. Priyanka is an active member of the Microsoft Tech community, where she reviews and writes blogs focusing on Data and AI. #SkilledByMTT #MSLearn #MTTBloggingGroup
The Future of AI: An Intern’s Adventure Turning Hours of Video into Minutes of Meaning
This blog post, part of The Future of AI series by Microsoft’s AI Futures team, follows an intern’s journey in developing AutoHighlight—a tool that transforms long-form video into concise, narrative-driven highlight reels. By combining Azure AI Content Understanding with OpenAI reasoning models, AutoHighlight bridges the gap between machine-detected moments and human storytelling. The post explores the challenges of video summarization, the technical architecture of the solution, and the lessons learned along the way.Azure AI Search: Microsoft OneLake integration plus more features now generally available
From ingestion to retrieval, Azure AI Search releases enterprise-grade GA features: new connectors, enrichment skills, vector/semantic capabilities and wizard improvements—enabling smarter agentic systems and scalable RAG experiences.Keeping Agents on Track: Introducing Task Adherence in Azure AI Foundry
Task Adherence is coming soon to public preview in both the Azure AI Content Safety API and Azure AI Foundry. It helps developers ensure AI agents stay aligned with their assigned tasks, preventing drift, misuse, or unsafe tool calls.Announcing GPT‑5‑Codex: Redefining Developer Experience in Azure AI Foundry
Today, we’re excited to announce OpenAI’s GPT‑5‑Codex is generally available in Azure AI Foundry, and in public preview for GitHub Copilot in Visual Studio Code. This release is the next step in our continuous commitment to empower developers with the latest model innovation, now building on the proven strengths of the earlier Codex generation along with the speed and CLI fluency many teams have adopted with the latest codex‑mini. Next-level features for developers Multimodal coding in a single flow: GPT-5-Codex accepts multimodal inputs including text and image. With this multimodal intelligence, developers are now empowered to tackle complex tasks, delivering context-aware, repository-scale solutions in one single workflow. Advanced tool use across various experiences: GPT-5-Codex is built for real-world developer experiences. Developers in Azure AI Foundry can get seamless automation and deep integration via the Response API, improving developers’ productivity and reducing development time. Code review expertise: GPT‑5‑Codex is specially trained to conduct code reviews and surface critical flows, helping developers catch issues early and improve code quality with AI-powered insights. It transforms code review from a manual bottleneck into an intelligent, adaptive and integrated process, empowering developers to deliver high-quality code experience. How GPT‑5‑Codex makes your life easier Stay in flow, not in friction: With GPT‑5‑Codex, move smoothly from reading issues to writing code and checking UI; all in one place. It keeps context, so developers stay focused and productive. No more jumping between tools or losing track of what they were doing. Refactor and migrate with confidence: Whether cleaning up code or moving to a new framework, GPT‑5‑Codex helps stage updates, run tests, and fix issues as you go. It’s like having a digital colleague for those tricky transitions. Hero use cases: real impact for developers Repo‑aware refactoring assistant: Feed repo and architecture diagrams to GPT‑5‑Codex. Get cohesive refactors, automated builds, and visual verification via screenshots. Flaky test hunter: Target failing test matrices. The model executes runs, polls status, inspects logs, and recommends fixes looping until stability. Cloud migration copilot: Edit IaC scripts, kick off CLI commands, and iterate on errors in a controlled loop, reducing manual toil. Pricing and Deployment available at GA Deployment Available Region Pricing ($/million tokens) Standard Global East US 2 Sweden Central Input Cached Input Output $1.25 $0.125 $10.00 GPT-5-Codex is bringing developers’ coding experience to a new level. Don’t just write code. Let’s redefine what’s possible. Start building with GPT-5-Codex today and turn your bold ideas into reality now powered by the latest innovation in Azure AI Foundry.Announcing the Grok 4 Fast Models from xAI: Now Available in Azure AI Foundry
These models, grok-4-fast-reasoning and grok-4-fast-non-reasoning, empower developers with distinct approaches to suit their application needs. Each model brings advanced capabilities such as structured outputs, long-context processing, and seamless integration with enterprise-grade security and governance. This release marks a significant step toward scalable, agentic AI systems that orchestrate tools, APIs, and domain data with low latency. Leveraging the Grok 4 Fast models within Azure AI Foundry Models accelerates the development of intelligent applications that combine speed, flexibility, and compliance. The unified model experience, paired with Azure’s enterprise controls, positions the Grok 4 Fast models as foundational technologies for next-generation AI-powered workflows. Why use the Grok 4 Fast Models on Azure Modern AI applications are increasingly agentic—capable of orchestrating tools, APIs, and domain data at low latency. The Grok 4 Fast models were designed for these patterns: fast, intelligent, and agent-ready, enabling parallel tool use, JSON-structured outputs, and image input for multimodal understanding. Azure AI Foundry enhances these models with enterprise controls (RBAC, private networking, customer-managed keys), observability and evaluations, and first-party hosting through Foundry Models—helping teams move confidently from prototype to production. Beyond that, using the Grok 4 Fast models on Azure offers the following: Global scalability and reliability – Azure’s worldwide infrastructure supports resilient, high-availability deployments across multiple regions. Integrated security and compliance – Enterprise-grade identity management, network isolation, encryption at rest and in transit, and compliance certifications help safeguard sensitive data and comply with regulatory requirements. Unified management experience – Centralized monitoring, governance, and cost controls through Azure Portal and Azure Resource Manager simplify operations and oversight. Native integration across Azure services – Easily connect to data sources, analytics, and other services like Azure Synapse, Cosmos DB, and Logic Apps for end-to-end solutions. Enterprise support and SLAs – Azure delivers 24/7 support, service-level agreements, and best-in-class reliability for mission-critical workloads. By building withDeploying Grok 4 Fast models throughon Azure, enables organizations tocan build robust, secure, and scalable AI applications with confidence and agility. Key capabilities The Grok 4 Fast models introduce a suite of advanced features designed to enhance agentic workflows and multimodal integration. With flexible model choices and powerful context handling, the Grok 4 Fast models are engineered for efficiency, scalability, and seamless deployment. Choose reasoning level by selecting which Grok 4 Fast model to use: grok-4-fast-reasoning: Optimized for fast reasoning in agentic workflows. grok-4-fast-non-reasoning: Uses the same underlying weights but is constrained by a non-reasoning system prompt, offering a streamlined approach for specific tasks. Multimodal: Provides image understanding when deployed with Grok image tokenizer. Tool use & structured outputs: Enables parallel function calling and supports JSON schemas for predictable integration. Long context: Supports approximately 131K tokens for deep, comprehensive understanding. Efficient H100 performance: Designed to run efficiently on H100 GPUs for agentic search and real-time orchestration. Collectively, these features make the Grok 4 Fast models a robust and versatile solution for developers and enterprises looking to push the boundaries of AI-powered workflows. What you can do with the Grok 4 Fast models Building on the advanced capabilities of the Grok 4 Fast models, developers can unlock innovative solutions across a wide variety of applications. The following use cases highlight how these models streamline complex workflows, maximize efficiency, and accelerate intelligent automation with robust, scalable AI. Real-time agentic task orchestration : Automate and coordinate multi-step processes across systems with fast, flexible reasoning for dynamic business operations. Multimodal document analysis : Extract insights and process information from both text and images for comprehensive, context-aware understanding. Enterprise search and knowledge retrieval : Leverage long-context support for enhanced semantic search, surfacing relevant information from massive data repositories. Parallel tool integration : Invoke multiple APIs and functions simultaneously, enabling sophisticated workflows with structured, predictable outputs. Scalable conversational AI : Deploy high-capacity virtual agents capable of handling extended dialogues and nuanced queries with low latency. Customizable decision support- : Empower users with AI-driven recommendations and scenario analysis tailored to organizational needs and governance requirements. With the Grok 4 Fast models, developers are equipped to build and iterate on next-generation AI solutions, leveraging powerful tools and streamlined deployment workflows. Start shaping the future of intelligent applications by harnessing the speed, scalability, and multimodal capabilities of the Grok 4 Fast models today. The Grok 4 Fast models offer developers the speed, scalability, and multimodal capabilities needed to advance intelligent applications, supporting complex workflows and innovative solutions across a range of use cases. Pricing for Grok 4 Fast Models on Azure AI Foundry Model Deployment Price $/1m tokens grok-4-fast-reasoning Global Standard (PayGo) Input - $0.43 Output - $1.73 grok-4-fast-non-reasoning Get started in minutes With the Grok 4 Fast models, developers gain access to cutting-edge AI with a massive context window, efficient GPU performance, and enterprise-grade governance. Start building the future of AI today,visit the Model Catalog in Azure AI Foundry and deploy grok-4-fast-reasoning and grok-4-fast-non-reasoning to accelerate your innovation.Agentic AI research-methodology - part 2
This post continues our series (previous post) on agentic AI research methodology. Building on our previous discussion on AI system design, we now shift focus to an evaluation-first perspective. Tamara Gaidar, Data Scientist, Defender for Cloud Research Fady Copty, Principal Researcher, Defender for Cloud Research TL;DR: Evaluation-First Approach to Agentic AI Systems This blog post advocates for evaluation as the core value of any AI product. As generic models grow more capable, their alignment with specific business goals remains a challenge - making robust evaluation essential for trust, safety, and impact. This post presents a comprehensive framework for evaluating agentic AI systems, starting from business goals and responsible AI principles to detailed performance assessments. It emphasizes using synthetic and real-world data, diverse evaluation methods, and coverage metrics to build a repeatable, risk-aware process that highlights system-specific value. Why evaluate at all? While issues like hallucinations in AI systems are widely recognized, we propose a broader and more strategic perspective: Evaluation is not just a safeguard - it is the core value proposition of any AI product. As foundation models grow increasingly capable, their ability to self-assess against domain-specific business objectives remains limited. This gap places the burden of evaluation on system designers. Robust evaluation ensures alignment with customer needs, mitigates operational and reputational risks, and supports informed decision-making. In high-stakes domains, the absence of rigorous output validation has already led to notable failures - underscoring the importance of treating evaluation as a first-class concern in agentic AI development. Evaluating an AI system involves two foundational steps: Developing an evaluation plan that translates business objectives into measurable criteria for decision-making. Executing the plan using appropriate evaluation methods and metrics tailored to the system’s architecture and use cases. The following sections detail each step, offering practical guidance for building robust, risk-aware evaluation frameworks in agentic AI systems. Evaluation plan development The purpose of an evaluation plan is to systematically translate business objectives into measurable criteria that guide decision-making throughout the AI system’s lifecycle. Begin by clearly defining the system’s intended business value, identifying its core functionalities, and specifying evaluation targets aligned with those goals. A well-constructed plan should enable stakeholders to make informed decisions based on empirical evidence. It must encompass end-to-end system evaluation, expected and unexpected usage patterns, quality benchmarks, and considerations for security, privacy, and responsible AI. Additionally, the plan should extend to individual sub-components, incorporating evaluation of their performance and the dependencies between them to ensure coherent and reliable system behavior. Example - Evaluation of a Financial Report Summarization Agent To illustrate the evaluation-first approach, consider the example from the previous post of an AI system designed to generate a two-page executive summary from a financial annual report. The system was composed of three agents: split report into chapters, extract information from chapters and tables, and summarize the findings. The evaluation plan for this system should operate at two levels: end-to-end system evaluation and agent-level evaluation. End-to-End Evaluation At the system level, the goal is to assess the agent’s ability to accurately and efficiently transform a full financial report into a concise, readable summary. The business purpose is to accelerate financial analysis and decision-making by enabling stakeholders - such as executives, analysts, and investors - to extract key insights without reading the entire document. Key objectives include improving analyst productivity, enhancing accessibility for non-experts, and reducing time-to-decision. To fulfill this purpose, the system must support several core functionalities: Natural Language Understanding: Extracting financial metrics, trends, and qualitative insights. Summarization Engine: Producing a structured summary that includes an executive overview, key financial metrics (e.g., revenue, EBITDA), notable risks, and forward-looking statements. The evaluation targets should include: Accuracy: Fidelity of financial figures and strategic insights. Readability: Clarity and structure of the summary for the intended audience. Coverage: Inclusion of all critical report elements. Efficiency: Time saved compared to manual summarization. User Satisfaction: Perceived usefulness and quality by end users. Robustness: Performance across diverse report formats and styles. These targets inform a set of evaluation items that directly support business decision-making. For example, high accuracy and readability in risk sections are essential for reducing time-to-decision and must meet stringent thresholds to be considered acceptable. The plan should also account for edge cases, unexpected inputs, and responsible AI concerns such as fairness, privacy, and security. Agent-Level Evaluation Suppose the system is composed of three specialized agents: Chapter Analysis Tables Analysis Summarization Each agent requires its own evaluation plan. For instance, the chapter analysis agent should be tested across various chapter types, unexpected input formats, and content quality scenarios. Similarly, the tables analysis agent must be evaluated for its ability to extract structured data accurately, and the summarization agent for coherence and factual consistency. Evaluating Agent Dependencies Finally, the evaluation must address inter-agent dependencies. In this example, the summarization agent relies on outputs from the chapter and tables analysis agents. The plan should include dependency checks such as local fact verification - ensuring that the summarization agent correctly cites and integrates information from upstream agents. This ensures that the system functions cohesively and maintains integrity across its modular components. Executing the Evaluation Plan Once the evaluation plan is defined, the next step is to operate it using appropriate methods and metrics. While traditional techniques such as code reviews and manual testing remain valuable, we focus here on simulation-based evaluation - a practical and scalable approach that compares system outputs against expected results. For each item in the evaluation plan, this process involves: Defining representative input samples and corresponding expected outputs Selecting simulation methods tailored to each agent under evaluation Measuring and analyzing results using quantitative and qualitative metrics This structured approach enables consistent, repeatable evaluation across both individual agents and the full system workflow. Defining Samples and Expected Outputs A robust evaluation begins with a representative set of input samples and corresponding expected outputs. Ideally, these should reflect real-world business scenarios to ensure relevance and reliability. While a comprehensive evaluation may require hundreds or even thousands of real-life examples, early-stage testing can begin with a smaller, curated set - such as 30 synthetic input-output pairs generated via GenAI and validated by domain experts. Simulation-Based Evaluation Methods Early-stage evaluations can leverage lightweight tools such as Python scripts, LLM frameworks (e.g., LangChain), or platform-specific playgrounds (e.g., Azure OpenAI). As the system matures, more robust infrastructure is required to support production-grade testing. It is essential to design tests with reusability in mind - avoiding hardcoded samples and outputs - to ensure continuity across development stages and deployment environments. Measuring Evaluation Outcomes Evaluation results should be assessed in two primary dimensions: Output Quality: Comparing actual system outputs against expected results. Coverage: Ensuring all items in the evaluation plan are adequately tested. Comparing Outputs Agentic AI systems often generate unstructured text, making direct comparisons challenging. To address this, we recommend a combination of: LLM-as-a-Judge: Using large language models to evaluate outputs based on predefined criteria. Domain Expert Review: Leveraging human expertise for nuanced assessments. Similarity Metrics: Applying lexical and semantic similarity techniques to quantify alignment with reference outputs. Using LLMs as Evaluation Judges Large Language Models (LLMs) are emerging as a powerful tool for evaluating AI system outputs, offering a scalable alternative to manual review. Their ability to emulate domain-expert reasoning enables fast, cost-effective assessments across a wide range of criteria - including correctness, coherence, groundedness, relevance, fluency, hallucination detection, sensitivity, and even code readability. When properly prompted and anchored to reliable ground truth, LLMs can deliver high-quality classification and scoring performance. For example, consider the following prompt used to evaluate the alignment between a security recommendation and its remediation steps: “Below you will find a description of a security recommendation and relevant remediation steps. Evaluate whether the remediation steps adequately address the recommendation. Use a score from 1 to 5: 1: Does not solve at all 2: Poor solution 3: Fair solution 4: Good solution 5: Exact solution Security recommendation: {recommendation} Remediation steps: {steps}” While LLM-based evaluation offers significant advantages, it is not without limitations. Performance is highly sensitive to prompt design and the specificity of evaluation criteria. Subjective metrics - such as “usefulness” or “helpfulness” - can lead to inconsistent judgments depending on domain context or user expertise. Additionally, LLMs may exhibit biases, such as favoring their own generated responses, preferring longer answers, or being influenced by the order of presented options. Although LLMs can be used independently to assess outputs, we strongly recommend using them in comparison mode - evaluating actual outputs against expected ones - to improve reliability and reduce ambiguity. Regardless of method, all LLM-based evaluations should be validated against real-world data and expert feedback to ensure robustness and trustworthiness. Domain expert evaluation Engaging domain experts to assess AI output remains one of the most reliable methods for evaluating quality, especially in high-stakes or specialized contexts. Experts can provide nuanced judgments on correctness, relevance, and usefulness that automated methods may miss. However, this approach is inherently limited in scalability, repeatability, and cost-efficiency. It is also susceptible to human biases - such as cultural context, subjective interpretation, and inconsistency across reviewers—which must be accounted for when interpreting results. Similarity techniques Similarity techniques offer a scalable alternative by comparing AI-generated outputs against reference data using quantitative metrics. These methods assess how closely the system’s output aligns with expected results, using measures such as exact match, lexical overlap, and semantic similarity. While less nuanced than expert review, similarity metrics are useful for benchmarking performance across large datasets and can be automated for continuous evaluation. They are particularly effective when ground truth data is well-defined and structured. Coverage evaluation in Agentic AI Systems A foundational metric in any evaluation framework is coverage - ensuring that all items defined in the evaluation plan are adequately tested. However, simple checklist-style coverage is insufficient, as each item may require nuanced assessment across different dimensions of functionality, safety, and robustness. To formalize this, we introduce two metrics inspired by software engineering practices: Prompt-Coverage: Assesses how well a single prompt invocation addresses both its functional objectives (e.g., “summarize financial risk”) and non-functional constraints (e.g., “avoid speculative language” or “ensure privacy compliance”). This metric should reflect the complexity embedded in the prompt and its alignment with business-critical expectations. Agentic-Workflow Coverage: Measures the completeness of evaluation across the logical and operational dependencies within an agentic workflow. This includes interactions between agents, tools, and tasks - analogous to branch coverage in software testing. It ensures that all integration points and edge cases are exercised. We recommend aiming for the highest possible coverage across evaluation dimensions. Coverage gaps should be prioritized based on their potential risk and business impact, and revisited regularly as prompts and workflows evolve to ensure continued alignment and robustness. Closing Thoughts As agentic AI systems become increasingly central to business-critical workflows, evaluation must evolve from a post-hoc activity to a foundational design principle. By adopting an evaluation-first mindset - grounded in structured planning, simulation-based testing, and comprehensive coverage - you not only mitigate risk but also unlock the full strategic value of your AI solution. Whether you're building internal tools or customer-facing products, a robust evaluation framework ensures your system is trustworthy, aligned with business goals, and differentiated from generic models.
