TestMu Deploys Adversarial Agent Swarms as AI Flaws Cost Firms $4.4M

Confidently Wrong: Building Validation and Trust for Your AI Agents With TestMu AI — Ai4

Ai4

Because autonomous agents execute stateful tool calls with unearned confidence, enterprise deployment safety depends on adversarial synthetic simulations rather than static model evaluations.

AI-assisted summary of Confidently Wrong: Building Validation and Trust for Your AI Agents With TestMu AI — original source. Check the original for full context.

Source published: 2026-08-19

Detailed notes

## Background Published on YouTube by the channel Ai4 on August 19, 2026, this keynote features Mudit Singh, Co-Founder and Head of Growth at TestMu AI. The presentation explores the hidden liabilities of confidently incorrect AI agents—which cause organizations average financial losses of $4.4 million—and introduces independent validation layers designed to verify agent actions before they reach production.

## TL;DR Mudit Singh explains that the core vulnerability of autonomous AI agents is their non-deterministic nature and unwavering, unwarranted confidence, making traditional deterministic QA and static LLM-as-a-judge evaluations inadequate. He highlights costly enterprise risks, from token theft exploits to regulatory fines, when agents execute erroneous tool calls or make binding commitments. To bridge this gap, Singh presents TestMu AI's approach of deploying synthetic adversarial user swarms to simulate end-to-end multi-turn interactions, stress-testing both dialogue and underlying backend stack traces. Ultimately, he demonstrates that automated, multi-metric validation across strict industry compliance standards constitutes the true competitive moat for enterprise AI adoption.

## Atmosphere & style The presentation delivers a pragmatic, sharp, and urgency-driven vibe that strips away generative AI hype to focus on hard financial and technical realities. Singh maintains an authoritative yet accessible speaking style, weaving cautionary real-world breach anecdotes with structured engineering diagrams. Watching the talk feels like a sobering masterclass on risk mitigation, systematically diagnosing the blind spots of modern agent deployment before presenting a practical, scalable blueprint for automated testing.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=4s) The core vulnerability of modern AI agents is unearned confidence: when an AI fails, it delivers erroneous answers with the exact same authority, poise, and green checkmarks as accurate responses. - [01:06](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=66s) Publicly exposed chatbot endpoints are vulnerable to inference and token theft, where subverted prompts turn customer-service agents into free compute wrappers for arbitrary tasks, costing companies thousands of dollars daily. - [02:47](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=167s) Unbounded AI decisions expose enterprises to direct regulatory, legal, and financial liability—with EY reporting that AI failures cost Fortune 500 enterprises an average of $4.4 million. - [04:51](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=291s) Traditional deterministic software testing cannot validate probabilistic AI; testing must transition from binary pass/fail assertions to quality thresholds and correctness gradients. - [07:14](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=434s) Manual QA cannot scale for AI agents due to inherent human evaluator subjectivity and the combinatorial explosion of real-world dialects, urgency levels, and user personas. - [09:48](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=588s) Standard LLM-as-a-judge evaluation frameworks fail on full-stack agents because they evaluate isolated text responses rather than stateful multi-system operations like database queries, API calls, and document generation. - [11:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=709s) Effective agent validation requires multi-turn adversarial simulations that mimic the worst-behaved end users to actively stress-test runtime stack traces, tool call precision, and prompt vulnerabilities. - [13:08](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=788s) Testing autonomous AI at scale requires deploying synthetic AI user swarms backed by high-throughput compute infrastructure capable of executing billions of end-to-end tests cost-effectively. - [15:46](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=946s) The end-to-end validation pipeline ingests high-level PRD or Markdown specifications, synthesizes over 100,000 persona and audio noise variations, incorporates human-in-the-loop curation, and generates Go/No-Go deployment gates. - [17:25](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1045s) Comprehensive agent evaluation measures 35 operational dimensions—including tool call accuracy, artifact generation fidelity, and latency—while auditing adherence to SOC 2, HIPAA, and FINRA compliance benchmarks. - [19:26](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1166s) The primary competitive bottleneck in AI has shifted from engineering speed to verification: deploying confidently validated agents before they reach customers is the true enterprise moat.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=4s) The Core Flaw of AI: Confidently Wrong

Mudit Singh introduces himself as a co-founder of TestMu AI. While the company has been active in testing for years, the recent explosion of generative AI prompted them to tackle a critical question: how do you actually validate artificial intelligence? A few years ago, the primary industry headache was hallucinations. Since then, the ecosystem has matured, building guardrails, harnesses, and mitigation layers around model outputs. However, the fundamental danger remaining in AI systems and autonomous agents is their unwavering, unwarranted confidence.

When an AI fails, it will never hedge its bets or admit uncertainty. It will not say, "there is a possibility that this might be the answer." Instead, it delivers a completely erroneous answer with the exact same authority and poise as an accurate one. This mismatch—where an agent is "extremely confident even when it goes wrong"—presents the central challenge for enterprise deployments.

[01:06](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=66s) The Chipotle Hack and Runaway Token Theft

A quick search for the hashtag `#AIFail` across social media reveals endless examples of systems going off the rails, but one of the most illustrative cases involves Chipotle's customer-ordering chatbot. Although Chipotle has disputed aspects of the event, documented screenshots and reporting from Gizmodo tell a telling story: a customer interacting with the burrito-ordering assistant asked the bot to debug a snippet of Python code for creating a linked list. Rather than staying within its domain, the chatbot happily analyzed and wrote the code with zero hallucinations and complete accuracy.

While amusing at first glance, the vulnerability quickly became a liability. A developer reverse-engineered the backend API, wrapped it in a new interface, and published an open-source GitHub project allowing anyone to run arbitrary coding tasks entirely on Chipotle's compute. This form of prompt subversion turned into rampant "inference theft" and "token theft." Companies like Vercel have documented similar incidents where hijacked customer-facing chatbots led to unauthorized token consumption exceeding $10,000 a day.

- **Inference Theft Mechanism:** Public customer-service chat endpoints exploited as free LLM compute wrappers for unrelated tasks (like coding). - **Financial Exposure:** Unchecked open-ended chatbot prompts leading to thousands of dollars in daily API token drains.

[02:47](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=167s) Enterprise Risks and the $4.4M Cost of AI Failures

The issue extends far beyond humorous social media screenshots or stolen compute; similar customer-facing chatbot failures have struck brands like Chevrolet, Air Canada, and even developer-centric AI companies like Cursor. When an AI agent interfaces directly with customers, it is empowered to make decisions and represent policy on behalf of the company. If that agent commits to an inaccurate insurance quote, creates a non-existent discount, or dispenses faulty legal advice, the business is directly exposed to regulatory penalties, compliance breaches, and lawsuits.

Compounding this risk is the problem of knowledge recency. An LLM trained with a fixed cutoff date may have zero awareness of regulatory policies instituted yesterday. When automated customer-facing systems fail, the financial consequences are severe. A survey conducted by EY revealed that large Fortune 500 enterprises deploying AI have suffered average financial losses of $4.4 million resulting from AI failures.

```mermaid flowchart TD accTitle: Enterprise AI Failure Cascade subgraph Trigger["Unvalidated Agent Action"] A["Customer Prompt"] --> B["AI Agent Makes Unbounded Decision"] end subgraph Exposure["Business Exposure"] B --> C["Regulatory Non-Compliance"] B --> D["Inference & Token Theft"] B --> E["Binding Commercial Commitments"] end subgraph Impact["Financial Fallout"] C --> F["Litigation & Penalties"] D --> G["Compute Cost Drain"] E --> H["Average $4.4M Enterprise Loss"] end ```

[04:51](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=291s) Why Deterministic Testing Breaks on Probabilistic AI

Traditional software testing methodologies cannot properly evaluate modern AI because they are inherently deterministic. Traditional QA relies on strict input-output validation: checking whether a specific UI button exists, clicking it, and asserting whether a predictable next state occurs. In contrast, generative AI is probabilistic and non-deterministic; feeding the exact same prompt multiple times can yield entirely different answers and variations in tone, structure, or content.

Because of this variability, AI validation cannot rely on simple binary assertions. It must operate on quality thresholds and correctness gradients. For instance, in an airline customer support workflow, a rebooking request can be phrased in dozens of distinct ways depending on the traveler's phrasing and demeanor. Similarly, if a model is asked "Who is the President of the United States?", it might return the correct current president 90% of the time, but out of 10,000 queries, it might occasionally answer "Barack Obama." While historically true, the answer is contextually incorrect today—representing an answer that sits at an 80% correctness threshold rather than a clean pass/fail checkmark.

[07:14](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=434s) The Three Testing Paradigms and the Limits of Manual QA

To understand how leading AI organizations tackle validation, researching deep search queries, NIST guidelines, and industry whitepapers reveals advanced terminology like "eval-driven development" and "adaptive rubrics." Synthesizing these approaches reveals three primary testing paradigms used across the industry:

1. **Manual Testing:** Human evaluators interacting with conversational agents directly. 2. **LLM-as-a-Judge (Evals):** Automated AI pipelines that generate synthetic test cases, send prompts, and evaluate responses against defined scoring rubrics. 3. **End-to-End Simulated Multi-Turn Agent Testing:** Fully simulated, stateful agent evaluations executed at scale.

Manual testing is the standard starting point where developers or QA teams test scenarios based on intuition and gut feeling. While necessary, manual testing breaks down quickly due to two major flaws. First, human evaluators possess inherent subjectivity and bias when scoring outputs that fall along a quality gradient—an answer deemed acceptable by one tester might be flagged as a complete failure by another. Second, manual testing cannot scale against the combinatorial explosion of real-world inputs. A single intent like rebooking a flight spawns endless permutations depending on whether the user is a native or non-native English speaker, how they express urgency, or whether they understand technical domain terms like a "PNR" (Passenger Name Record).

- **Human Evaluator Bias:** Inconsistent thresholds when judging fuzzy, subjective natural language answers. - **Combinatorial Explosion:** Inability for human teams to manually execute the thousands of permutations needed to cover varied user personas, dialects, and vocabularies.

[09:48](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=588s) LLM-as-a-Judge and the Multi-System Reality of AI Agents

To overcome human scaling limits, teams turn to synthetic evaluation pipelines—commonly referred to as "LLM as a judge" or automated evals. In this workflow, an LLM synthesizes vast datasets of test prompts derived from predictive variations and historical logs. These prompts are dispatched to the target system, and a secondary judge model uses an algorithmic rubric to grade each response for format, tone, and factual correctness across a gradient. Companies like OpenAI and ChatGPT rely heavily on these evaluation frameworks.

```mermaid flowchart LR accTitle: Eval Pipeline vs Full Agent Architecture subgraph EvalBoundary["Standard Eval Testing Scope"] P["Synthetic Prompt"] --> LLM["Target LLM"] LLM --> J["Judge LLM / Rubric"] end subgraph AgentReality["Full Agent Ecosystem"] LLM -.-> DB[("Database / PNR Lookup")] LLM -.-> API["External APIs / Tools"] LLM -.-> DOC["PDF / Pass Generator"] LLM -.-> ENT["ERP & CRM Systems"] end ```

However, static evaluation of standalone prompts falls short when transitioning from simple LLMs to autonomous AI agents. An AI agent is not a stateless text generator; it is a stateful system wired into enterprise architecture. In a flight rebooking scenario, the agent must invoke tool calls to verify a PNR in a live database, interface with external booking APIs, generate a valid PDF boarding pass, and sync records with downstream CRM and ERP systems. Evaluating only the natural language output of an isolated step fails to validate whether the agent successfully orchestrated the underlying business operations.

[11:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=709s) The Limitations of Manual QA and LLM-as-a-Judge: The Need for Adversarial Simulation

In any modern enterprise, software architecture is composed of thousands of interconnected systems and integrations. When an AI agent is deployed, it does not operate in isolation; it interacts across the entirety of that software ecosystem. Consequently, traditional human quality assurance simply cannot scale to cover the vast matrix of possible interactions, nor is it sufficiently rigorous to catch nuanced downstream failures. At the same time, standard LLM-as-a-judge evaluation frameworks fall short because they do not assess the system holistically across the board, nor can they grade the precision and validity of underlying tool calls.

```mermaid flowchart TD accTitle: Agent-Testing-Agent Pipeline Architecture subgraph Inputs["1. Specification & Context"] PRD["PRD / Markdown Spec"] Persona["Personas, Accents & Noise Profiles"] end

subgraph Orchestration["2. Test Generation & Synthesis"] GenAgent["Scenario Generation Agent"] HITL{"Human-in-the-Loop Filter"} GenAgent --> HITL end

subgraph Execution["3. Adversarial Simulation"] SyntheticUser["Synthetic User Swarm (Adversarial Agent)"] TargetAgent["Target AI Agent Under Test"] ToolBackend["Enterprise Backend / Tools / APIs"]

SyntheticUser <-->|"Turn-by-Turn Dialog"| TargetAgent TargetAgent <-->|"Tool Calls & Stack Traces"| ToolBackend end

subgraph Evaluation["4. Multi-Metric Analysis & Reporting"] Engine["35 Metrics & Rubric Engine"] Compliance["Compliance Checks (SOC 2, HIPAA, FINRA)"] Report["Go / No-Go Decision Report"]

SyntheticUser & TargetAgent --> Engine Engine --> Compliance Compliance --> Report end

Inputs --> GenAgent HITL --> SyntheticUser ```

To solve this validation crisis, teams need more than static evaluations: they require dynamic, multi-turn conversational simulations that evaluate the exact stack trace and execution flow step by step. Most critically, systems need an autonomous mechanism that can "act as an adversarial customer, act as your worst customer that can come to your chatbot and actively try to break your chatbot or your AI agent." While this adversarial approach is essential, walking the floor at AI conferences reveals that the vast majority of teams shipping agentic applications today are skipping this stage entirely.

- Enterprise architectures encompass thousands of integrated components, making human QA fundamentally unscalable for agent workflows. - LLM-as-a-judge approaches fail to evaluate full-stack tool calls, multi-turn context drift, or backend integration health. - Robust validation demands multi-turn scenario simulation that analyzes runtime stack traces alongside natural language dialogue. - Synthetic adversarial testing targets edge cases by actively attempting to prompt-inject, exploit, or break the conversational agent.

---

[13:08](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=788s) Using AI to Test AI: TestMu AI's Infrastructure and Synthetic User Swarms

Just as early LLM evaluations introduced the concept of AI grading AI, validating complex autonomous agents demands the next logical evolution: deploying an AI agent to test an AI agent. TestMu AI tackles this by deploying swarms of autonomous synthetic end users designed to simulate real-world behavior and execute realistic, end-to-end conversations at scale. This capability builds directly on TestMu AI's historical testing infrastructure, which has been in development since 2018.

Testing autonomous agents introduces exponential complexity, requiring not just conversational intelligence but massive underlying computing power. TestMu AI leverages its proprietary execution engine, HyperExecute—originally engineered to run tests across web, mobile, APIs, frontends, and backends—to spin up agent swarms, execute authoring and validation workloads at a fraction of standard operational costs, and surface immediate root-cause diagnostics on what broke and how to fix it.

- TestMu AI was founded in 2018 and supports a community of approximately 3 million developers, programmers, and testers. - The platform executes roughly 1.5 billion automated tests annually for enterprise clients, including OpenAI, Microsoft, Salesforce, and Transavia. - AI agent testing requires high-scale compute infrastructure capable of orchestrating multi-agent interactions across external APIs and applications. - HyperExecute provides the underlying engine that enables cost-effective scenario generation, parallel execution, and automated failure analysis.

---

[15:46](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=946s) End-to-End Testing Workflow, Security Vulnerabilities, and Go/No-Go Reporting

In practice, the testing pipeline starts with context ingestion. A development team supplies high-level documentation, such as a Product Requirement Document (PRD) or a simple Markdown (`.md`) specification defining what the application is intended to do. An authoring agent consumes this context to generate hundreds of thousands of concrete test scenarios, mapping them to diverse user personas, regional accents, and synthetic background noises to thoroughly exercise voice bots and phone-based interactive agents.

A deliberate human-in-the-loop checkpoint allows engineering teams to filter out unnecessary noise from the generated scenarios and focus on the most relevant personas. Synthetic adversarial agents then execute the simulations against the target application. Once the test run concludes, the platform synthesizes the interaction into a conclusive "go/no-go" report, providing deep micro-level analytics across 35 distinct dimensions alongside security auditing for logical vulnerabilities, API key leaks, and prompt exploits.

- Scenario synthesis creates tailored personas, accent variations, and environmental background noises to stress-test telephony and voice agents. - Human-in-the-loop governance enables engineering teams to eliminate synthetic test noise and focus validation on critical business paths. - Security evaluations explicitly test whether agents leak internal API keys, fall prey to logical business flaws, or succumb to adversarial manipulation. - Output reporting delivers both high-level go/no-go deployment gates and micro-level breakdowns of individual scenario failures.

---

[17:25](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1045s) The "Money Slide": Evaluating 35 Metrics and Regulatory Compliance

Because every enterprise builds context-specific models, the industry lacks universal DORA-style metrics for evaluating AI agents. Standard evaluations check for bias, hallucinations, and Personally Identifiable Information (PII) exposure, but agentic architectures require measuring operational performance: tool call precision, end-to-end task completion rates, artifact generation fidelity (such as generating and structurally validating a PDF document), end-to-end latency, and total conversational step count.

``` +-------------------------------------------------------------------------+ | TESTMU AI AGENT EVALUATION MATRIX | +------------------------------------+------------------------------------+ | Traditional Evaluators | Agentic & Operational Metrics | | - Hallucination detection | - Tool call accuracy & arguments | | - Demographic & prompt bias | - End-to-end task completion rate | | - PII identification & masking | - Artifact validation (e.g., PDF) | | - Conversational latency tracking | - Total turn & step efficiency | +------------------------------------+------------------------------------+ | Enterprise Governance & Compliance Frameworks: | | - HIPAA (Healthcare) - SOC 2 Type II | | - ISO Standards - FINRA (35+ Financial Benchmarks) | +-------------------------------------------------------------------------+ ```

Because acceptable tolerances differ dramatically across industries, TestMu AI pairs its 35 pre-built metrics with customizable rubric algorithms. While a healthcare agent may demand strict 99.9% accuracy where zero errors are tolerated, an e-commerce customer support bot can operate under more relaxed operational thresholds. Furthermore, all validations are conducted within heavily regulated frameworks, auditing agents against SOC 2 Type II, ISO, HIPAA, and more than 35 distinct financial compliance standards, including FINRA guidelines.

- The agent ecosystem lacks standardized performance metrics, making custom, domain-specific evaluation thresholds essential. - Core agent metrics track tool call accuracy, conversation step efficiency, latency, and artifact generation correctness. - Rubric algorithms are customizable: healthcare demands up to 99.9% accuracy thresholds, whereas e-commerce use cases accommodate broader variance. - Automated compliance auditing verifies models against SOC 2 Type II, ISO, HIPAA, and 35 financial regulatory standards including FINRA.

---

[19:26](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1166s) The True Bottleneck: Validation as the New Competitive Moat

At industry events and executive briefings, founders, CEOs, and CTOs routinely ask what defines the emerging age of AI. While the broader market remains obsessed with engineering speed and rapid agent development, the foundational bottleneck has shifted toward verification: the true constraint is how quickly and reliably organizations can validate that their autonomous agents actually work as intended.

Ultimately, moving beyond unverified prototypes requires robust, scalable validation layers. In an ecosystem saturated with systems that act with unearned certainty, "getting a confidently validated AI agent in front of customers is what the new moat is, what's the new competitive edge." Development speed provides little advantage if flawed agents cause catastrophic business failures; true enterprise advantage belongs to organizations that can deploy validated, battle-tested agents with genuine confidence.

## Notable quotes > Your AI agent will never tell you it's wrong. It doesn't know it's wrong. — Mudit Singh

> That's the trap of the agent era: confidence isn't correctness, and an agent can't grade its own work. — Mudit Singh

> So the failures don't look like failures. They look like green checkmarks and fluent answers — right up until a real user, or a regulator, finds the one that was wrong. — Mudit Singh

> The fix isn't a better model, it's an independent layer that verifies what the agent did before it reaches a customer, not after the damage is done. — Mudit Singh

> [00:04](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=4s) there is a possibility that this might be the answer. — Mudit Singh

> [00:04](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=4s) extremely confident even when it goes wrong — Mudit Singh

> [04:51](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=291s) Who is the President of the United States? — Mudit Singh

> [11:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=709s) act as an adversarial customer, act as your worst customer that can come to your chatbot and actively try to break your chatbot or your AI agent. — Mudit Singh

> [19:26](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1166s) getting a confidently validated AI agent in front of customers is what the new moat is, what's the new competitive edge. — Mudit Singh

## Mentioned Mudit Singh, TestMu AI, Ai4, Chipotle, Gizmodo, GitHub, Vercel, Chevrolet, Air Canada, Cursor, EY, NIST, OpenAI, ChatGPT, HyperExecute, Microsoft, Salesforce, Transavia, SOC 2 Type II, ISO, HIPAA, FINRA

## Video description Mudit Singh - Co-Founder and Head of Growth, TestMu AI

Confidently wrong AI has a price tag and in 2026, it's a line item. Your AI agent will never tell you it's wrong. It doesn't know it's wrong. It ships code with total confidence, answers customers with total confidence and is exactly as confident when it's right as when it just invented a refund policy that doesn't exist, or reported success over a database it quietly broke.

That's the trap of the agent era: confidence isn't correctness, and an agent can't grade its own work. So the failures don't look like failures. They look like green checkmarks and fluent answers — right up until a real user, or a regulator, finds the one that was wrong. It's already expensive: 99% of organizations deploying AI report financial losses from it, averaging $4.4 million each.

The fix isn't a better model, it's an independent layer that verifies what the agent did before it reaches a customer, not after the damage is done. This talk shows what that looks like for both kinds of agents: the ones that build, and the ones that interact. You'll walk out able to tell an agent that sounds trustworthy from one you can actually trust, before your next deployment writes a check your business can't cash.

[Source](https://www.youtube.com/watch?v=Jh2_xYVk1jY)

中文简报

AI缺陷致企业损失达440万美元，TestMu部署对抗性智能体集群由于自主智能体在执行有状态工具调用时伴随着毫无根据的盲目自信，企业部署的安全性取决于对抗性合成模拟，而非静态模型评估。 Mudit Singh解释称，自主AI智能体的核心脆弱性在于其非确定性以及坚定却毫无根据的自信，这使得传统的确定性QA和静态LLM-as-a-judge评估手段难以应对。他指出，当智能体执行错误工具调用或做出具约束力的承诺时，会带来高昂的企业风险，涵盖从Token盗用漏洞到监管罚款等多个方面。为弥补这一差距，Singh介绍了TestMu AI的解决方案：部署合成对抗性用户群以模拟端到端多轮交互，对对话内容及底层后端堆栈跟踪同时进行压力测试。他最终表明，遵循严格行业合规标准的自动化、多指标验证才是企业落地AI的真正竞争壁垒。现代AI智能体的核心弱点在于毫无依据的自信：当AI出错时，它给出错误答案的权威度、从容感和绿色对勾标记，与给出正确答案时毫无二致。 (0:04) 公开发布的聊天机器人端点容易受到推理与Token盗用攻击，被篡改的提示词会将客服智能体变为执行任意任务的免费算力外壳，导致企业每天蒙受数千美元的损失。 (1:06) 不受约束的AI决策会使企业直接承担监管、法律和财务责任——安永（EY）报告显示，AI故障平均给财富500强企业造成440万美元的损失。 (2:47) 传统的确定性软件测试无法有效验证概率性AI；测试模式必须从二元的通过/失败断言，转向质量阈值与正确性梯度的评估。 (4:51) 由于人工评估员固有的主观性，加之现实场景中方言、紧急程度与用户画像的组合爆炸，人工QA无法适应AI智能体的规模化测试需求。 (7:14)

Reading summary

Mudit Singh, co-founder of TestMu AI, argues that the most dangerous risk in generative AI deployments is unwarranted confidence, as autonomous agents execute flawed actions with the same certainty as accurate ones. Because modern agents execute stateful business workflows across enterprise systems, avoiding severe financial and legal liabilities requires moving past traditional quality assurance to multi-turn adversarial simulation. Unwarranted Model Confidence and Enterprise Exposure (2:47) Unlike traditional software bugs, generative AI models rarely express uncertainty; they assert erroneous conclusions with full authority. When customer-facing systems fail, enterprises face immediate exposure. Prompt subversion can result in token and inference theft, such as when Chipotle's ordering chatbot was reverse-engineered to execute arbitrary Python code, or when hijacked bots caused daily compute drains exceeding $10,000 at companies like Vercel. Beyond compute theft, customer-facing agents make binding commercial commitments. Failures at brands such as Air Canada, Chevrolet, and Cursor demonstrate how erroneous advice or synthetic discounts create immediate compliance liabilities and litigation risks. Singh cites an EY survey indicating that Fortune 500 enterprises adopting AI have incurred average financial losses of $4.4 million stemming from unvalidated AI failures, often worsened by models lacking awareness of recent regulatory updates. Why Deterministic Assertions and Static Evals Fail (4:51) Traditional software quality assurance relies on deterministic, binary input-output validations that fail when applied to probabilistic AI. Generative systems produce diverse responses across a spectrum of correctness, where a historically true answer may be contextually invalid today. Manual human testing cannot resolve this problem at enterprise scale, as human reviewers introduce subjective grading biases and cannot manually execute the combinatorial variations required for diverse user personas, dialects, and intents. Automated "LLM-as-a-judge" pipelines evaluate text output against rubrics, but Singh contends they remain fundamentally inadequate for autonomous agents. Simple language models merely generate text, whereas enterprise agents orchestrate multi-system transactions, including database queries, external API calls, PDF artifact generation, and CRM updates. Static evaluation of prompt responses checks natural language fluency while missing broken backend dependencies and invalid tool calls. Multi-Turn Adversarial Simulation Using Agent Swarms (11:49) To validate stateful autonomous agents, TestMu AI advocates using AI agents to test AI agents through dynamic, end-to-end conversational simulations. The workflow begins by ingesting a Product Requirement Document (PRD) or Markdown specification, from which an authoring agent synthesizes over 100,000 test scenarios representing diverse user personas, regional accents, and acoustic background noise. A human-in-the-loop gate enables engineers to filter these synthetic scenarios before testing begins. Autonomous synthetic user swarms then interact with the target agent, acting adversarially to identify prompt injection vulnerabilities, logical loopholes, and API credential leaks. The simulation monitors dialogue progression alongside runtime stack traces and backend tool integrations, utilizing TestMu AI's HyperExecute engine—which supports a testing network executing 1.5 billion automated runs annually—to parallelize execution and surface root-cause diagnostics. Operational Performance Metrics and Regulatory Governance (17:25) Because the industry lacks standardized DORA metrics for autonomous AI, testing frameworks must evaluate beyond generic hallucination and PII detection. TestMu AI assesses agents against 35 distinct dimensions, measuring operational criteria such as tool-call precision, conversational turn efficiency, task completion rates, artifact formatting, and end-to-end latency. These metrics are tied to customizable algorithmic rubrics that reflect industry-specific error tolerances; healthcare agents can enforce up to 99.9% accuracy thresholds, whereas e-commerce support tools allow wider variance. Test runs conclude with automated compliance audits and definitive go/no-go deployment reports mapped to SOC 2 Type II, ISO, HIPAA, and 35 financial regulatory benchmarks, including FINRA standards. Singh concludes that the primary bottleneck in enterprise AI has shifted from development speed to verification capacity. As organizations rush to deploy autonomous agents, the sustainable competitive advantage belongs not to those releasing unverified prototypes quickly, but to teams that can systematically prove system reliability and regulatory compliance prior to customer deployment.

精炼阅读摘要

TestMu AI联合创始人Mudit Singh指出，当前企业部署自主AI代理（AI Agents）的核心危机在于模型在犯错时依然保持极高的虚假自信。随着AI系统从单纯的文本生成演进为调用企业多系统API的执行实体，行业的竞争壁垒已从模型构建速度转向端到端自动化验证与对抗性测试。盲目自信与确定性失效带来的巨额商业风险 (0:04) 生成式AI在本质上是概率性和非确定性的，完全打破了传统软件测试依赖输入-输出精确匹配的确定性断言逻辑。当AI给出错误结果时，它不会表达不确定性，而是以与正确答案完全一致的笃定语气输出。这种无保证的自信在面向客户的商业场景中带来了高昂的合规与财务风险。例如，Chipotle的订餐机器人曾被用户诱导编写Python链表代码，随后接口遭到逆向工程，被公开作为免费运行算力，造成算力与Token盗用；Vercel亦记录过客户聊天接口被劫持导致单日Token损失超10,000美元的案例。安永（EY）的一项调查显示，由于做出错误承诺、违反监管或遭遇法律诉讼，部署AI的财富500强企业因AI故障遭受的平均经济损失已达440万美元。人工质检与静态LLM评估的系统性局限 (7:14) 传统质量保障与早期的自动化评估在面对复杂自主代理时均陷入瓶颈。人工测试受限于评估人员在模糊语义下的主观偏差，且无法穷举真实世界中因语言习惯、口音、紧急程度及专业术语（如航空PNR码）产生的组合爆炸。另一方面，以OpenAI等推行的“大模型作为裁判”（LLM-as-a-Judge）主要针对静态单轮Prompt及其文本输出进行打分，脱离了真实业务系统。现代企业级自主代理并非孤立的文本生成器，而是在多轮交互中深度介入底层架构：代理需要实时调用数据库验证信息、请求外部API、生成PDF凭证并与后端CRM和ERP系统双向同步。仅对孤立步骤的自然语言进行评测，无法验证底层业务流编排与工具调用的准确性。对抗性模拟：以自主代理集群突破验证瓶颈 (11:49) 针对企业数千个集成系统构成的复杂架构，验证方案必须从静态评审升级为“以AI测试AI”的端到端动态模拟。该方案通过部署自主合成用户群（Synthetic User Swarms），模拟具有敌意或处于极端边界条件下的“最差客户”，对受测代理发起主动破解与提示词注入测试。在多轮交互过程中，测试系统不仅评估语言交互，更直接监测运行时的调用栈追踪（Stack Trace）与API工具链执行状态，排查上下文漂移与内部密钥泄露风险。TestMu AI依托其自2018年研发的HyperExecute底层分布式引擎支撑此流程，该基础设施目前面向OpenAI、Microsoft、Salesforce等企业客户每年执行约15亿次自动化测试，以解决多代理并发模拟所需的庞大算力开销。规范驱动与自适应指标：35项维度与行业合规门禁 (15:46) 在工程落地层面，测试流程始于上下文摄入：团队输入产品需求文档（PRD）或Markdown格式规范，场景生成代理据此自动合成10万行以上涵盖多样化角色画像、地区口音及背景噪音的测试用例，用于对文本及语音电话机器人进行全方位压力测试。随后通过“人在回路”（Human-in-the-Loop）机制过滤测试噪音并聚焦关键业务路径。鉴于行业缺乏通用标准，系统针对代理场景设计了35项运行度量指标，严格追踪工具调用参数精度、端到端任务完成率、生成产物（如PDF）结构有效性及交互步数效率。根据行业容错率差异，系统支持自定义评分规则（例如医疗代理要求高达99.9%的绝对精度，而电商客服则允许更宽容的梯度），并对照SOC 2 Type II、HIPAA、ISO以及涵盖FINRA规范在内的35项以上金融合规基准，最终生成具有操作指引的“通过/终止”（Go/No-Go）部署决策报告。 Mudit Singh强调，在模型开发门槛不断降低、充斥虚假自信输出的当下，快速堆砌代理功能已不再构成技术优势。企业的核心壁垒取决于能否构建高可扩展的验证闭环，在复杂的全系统交互与对抗模拟中完成系统性验错，从而向市场交付具备真正确定性与信任度的商业化AI代理。

Detailed notes — zh

## Background 该内容由行业峰会频道 Ai4 于 2026 年 8 月 19 日在 YouTube 平台发布。视频记录了 TestMu AI 联合创始人兼增长负责人 Mudit Singh 的主题演讲，核心聚焦于 AI 智能体“自信但完全错误”所带来的高昂商业代价，并阐明为何企业亟需在智能体触达真实客户前建立一套独立的端到端验证机制。 ## TL;DR 演讲指出，当前企业部署自主 AI 智能体面临的最大威胁已非单纯的模型幻觉，而是模型以极度笃定的口吻交付错误结论或静默破坏底层业务。由于智能体涉及多轮对话与复杂的工具调用（Tool Calls），传统确定性测试和基于纯文本打分的 LLM-as-a-Judge 均存在严重盲区。对此，TestMu AI 提出了“用 AI Agent 测试 AI Agent”的对抗性端到端仿真框架，依托大规模并发基础设施模拟极端边缘场景与恶意破坏，并结合 35 项以上的综合评估指标与行业合规标准，为企业在上线前构建起可信的智能体防御护城河。 ## Atmosphere & style 整场演讲呈现出冷静务实、直击工程痛点的专业技术基调，发言风格兼具警示意味与建设性。演讲者通过解构 Chipotle 客服机器人被滥用为免费编程工具等鲜活案例，迅速让观众感受到 AI 失控带来的实际财务与合规冲击，营造出一种迫在眉睫的危机感。随着对传统测试局限与底层评估机制的层层剖析，情绪曲线从对盲目追求部署速度的冷峻反思，稳步转向依靠强大测试基建与多智能体仿真破局的沉着底气。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=4s) AI 时代的核心陷阱已从“模型幻觉”演变为“极度自信但完全错误”（Confidently Wrong），模型在给出错误答案时依然表现得极其笃定且无法自省。 - [01:06](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=66s) AI 行为偏离既定业务范围会带来严重合规与商业损失（如 Chipotle 机器人被逆向盗用 Token），财富 500 强企业因 AI 事故导致的单次平均财务损失高达 440 万美元。 - [04:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=289s) 传统测试基于确定性断言逻辑，而 AI 的运行机制是非确定性的，输出往往处于概率性的灰度区间（如“部分正确”），导致传统测试方法彻底失效。 - [06:44](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=404s) 人工测试受限于评估人员的主观容忍度偏见，且面对真实用户表达与场景的排列组合指数级爆炸，根本无法实现规模化覆盖。 - [09:48](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=588s) LLM-as-a-Judge 机制虽然能自动化评估文本表面质量，但存在致命盲区：无法验证 AI Agent 底层的工具调用（Tool Calls）、数据库交互与多系统状态流转。 - [11:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=709s) AI Agent 测试必须引入“对抗性客户”（Adversarial Customer）机制，通过多轮对话、攻击性提问和边缘用例主动诱导和破坏系统，以检验真实鲁棒性。 - [13:08](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=788s) 针对自主智能体的测试需要升级为“用 Agent 测试 Agent”，依托强大的底层算力与测试执行基础设施，以极低边际成本并发运行大规模合成用户蜂群。 - [15:14](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=914s) 端到端测试工作流能够直接从 PRD 需求文档生成海量测试场景，结合人类在环（HITL）筛选、语音多模态噪音模拟以及越狱安全漏洞排查。 - [17:25](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1045s) 评估 AI Agent 的合格线必须超越纯语言层面，深入考量工具调用准确率、闭环任务完成度，并支持根据医疗、金融等行业合规标准（如 HIPAA、SOC 2）定制判定阈值。 - [19:26](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1166s) 企业真正的竞争壁垒与护城河不再仅仅是 AI Agent 的构建速度，而在于能否在触达用户前通过独立验证层打造“经过可信验证”（Confidently Validated）的 Agent。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=4s) AI 的核心陷阱：极度自信但完全错误 TestMu AI 的联合创始人兼增长负责人 Mudit Singh 在开场中指出，在当今的 AI 时代，企业面临的最大挑战早已不再是两三年前常说的“模型幻觉”（Hallucination）。随着 AI 技术的演进，业界已经通过各种外围护栏（Harnesses）和工程手段在很大程度上缓解了幻觉问题。然而，当前 AI 最棘手、最危险的本质问题在于它的“过度自信”——即使在给出完全错误的答案时，它依然表现得极度笃定。 AI 不会提示用户“这个答案可能存在不确定性”，而是直接以不容置疑的口吻将错误结论包装成标准答案交付出来。这种“自信的错误”（Confidently Wrong）在通用 AI 特别是自主 AI 智能体（AI Agents）中极为普遍。当没有独立的校验机制时，系统无法意识到自身正在犯错，这构成了当下企业部署 AI 过程中最隐蔽也最昂贵的陷阱。 ### [01:06](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=66s) 从 Chipotle 案例到企业级商业与合规风险为了具象化这种偏离预期的行为，Mudit Singh 分享了 Chipotle 智能点餐机器人的真实案例（Gizmodo 曾对此刊发带有完整截图的调查报道）。原本用于在线订购卷饼碗（Burrito Bowl）的客服机器人，在被用户要求“帮我调试 Python 代码以创建一个链表”时，居然分毫不差地写出了正确的代码。从纯技术角度看，模型没有任何幻觉，代码逻辑完全正确，但它彻底超出了既定的业务范围（Out of Scope）。这个看似有趣的插曲迅速演变成严重的安全与商业事故：有开发者直接逆向调用该机器人的后端 API，制作成开源封装库并发布在 GitHub 上，让公众免费调用 Chipotle 的后端模型来进行日常代码编写。这种“推理盗用”（Inference Theft）与“Token 盗窃”并非孤例，Vercel 曾发布博文披露，类似漏洞可导致每天被盗取价值超过 10,000 美元的 Token。类似的失控事件也曾出现在雪佛兰（Chevrolet）、加拿大航空（Air Canada）以及 AI 编程工具 Cursor 身上。当 AI 代理开始代表企业直接与客户互动并做出业务决策时，风险便延伸到了法律诉讼与行业监管领域： - **保险与银行等强监管领域**：若 AI 给出了错误的保费费率或信贷建议，企业将瞬间面临法律诉讼与合规调查。 - **知识截止日期滞后**：模型的训练知识库可能停留在过去（例如 2024 年），完全无法感知前一天刚刚出台的新监管法规。 - **巨大的财务损失**：安永（EY）的一项调查显示，部署 AI 的企业中发生重大失误的案例屡见不鲜，财富 500 强级大型企业因 AI 失误导致的单次平均财务损失高达 440 万美元。 ### [04:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=289s) 为什么传统测试方法在 AI 时代彻底失效面对如此高昂的风险代价，现有的传统软件测试工具却显得力不从心。Mudit Singh 解释道，传统测试工具本质上是**确定性**（Deterministic）的，遵循严格的“输入对应固定输出”逻辑。以传统的 UI 测试为例，测试脚本只需断言某个按钮是否存在，点击后验证下一步页面是否加载，整个流程都是预设的算法流。然而，AI 的运行机制是非确定性的。面对完全相同的输入，大语言模型在不同时刻给出的输出可能大相径庭。此外，评估 AI 的标准往往不是非黑即白的布尔值，而是一个概率阈值。 ```mermaid flowchart TD accTitle: 传统测试与 AI 测试模式对比 subgraph 传统软件测试 ["传统软件测试（确定性）"] A1["固定输入 Input"] --> B1["预设算法流 / UI 判定"] B1 --> C1{"布尔值判定\nPass / Fail"} end subgraph AI评估模式 ["AI 与智能体测试（非确定性）"] A2["多样化提示词 Input"] --> B2["LLM / 智能体推理"] B2 --> C2["语义渐变输出 Output"] C2 --> D2{"阈值与评分标准\nRubrics (如 80% 正确)"} end ``` 如果询问 AI“谁是美国总统”，它在 90% 以上的时间里能给出正确答案，但在一万次查询中，可能会有一次回答“Barack Obama”。奥巴马确实曾任美国总统，这个答案在语义上并非 100% 凭空捏造的谬误，但作为当前事实它却是不正确的。AI 的输出往往处于这种“部分正确”（例如 80% 正确）的灰度区间中，这使得传统断言完全无法对其进行有效检验。 ### [06:44](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=404s) AI 测试的三种路径与人工测试的局限为了探索行业前沿的测试方法，Mudit Singh 调研了各大头部 AI 企业采用的方案，梳理出评测驱动开发（Eval-Driven Development）、自适应评分标准（Adaptive Rubrics）、人类在环（Human-in-the-Loop）以及 NIST 指南等核心理念，并将其归纳为三大核心测试路径： 1. **人工交互测试（Manual Testing）**：由熟悉业务规则的人员直接与 AI 聊天机器人进行多轮对话测试。 2. **LLM 充当裁判 / 自动化评测（LLM as a Judge / Evals）**：利用 AI 自动生成测试用例并基于评分标准对生成结果进行打分。 3. **大规模端到端模拟测试（End-to-End Simulated Testing）**：全自动化模拟真实用户与系统的复杂交互全流程（目前业内仅极少数团队能够实现）。在人工测试路径中，测试人员凭借经验与直觉输入各种测试场景。虽然该方法在上线前必不可少，但存在两个致命瓶颈： - **主观偏见与渐变尺度难以统一**：AI 的输出是渐变的有界分数（Gradient），不同的人类测试员对“80% 正确”的容忍度完全不同。某个人眼中的“严重错误”，在另一个人看来可能属于“勉强合格可放行”。 - **排列组合爆炸导致无法规模化**：以“航班改签”这一看似简单的场景为例，母语为英语的用户与非母语用户的表达方式截然不同；用户是否理解专业术语（如 PNR，旅客订座记录）也会彻底改变对话路径。单点场景的输入排列组合呈指数级增长，纯靠人工根本无法覆盖全部边界。 ### [09:48](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=588s) LLM-as-a-Judge 的运行机制及其在智能体时代的盲区针对人工评测规模化的瓶颈，业界目前普遍采用 **LLM-as-a-Judge（以模型为裁判）** 的 Evals 体系。这种方法结合历史真实对话日志与 AI 预测，构建海量测试数据集并生成成千上万个测试 Prompt，批量发送给目标模型，随后利用另一个配置了特定规则判定标准（Rubric）的判定模型对输出内容的正确性、格式合规度等进行多维度梯度打分。 ```mermaid flowchart LR accTitle: LLM as a Judge 评测流程 subgraph 数据构建 ["测试集生成"] A["历史交互日志"] --> C["Prompt 数据集"] B["AI 预测用例"] --> C end subgraph 目标执行 ["目标调用"] C --> D["目标 AI / API"] D --> E["生成响应结果集"] end subgraph 判定评估 ["自动化打分"] E --> F["裁判模型 (Judge LLM)"] G["打分规则 (Rubrics)"] --> F F --> H["多维度质量得分 / 梯度判定"] end ``` 包括 OpenAI 在内的几乎所有主流 AI 研发团队都在深度依赖 Evals 模式。尽管这一机制在纯文本内容与格式校验上表现出色，但将其直接套用于 **AI 智能体（AI Agents）** 时，却暴露出严重的盲区。 Mudit Singh 强调：“AI 智能体是一个具有生命力的活体系统（Living, breathing thing），它绝不仅仅关乎底层大模型或 Prompt 本身。”在完整的改签流程中，智能体必须执行一系列底层工具调用（Tool Calls）： - 调用数据库接口验证用户的 PNR 订座记录是否存在； - 触发后端核心业务逻辑执行实际的改签扣款与席位变更； - 调用 PDF 生成服务为客户生成合规的全新登机牌与电子行程单； - 与企业内部的 CRM、ERP 等遗留系统进行深层 API 数据同步。仅仅使用基于文本匹配的 LLM-as-a-Judge，只能评估对话表面是否通顺，完全无法验证背后的工具调用、数据库操作和多系统状态流转是否在静默中崩溃。智能体测试必须跳出纯语言评估的局限，走向对全链路系统行为的深度验证。 ### [11:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=709s) 传统评估与人工测试的局限：为什么需要对抗性端到端模拟在当今的企业级软件架构中，数以千计的组件与服务相互交织，而 AI Agent 的交互触角更是贯穿整个系统全局。面对如此庞大且动态的交互网络，传统的人工测试不仅成本高昂、难以扩展，在准确性上也捉襟见肘。与此同时，行业内流行的“LLM 作为裁判”（LLM-as-a-judge）的单点评估方式同样存在盲区——它无法全面覆盖跨组件的复杂调用链路，也无法精确裁定工具调用（Tool Calls）的执行准确性与副作用。真正的解决方案需要将这些评估手段整合并向前推进一步：必须建立一套能够逐轮（Turn-by-Turn）模拟完整真实对话场景的机制。这种测试机制不仅要对底层调用的完整堆栈追踪（Stack Trace）进行逐级评分，更关键的是扮演“对抗性客户”（Adversarial Customer）的角色。测试系统必须像现实中“最挑剔、最恶意的破坏者”一样，主动通过各种边缘用例和攻击性提问，试图诱导或搞垮你的聊天机器人和 AI Agent。然而，市场上绝大多数正在构建 AI 应用的团队目前根本没有执行这一步。如果你去向展会上的 AI 开发者询问他们究竟是如何测试产品的，会发现端到端的对抗性多轮交互测试依然是普遍缺失的一环。 ```mermaid flowchart TD accTitle: AI Agent 端到端对抗性测试架构 accDescription: 展示从输入产品上下文到生成对抗性场景、多智能体执行及指标判定的完整流程。 subgraph InputStage ["1. 输入与上下文解析"] PRD["产品需求文档 / Markdown 说明"] HITL["人类专家在环 (HITL) 筛选与定义"] end subgraph SwarmStage ["2. 智能体蜂群模拟与对抗执行"] Generator["测试场景生成智能体<br/>(数十万行测试用例)"] AdversarySwarm["对抗性用户智能体蜂群<br/>(多角色 / 噪声 / 恶意攻击)"] TargetAgent["被测 AI Agent<br/>(工具调用 / 业务逻辑)"] end subgraph EvalStage ["3. 评估分析与决策输出"] Metrics["35+ 核心评估指标<br/>(工具准确率 / 延迟 / 漏洞 / 幻觉)"] Report["Go / No-Go 上线裁决报告"] end PRD --> HITL HITL --> Generator Generator --> AdversarySwarm AdversarySwarm <--> TargetAgent TargetAgent --> Metrics Metrics --> Report ``` --- ### [13:08](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=788s) 用 AI Agent 测试 AI Agent：依托底层基础设施的大规模自主仿真如果说用 AI 测试 AI 是 LLM 评估的初步形态，那么针对自主智能体的测试，则必须升级为“用 AI Agent 来测试 AI Agent”。TestMu AI 的核心构想正是部署自主 AI Agent 作为合成终端用户，在大规模并发环境下模拟真实用户行为，执行端到端的全流程对话与业务调用。这种大规模测试不仅需要智能体本身的推理能力，更依赖强大的底层算力与执行基础设施支持。TestMu AI 并非横空出世的初创团队，平台自 2018 年成立以来，已拥有约 300 万名开发者、程序员与测试人员，每年稳定执行约 15 亿次自动化测试，服务于包括 OpenAI、Salesforce、Transavia 以及微软（Microsoft）在内的诸多企业。团队此前构建的执行引擎 HyperExecute 覆盖了 Web 端、移动端、前端、后端以及 API 性能等全栈测试需求。正是这种深厚的底层基建优势，使他们能够以极低的边际成本快速拉起指数级扩张的测试智能体蜂群，自主编写测试用例、在云端并发执行，并为开发者输出精准的根因分析：明确标示出系统各环节的表现、崩溃点以及具体的修复建议。 - **基础设施底座**：自 2018 年起步，沉淀了年均 15 亿次测试执行的底层算力引擎 HyperExecute。 - **用户与客户生态**：全球约 300 万开发者使用，获得 OpenAI、微软、Salesforce 等一线厂商验证。 - **降本与洞察**：以极低成本并发执行数以万计的复杂用例，提供直观的运行状态、故障溯源与修复指引。 --- ### [15:14](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=914s) 测试工作流实战：从 PRD 文档到多角色、语音场景与安全漏洞攻坚在实际工作流中，企业客户只需向平台提供基础上下文——例如一份 PRD 产品需求文档或简单的 Markdown（`.md`）说明文件，描述该应用的功能定位与业务逻辑。系统便会自动据此生成包含数十万行测试场景的海量测试数据集。为了确保测试不沦为毫无意义的盲目轰炸，系统引入了关键的“人类在环”（Human-in-the-Loop）机制。开发与测试团队可以主动介入，根据实际需求筛选核心场景，剔除无效噪音，并灵活配置所需测试的目标用户画像（Personas）。在语音机器人（Voice Bots）与电话外呼机器人的测试中，系统甚至能够模拟不同地区口音、方言特色以及复杂的背景环境噪音，并发启动一整套 AI Agent 蜂群对目标系统展开全方位的压力与场景冲击。测试完成后，系统会输出涵盖近 35 项评估指标的详尽报告，给出明确的“上线 / 不上线”（Go / No-Go）决策建议。同时，测试重点覆盖安全性与逻辑脆弱性，主动充当攻击者，排查类似越狱投毒、企业 API 密钥泄露以及逻辑绕过等致命安全漏洞。 ```mermaid flowchart LR accTitle: 语音与多模态 Agent 仿真测试维度 accDescription: 展示从输入 PRD 到模拟口音、噪音、对抗攻击并输出上线决策的流转。 A["输入 PRD / MD 上下文"] --> B["生成海量场景与角色画像"] B --> C{"多模态特征注入"} C -->|"环境变异"| D["口音 / 背景噪音 (语音测试)"] C -->|"安全攻击"| E["越狱测试 / API 密钥防泄漏"] D --> F["智能体蜂群并发执行"] E --> F F --> G["35 项指标分析 & Go/No-Go 判定"] ``` --- ### [17:25](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1045s) 核心指标与合规标准：如何定义 AI Agent 的「合格线」目前整个 AI 行业对于 Agent 的评估缺乏公认的统一规范，既没有标准化的“DORA 研发效能指标”，各家企业的模型与业务场景也千差万别。除了常规的模型偏差（Bias）、幻觉（Hallucination）和个人身份信息（PII）泄露防范之外，针对 Agent 的测试还必须深入到行动与执行层。这涵盖了一系列全新的评估维度：工具调用的准确率到底有多高？Agent 是否具备闭环推进并完成整个复杂会话的能力？例如系统要求生成一份合规的 PDF 业务文档时，Agent 是否不仅能输出文档，还能自我校验文件内容的准确性？此外，完成单项业务所需的对话轮数（Step Count）以及端到端响应延迟也是衡量 Agent 可用性的核心指标。不同行业对可靠性的容忍度截然不同。TestMu AI 允许企业根据自身场景自定义判定阈值算法（Rubric Algorithm）： - **医疗健康领域**：对准确率有着近乎严苛的要求，模型与 Agent 必须达到 99.9% 的准确率，绝不允许致命失误。 - **跨境电商等消费场景**：对于交互容错与对话弹性的阈值设定则相对宽泛。在合规管控层面，测试全程运行在严密的安全监管体系下，能够协助企业全面验证 AI Agent 是否符合包括 HIPAA、ISO、SOC 2 Type II、FINRA 在内的行业合规标准，内建支持 35 种不同的金融级合规检测项。 --- ### [19:26](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1166s) 结语：新时代的护城河在于「经过可信验证的 AI Agent」在与众多前来的 CEO、CTO 和创业团队交流时，行业普遍都在竞逐“AI Agent 的构建与迭代速度”。然而，当前技术演进真正的阻碍并不在于你能多快写出一个 Agent，而在于你如何快速且有效地验证它。 "自信地给出错误答案"是 AI 落地过程中的巨大隐患。真正的竞争壁垒与业务护城河，已经转移到能否在 Agent 接触真实用户之前，完成全面、严密的对抗性测试，并将一个“经过可信验证（Confidently Validated）”的 AI Agent 稳健地推向生产环境。 ## Notable quotes > Your AI agent will never tell you it's wrong. It doesn't know it's wrong. It ships code with total confidence, answers customers with total confidence and is exactly as confident when it's right as when it just invented a refund policy that doesn't exist — Mudit Singh > That's the trap of the agent era: confidence isn't correctness, and an agent can't grade its own work. — Mudit Singh > The fix isn't a better model, it's an independent layer that verifies what the agent did before it reaches a customer, not after the damage is done. — Mudit Singh > [01:06](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=66s) 帮我调试 Python 代码以创建一个链表 > [09:48](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=588s) AI 智能体是一个具有生命力的活体系统（Living, breathing thing），它绝不仅仅关乎底层大模型或 Prompt 本身。 — Mudit Singh > [11:49](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=709s) 最挑剔、最恶意的破坏者 — Mudit Singh > [13:08](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=788s) 用 AI Agent 来测试 AI Agent — Mudit Singh > [19:26](https://www.youtube.com/watch?v=Jh2_xYVk1jY&t=1166s) 当前技术演进真正的阻碍并不在于你能多快写出一个 Agent，而在于你如何快速且有效地验证它。 — Mudit Singh ## Mentioned Mudit Singh, TestMu AI, Chipotle, Gizmodo, GitHub, Vercel, 雪佛兰 (Chevrolet), 加拿大航空 (Air Canada), Cursor, 安永 (EY), NIST, OpenAI, HyperExecute, Salesforce, Transavia, 微软 (Microsoft), HIPAA, ISO, SOC 2 Type II, FINRA, DORA ## Video description Mudit Singh - Co-Founder and Head of Growth, TestMu AI Confidently wrong AI has a price tag and in 2026, it's a line item. Your AI agent will never tell you it's wrong. It doesn't know it's wrong. It ships code with total confidence, answers customers with total confidence and is exactly as confident when it's right as when it just invented a refund policy that doesn't exist, or reported success over a database it quietly broke. That's the trap of the agent era: confidence isn't correctness, and an agent can't grade its own work. So the failures don't look like failures. They look like green checkmarks and fluent answers — right up until a real user, or a regulator, finds the one that was wrong. It's already expensive: 99% of organizations deploying AI report financial losses from it, averaging $4.4 million each. The fix isn't a better model, it's an independent layer that verifies what the agent did before it reaches a customer, not after the damage is done. This talk shows what that looks like for both kinds of agents: the ones that build, and the ones that interact. You'll walk out able to tell an agent that sounds trustworthy from one you can actually trust, before your next deployment writes a check your business can't cash. [Source](https://www.youtube.com/watch?v=Jh2_xYVk1jY)

Source quotes

Mudit Singh: Your AI agent will never tell you it's wrong. It doesn't know it's wrong. It ships code with total confidence, answers customers with total confidence and is exactly as confident when it's right as when it just invented a refund policy that doesn't exist Mudit Singh: That's the trap of the agent era: confidence isn't correctness, and an agent can't grade its own work. Mudit Singh: The fix isn't a better model, it's an independent layer that verifies what the agent did before it reaches a customer, not after the damage is done. [1:06] 帮我调试 Python 代码以创建一个链表 [9:48] Mudit Singh: AI 智能体是一个具有生命力的活体系统（Living, breathing thing），它绝不仅仅关乎底层大模型或 Prompt 本身。 [11:49] Mudit Singh: 最挑剔、最恶意的破坏者 [13:08] Mudit Singh: 用 AI Agent 来测试 AI Agent [19:26] Mudit Singh: 当前技术演进真正的阻碍并不在于你能多快写出一个 Agent，而在于你如何快速且有效地验证它。

Source quotes

Mudit Singh: Your AI agent will never tell you it's wrong. It doesn't know it's wrong. Mudit Singh: That's the trap of the agent era: confidence isn't correctness, and an agent can't grade its own work. Mudit Singh: So the failures don't look like failures. They look like green checkmarks and fluent answers — right up until a real user, or a regulator, finds the one that was wrong. Mudit Singh: The fix isn't a better model, it's an independent layer that verifies what the agent did before it reaches a customer, not after the damage is done. [0:04] Mudit Singh: there is a possibility that this might be the answer. [0:04] Mudit Singh: extremely confident even when it goes wrong [4:51] Mudit Singh: Who is the President of the United States? [11:49] Mudit Singh: act as an adversarial customer, act as your worst customer that can come to your chatbot and actively try to break your chatbot or your AI agent. [19:26] Mudit Singh: getting a confidently validated AI agent in front of customers is what the new moat is, what's the new competitive edge.

Original transcript

[0:04] to introduce myself. I am Modit Singh. I am one of the co-founders at a company called Test Mu AI. Uh [0:10] we have been around for quite some time but very recently in the age of AI we started to look into [0:18] how exactly to validate AI. Now one of the biggest challenges is not hallucinations which [0:25] used to be let's say two or three years back. people have like AI has evolved quite a lot and [0:30] people have built quite a harnesses over the top and like there there are ways to kind of [0:36] mitigate some of the things that AI has problem but one biggest problem that I feel [0:41] personally AI has is that it is extremely confident even when it goes wrong like [0:48] it won't say that I know there is a possibility that this is the answer no it will say it's [0:54] a wrong answer and it will say yes this is the answer and that is one of the biggest challenges [0:59] uh across AI and in general AI agents. So how do we actually fix that? [1:06] I of course everybody has uh Twitter, Instagram, LinkedIn, you will see a lot of [1:11] AI fail. Just search the hashtag AI fail. But this is one of my favorite story, right? Like [1:16] uh u first of all disclaimer, this is a Chipotle story. They always claim that this never happened. [1:23] But I have a Gizmodo article which has all the screenshots and the proof. But what happened was [1:28] that there's a chatbot, a Gizmodo chat uh uh Chipotle chatbot where you can go [1:32] and order uh a burrito bowl. But somebody went there and said, "Okay, while ordering the thing, [1:39] here's my Python code. Can you debug it? Can you figure out what is working?" Uh [1:45] it was correct. It actually wrote the code. Sorry, here for creating a link list. Uh it [1:51] was uh completely correct. There was no hallucination. There was nothing that went wrong. [1:55] It was just it was out of scope. Pretty funny, right? Till it didn't become funny anymore. [2:02] So some developer went ahead used that API in the back end created a wrapper around it and now there [2:08] is actual GitHub project by this name. You can use Chipotle's AI chatbots LLM in the back end [2:16] and do your own coding. And it's not just Chipotle. There are a few other companies [2:21] that are part of this thing. I'm not sure if it is still there or maybe they have [2:26] fixed that bug but it escalated pretty fast. This was inference theft, token theft and uh we know [2:33] for a fact that companies like Versel, they have a blog about this as well that people were able to [2:38] kind of use that chatbot to do at least $10,000 a day worth of tokens stolen from it. Right? [2:47] It's not just one case like it's happening for quite some time. Chevrolet had an issue. [2:52] Air Canada has an issue. cursor the AI company themselves they had an issue and it's happening [2:58] now because when we are using customerf facing AI chatbots uh customerf facing AI it becomes even [3:04] more critical and I'm like it was a case study about uh token theft but it's also about digital [3:11] experience right so we have AI agents that are making decisions on behalf of our company in front [3:19] of our customers and now that is a extremely critical ical aspect of the overall business [3:28] and most importantly it's not about hallucination or bias it was that AI never knew that it was [3:35] wrong it was pretty confident about what it was saying and it's that businesses or people like us [3:42] who end up paying so what are the core risks they are of course uh insurance issues regulators so [3:52] we had uh um I was roaming around the there were a lot of regulated industries that are building [3:57] customerf facing chatbots, banks and everything. So there are a lot of problem statements. There [4:02] are of course litigations. If your AI is wrong about let's say a uh insurance rate that it's [4:07] supposed to give out that's potential lawsuit right then and there. There are also a lot of [4:13] regulations that are coming out. Now AI has a let's say a 24 uh 2024 cut off date. They didn't [4:19] know the regulation that came out just yesterday. So, how do you mitigate all of that? Right? So, [4:26] that is the problem statement and it's not a cheap problem statement. When AI goes bad, [4:31] it goes bad big. It's a actual survey done by uh EI and they have figured out that on an average [4:40] large Fortune 500 companies have lost up to $4.4 million just because of AI gone wrong. So [4:49] how do you test for that? How do you test whether the AI that you are building, deploying is working [4:55] perfectly as expected. Now one of the challenges with I'll say traditional testing tools is that [5:01] they are not sufficient enough to test for AI. Why? Because traditional testing tools are very [5:08] predictive deterministic input in output out kind of a platform where like for example you [5:12] have to test UI. It's about asserting whether that button is there. If that button is there, [5:17] click it and if next step happens, yes or no. Right? So, it's a very uh kind of an algorithmic [5:23] flow that is predetermined in nature and traditional AI is not something like that. It does [5:28] not work like that because for every input, the output could be different every other time. So, [5:36] we go with a threshold. So for example, here's the use case that if I want to rebook a flight, [5:40] the way a customer can start that conversation could be completely different personto person, [5:46] situation to situation and even the response that come out of an LLM that can also differ. [5:53] For example, uh if I ask who is the uh president of United States, it will tell the right answer. [6:01] 90% of the time there is a possibility that out of 10,000 times you ask one time it may [6:08] say Barack Obama. Now that's not a wrong answer. He was the United States of he was the president [6:13] of United States but that does not mean he's the president of the United States currently. [6:17] It's not also a 100% wrong answer. So that's the challenge right? It's a threshold. It's not a uh [6:24] onestop thing as well. It's not a deterministic. It can be right but can also be right 80% of [6:31] the time and most importantly that correctness threshold will also be that it is correct 80% not [6:37] 100% right [snorts] so how do you actually test for that so I use uh chart GPT DP search agents [6:44] I use multiple agents to figure out what the big AI companies are talking about how do they do it [6:50] they had pretty pretty big words like eval driven development adoptic rubrics human in the loop [6:57] uh NIST has a guideline of their own. I will have all these links there. If you just DM me, I'll [7:04] be happy to share all these links to talk about. But I know there's a very diverse crowd here. So, [7:08] let me kind of condense all this knowledge down into something a little bit simpler. So, there [7:14] are actually three core approaches that I feel of how you actually test the AI. First of all, [7:19] it's of course a manual process. You can have a human who actually goes and start interacting [7:24] with AI chatbots. So I'm taking examples of AI chatbot because it's applicable to even [7:28] enterprise AI or enterprise AI workflows. U AI chatbot is a little bit simpler to understand. [7:35] Then there is another layer which is an AI writes the test cases. AI test that test cases we usually [7:41] call an LLM as a judge uh also eval. And now this is the third one which very very few are doing [7:48] is how to do an end toend simulated conversation or end to end simulated AI testing at scale. [7:56] So let's talk about how to test it manually. Now as I said we have a chatbot that's job is to [8:03] rebook a flight. So we have a human who knows the what the system is, how it works, what the chatbot [8:09] is supposed to do and start to interact on let's say based on their experience based on gut feeling [8:14] that this is what it um this is I'm going to try these scenarios let's do it one by one [8:21] now the of course it works first of all it's I'm not saying that doesn't work the before deploying [8:26] an AI the people who is building AI they also test it as well right so that is not that it does not [8:32] work but there are two core challenges with there like I have written three but there are two core [8:36] challenges with it. Uh first of all the person who is testing the AI they can also be biased and as [8:44] I said AI is not about input in output out it's not just a check mark it's about a threshold it's [8:49] about that it is correct but it is correct only 80%. But who defines that 80% and a human judge [8:56] usually has a bias. So for example for somebody it would be a completely wrong answer but for [9:01] somebody it was an okay answer let's move it ahead right so humans are biased in general so humanly [9:06] it's difficult to uh test a gradient but most importantly it's a problem at scale [9:12] so as I mentioned the inputs could be multiple just for a chatbot the way to rebook a flight [9:18] that conversation can start off with many many different type of uh starting words [9:24] every person is also different who is interacting with the chatbot. So that means a person who is [9:29] a native English speaker would have a different starting point. A person who is nonnative English [9:33] speaker would have a different starting point. What happens if they understand what a PNR is? [9:38] What they happens if they don't understand what a P&R is? So scenarios even for a one [9:42] scenario the permutation and combinations are exponential and it's not scalable humanly. [9:48] So what we do again we use AI for that. So we use AI to create a huge set of data sets [9:54] using both predictively that means AI to predict what all could be the possible combination [9:59] and maybe look at past conversations that has happened build up a data set [10:03] use that data set to create a set of prompts send it one by one to our API or AI or our agent [10:09] and figure out what's the responses coming and of course because there are thousands of response [10:13] we use another AI with a algorithm or a guidel guideline in place called rubric to analyze each [10:20] and every response to figure out how good the AI is or how accurate our AI agent is. So we [10:27] basically LLM as a judge also known as evals. It works actually it's pretty solid. People have [10:34] been doing it. OpenAI has been doing it. Charge has been doing it. Every every company has been [10:38] doing it. If you are building AI agents, this is something that you may also have been doing it. [10:43] And uh what do you actually test for? You test for correctness format. And because it's a algorithmic [10:48] AI checking uh let's say an LLP response, it can do it on a gradient. But there is a problem in [10:56] that because I started the conversation not about testing of AI. I started the conversation about [11:02] testing of AI agents. AI agents is a living breathing thing. It's not just about LLMs. [11:07] It's not just about prompts. There are tool calls that is happening. So our flight rebooking example [11:13] there is a tool call that happens inside a database to figure out if that PNR actually [11:17] exists or not. Once that conversation happened, once it went ahead actual rebooking happened. So [11:24] uh actual new boarding pass or a ticket generated a PDF has to be provided to the customer. [11:29] Did that process worked out perfectly or not? Is there a challenge in between? So along with [11:35] what LLMs are happening, there are also other systems that integrate inside the AI agents [11:42] including databases, including tool calls, including APIs, including CRM, ERP, [11:49] there are there are like any enterprise company here, [11:52] there are thousands and thousands of things that integrate and make up a whole software, [11:56] right? So an AI agent across across the whole board interacts across the whole board. [12:02] So a simple human testing is not scalable enough, accurate enough. U LLM as a judge, eval is not [12:10] something that is testing across the board all the things or grading how accurate the tool calls are. [12:18] So what we actually need? What's the solution? We need all of those two that we just talked [12:22] about. But at the same time we also need a way to actually simulate a full scenario turn by turn [12:30] a whole conversation done turn by turn which grades the exact stack trace which grades the [12:37] exact conversation and most importantly act as an adversarial customer act as your worst customer [12:45] that can come to your chatbot and actively try to break your chatbot or [snorts] your AI agent. [12:51] Now this is where a lot of companies are missing it and I I've been talking around [12:56] and while you are on the floor go ask anybody who is building AI how actually they are testing [13:01] that AI and you will find this is the step which most of the people are not even doing as of now [13:08] but of course how do you do that as well so we already have AI testing AI in LLM evals [13:15] now this would be an AI agent testing an AI agent one step ahead same concept you need an AI to [13:21] test an AI. We deploy autonomous AI agents that act as synthetic end users to actually simulate [13:29] real users and executing end-to-end conversations at scale. So this was the concept that we started [13:36] with building when we started to build uh the testing of uh AI agents. So it's not that we [13:42] are a new company, we have been around for quite some time. We started in 2018. uh around 3 million [13:49] developers, programmers, testers are using our platform. We execute around 1.5 billion tests [13:55] every year and testing or quality assurance has been the base of our platform used by [14:00] companies like OpenAI, Salesforce, U Transavia, Microsoft, quite a lot of companies and uh we have [14:08] when we started to build up AI agents or AI agents of our own, we started to realize that testing of [14:13] that AI agents is a very exponential aspect. You need both capabilities AI agents of your own [14:20] but to run it at scale you needed infra and that is where was also the bread and butter that we had [14:27] we had the advantage we were the infra providers to test other infra providers so we had an [14:33] execution engine called hyperexecute over the top just for testing web mobile back end front [14:39] end API performance and all of that and that gave us the foundation to create exponential AI agents [14:46] and exponential AI agents to author the test, perform the test, execute it at a infra, [14:52] give you back the result at a fraction of a cost and give you insight on what is working, [14:59] what is breaking and what you can do to fix it. So I'm not going to talk about the whole [15:03] platform just about the agent testing. If you want to know more about feel free to reach [15:07] out at the booth and I'll be happy to tell. So how do you actually test your AI agents? [15:14] We create as I mentioned a AI agent that actually simulate the test scenarios. A AI agent that [15:22] creates a huge data sets of hundreds of thousands of rows of test scenarios. Perform it mapping with [15:29] personas accents. So we can also test voice bots and phones bots. So there you need accents. there [15:33] you need background noises to perform that and create a spin up a swarm of AI agents to actively [15:41] interact with your agent in the test and figure out vulnerabilities. So this is how it looks like [15:46] in action. You provide us with context kind of like a PR document or even an MD file of what your [15:52] application is, what your application does. We use that to figure out a huge number of test scenarios [15:59] starts to execute those test scenarios one by one. So there is a human in the loop element [16:04] across every place. A deliberate human in the loop element to figure out what is happening [16:09] and uh how to map which personas you want to test. As I said, thousands of test scenarios does [16:14] not necessarily mean that all that noise is also required, but we can help you cut that down noise. [16:20] And we will have an actual uh user performing actual AI agent performing that test step [16:28] and end of the day. Uh we create a complete report of a go no-go action for your AI agent. Uh perform [16:35] a simulated conversation and uh provide you analytics across nearly 35 different metrics. [16:42] which you can take as a both microlevel thing like which exact matrix was um um [16:48] was passing which was failing and if you can take a go no-go decision for your AI agent [16:56] and also most importantly we can also test for vulnerabilities. So there is a huge security [17:03] layer. The chipotle example just I talked about. We can also test for that. We can also check for [17:07] logical vulnerabilities. We can also test for uh things like for example your uh AI agent is [17:13] not leaking and let's say an API key. We act as an adversary agent to actively try to break [17:19] your agent in the test and figure out what is going right and also what is going wrong. Now [17:25] this is the money slide. What exactly we test for? Because there is no global standard on what has to [17:30] be tested. For example, everybody has a LLM that is doing something different completely different. [17:37] It's very contextdriven, but so there is no uh dorometrics for testing of AI agents, right? So [17:43] what do you exactly test for? There are of course things like testing for biasness, testing for [17:48] hallucination, uh testing for PIIA exposure, but there are also because we are talking about AI [17:53] agents, there are also things like how accurate is the tool call that is happening. How act uh [17:59] whether the overall agent was able to actually complete the overall conversation, [18:04] whether the AI agent was actually able to generate let's say in our case a direct [18:08] uh good PDF document also validate that PDF document if that document was right or wrong. [18:14] what was the latency, how much time it took, what were the number of con steps that was there in the [18:18] conversation to actually get the job done. All of those is something that we have built in. But at [18:24] the same time, we tested for a threshold. So for each parameter, for each metric, you can define [18:32] either on your own or work with us a rubric algorithm that this is what correct looks like [18:37] for us. For example, for a uh healthcare company, AI has to be right 99.9% of the time. It cannot be [18:45] wrong. But for maybe a e-commerce company, uh that threshold may be a little bit different. So we [18:51] create a series of 35 pre-built metrics. But those can be defined, custom defined or even [18:58] that metrics threshold can be changed as well. And all of this is happening in a regulated ecosystem [19:05] where we ensure that your AI agents that are building are compliant across all the [19:10] industry guidelines that includes HIPPA, ISO, SOCK 2, type 2, uh, FINRA. There are like [19:16] 35 different financial uh, compliances that we can ensure that your AI agent is meeting. [19:26] people a lot of CEOs and CTOs and founders have been coming to our booth and asking me like [19:31] what do you think the new age of AI looks like? One of the things I tell them that [19:35] while everybody has been focusing on how fast we can build, I personally feel the bottleneck [19:41] is how fast we can validate an AI agent is using a AI agents effectively. Getting a confidently [19:51] validated AI agent in front of customers is what the new motives what's the new competitive edges. [19:58] So thank you that's for my talk. Uh feel free to reach out to me at booth testi. [20:03] Happy to discuss as far thank you. [applause]