New York Life Deploys Multi-Tier Circuit Breakers for Autonomous AI
Ai4
Autonomous AI systems require continuous execution trajectory audits and granular kill switches because evaluating static outputs fails to catch compounding errors and prompt injections across regulated trust boundaries.
## Background
Published on YouTube by Ai4 on August 19, 2026, this presentation features Marina Printz, VP of AI and Data Science at New York Life. The talk outlines practical methodologies for evaluating and monitoring generative AI systems in production to ensure outputs are verifiably accurate rather than merely confident-sounding.
## TL;DR
Marina Printz outlines New York Life's enterprise governance framework for safely deploying generative and agentic AI systems within a heavily regulated financial services environment. The operating model is anchored by two safeguards (pre-deployment testing and runtime monitoring), four diagnostic response checks (context relevancy, answer relevancy, groundedness, and completeness), and three predefined operational response tiers. The talk emphasizes moving beyond static prompt-response metrics to trajectory-level auditing for autonomous agents, calibrating LLM judges against human review, and implementing granular isolation kill switches. Printz also details organizational enablement through the 'Ignite AI' literacy program and continuous qualitative feedback loops to align technical rigor with real-world business value.
## Atmosphere & style
The presentation delivers a pragmatic, authoritative, and methodical deep dive into enterprise AI engineering and compliance. Printz maintains a direct, candid tone that cuts through industry hype, blending dry humor with rigorous architectural discipline. Watching the session feels like sitting in on a high-level operational briefing where theoretical agent capabilities are systematically grounded into measurable risk tiers, audit trails, and concrete production controls.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=LnRXxsviw7A&t=4s) Deploying agentic systems shifts validation from evaluating plausible text generation to verifying safe tool selection, intermediate reasoning trajectories, and policy-compliant workflow execution.
- [02:44](https://www.youtube.com/watch?v=LnRXxsviw7A&t=164s) Operating in heavily regulated financial services requires Board-level auditability and error tracking to meet governance standards like the NAIC AI model bulletin adopted across 24 states.
- [05:02](https://www.youtube.com/watch?v=LnRXxsviw7A&t=302s) Enterprise AI adoption should progress through defined capability tiers (Empower, Elevate, Reimagine), scaling architectural complexity and autonomy only when justified by cost-benefit analysis.
- [06:54](https://www.youtube.com/watch?v=LnRXxsviw7A&t=414s) Agentic evaluation requires auditing the entire execution trajectory—including planning, tool parameter selection, and intermediate observations—because intermediate decisions compound across steps.
- [08:25](https://www.youtube.com/watch?v=LnRXxsviw7A&t=505s) Operational safety relies on defining three operational response tiers (Log, Review, and Pause) before deployment to avoid improvising incident escalations during live production failures.
- [11:46](https://www.youtube.com/watch?v=LnRXxsviw7A&t=706s) Standard golden datasets are inadequate for agents, requiring a five-part test portfolio to protect against hallucination traps, execution inefficiencies, and indirect prompt injections in retrieved external data.
- [14:53](https://www.youtube.com/watch?v=LnRXxsviw7A&t=893s) Effective scoring demands triangulating LLM-as-a-Judge, deterministic rule checks, and human review, using review discrepancies to continuously calibrate and refine automated judging rubrics.
- [17:12](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1032s) Four technical diagnostics (context relevancy, answer relevancy, groundedness, and completeness) isolate root causes of failure but must be paired with business usefulness metrics to confirm practical value.
- [22:19](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1339s) Production runtime safety requires granular isolation capabilities—such as pausing specific tools, constraining action spaces, or detaching corrupted data sources—rather than blunt global kill switches.
- [27:23](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1643s) Because no single commercial vendor provides an all-in-one governance platform, enterprises must build composite architectures combining vendor tools, internal orchestrations, and semantic data layers.
- [28:57](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1737s) Scaling generative AI safely across large workforces requires structured capability programs like 'Ignite AI' that integrate tool distribution with formal training, change management, and departmental champions.
- [31:47](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1907s) Balancing rapid foundation model innovation with strict governance requires supplementing quantitative telemetry with qualitative feedback loops, including customer service call listening and user focus groups.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=LnRXxsviw7A&t=4s) The Agentic Shift: Moving from Prototypes to Production at Scale
Marina Printz, Vice President of AI and Data Science at New York Life, opens her talk with a lighthearted remark, wondering if scheduling drinks at 4:00 PM instead of 5:00 PM might have drawn a larger crowd. Transitioning into the core subject, she poses a thought experiment regarding what deploying agentic systems actually entails. In an agentic architecture, systems do far more than generate text: they retrieve information dynamically, select tools, and take concrete actions on behalf of users—such as drafting client communications, updating core business records, or executing end-to-end task requests. While early prototypes look impressive almost immediately, moving from a proof-of-concept to scaling in production introduces fundamentally different challenges.
When an autonomous system reads external unstructured content, selects downstream tools, and modifies enterprise workflows, success can no longer be judged simply by whether it generated a plausible answer. Organizations must determine whether the system arrived at the outcome safely, accurately, and strictly within enterprise policies—and how operators will detect when underlying behavior shifts. To address this, Printz introduces a practical operating framework designed to decouple systemic reliability from foundational model variance, built upon three foundational pillars: two safeguards, four shared response checks, and three predefined production response tiers.
- **Core Framework Pillars**:
- **Two Safeguards**: Rigorous pre-deployment evaluation paired with continuous post-launch production monitoring.
- **Four Response Checks**: Answer relevancy, context relevancy, groundedness, and completeness applied across both pre-deployment and runtime environments.
- **Three Production Response Tiers**: Explicit, pre-agreed operational thresholds for logging, reviewing, and pausing systems.
- **Model Independence Principle**: The governance and evaluation architecture must hold stable regardless of how underlying foundation models evolve, update, or benchmark against one another.
[02:44](https://www.youtube.com/watch?v=LnRXxsviw7A&t=164s) Regulatory Realities and Trust Boundaries in Financial Services
New York Life operates as a life insurer and financial services provider within a heavily regulated B2B2C business model. The enterprise supports a nationwide network of 12,000 agents and financial advisors delivering solutions across life insurance, annuities, wealth management, and long-term care. In this ecosystem, AI systems rarely operate in complete isolation; instead, they intermediate workflows between internal corporate employees, field agents, and end consumers. Consequently, every automated output crosses multiple trust boundaries where an unchecked error produces far greater fallout than a harmless cosmetic mistake on a screen.
Flawed model outputs directly generate advisor confusion, operational rework, compliance vulnerabilities, or unauthorized state changes across core financial systems. This operational reality aligns with heightened regulatory oversight across the United States. The National Association of Insurance Commissioners (NAIC) established an AI governance model bulletin that has already been adopted by 24 states. This standard mandates that insurers maintain a formally documented AI governance program with explicit reporting accountability to the Board of Directors, requiring detailed records of testing protocols, error tracking, and guardrail validations.
```mermaid
flowchart TD
accTitle: AI Governance and Multi-Tier Enterprise Architecture
accDescription: Workflow showing governance requirements and the three strategic tiers of AI adoption at New York Life.
subgraph Gov["Regulatory & Governance Layer (NAIC Compliance)"]
G1["Board-Level AI Governance & Auditability"]
G2["Cross-Trust Boundary Controls (B2B2C: 12k Agents)"]
end
subgraph Strategy["Enterprise AI Strategic Tiers"]
T1["Empower: Broad Access & Local Copilots"]
T2["Elevate: Targeted Custom Solutions & Measured ROI"]
T3["Reimagine: Autonomous Domain-Level Intelligence"]
end
Gov --> Strategy
T1 --> T2 --> T3
```
[05:02](https://www.youtube.com/watch?v=LnRXxsviw7A&t=302s) Strategic AI Tiers: Empower, Elevate, and Reimagine
New York Life structures its enterprise AI strategy across three distinct capability levels:
1. **Empower**: Broad-access productivity tooling deployed across local, everyday tasks.
2. **Elevate**: Targeted, custom-built solutions engineered to deliver quantifiable business outcomes.
3. **Reimagine**: Transformative, domain-level workflow redesigns building toward integrated enterprise intelligence.
Printz emphasizes that these tiers represent more than technological sophistication; they reflect escalating architectural complexity, deeper reliance on proprietary enterprise data, and greater operational autonomy. As systems move toward autonomous execution, validation criteria must expand from simple text validation ("did we get the right response?") to operational verification ("was the action performed correctly and within authorized guardrails?"). However, Printz warns against pursuing full autonomy for its own sake: every deployment must be grounded in strict cost-benefit analysis. A straightforward summarization or document-drafting copilot should remain simple if it fulfills the business need without the overhead of an autonomous multi-agent architecture.
[06:54](https://www.youtube.com/watch?v=LnRXxsviw7A&t=414s) Paradigm Shift: Validating Non-Agentic vs. Agentic Trajectories
The transition from non-agentic to agentic AI fundamentally transforms how system correctness must be evaluated. Non-agentic interactions follow a straightforward, linear paradigm: a prompt enters the system, and a response is generated. Evaluation in this paradigm relies on static comparisons against expected reference answers, evaluation rubrics, or human rating scales.
```mermaid
flowchart LR
accTitle: Non-Agentic vs Agentic Evaluation Trajectories
accDescription: Comparison between simple prompt-response validation and complex multi-step agent trajectory validation.
subgraph NonAgentic["Non-Agentic Evaluation"]
P1["Prompt In"] --> R1["Response Out"]
R1 --> V1["Compare vs Rubric / Reference"]
end
subgraph Agentic["Agentic Trajectory Validation"]
Plan["1. Plan"] --> Tool["2. Select Tool"]
Tool --> Obs["3. Observe"]
Obs --> Dec["4. Decide / Act"]
Dec --> Out["5. System Action / Output"]
end
```
In contrast, an agentic workflow executes a dynamic loop: the model constructs a multi-step plan, selects and queries external tools, observes intermediate outputs, makes intermediate decisions, and executes an action or state change. Because agent decisions compound across intermediate steps—especially in multi-agent environments—scoring only the final output is insufficient. Evaluators must audit the entire execution trajectory to ensure the agent selected the appropriate tools, provided valid parameters, interpreted intermediate observations correctly, and stayed within authorization limits. Trajectory-level visibility enables engineers to pinpoint the exact failure point when an execution goes off track.
[08:25](https://www.youtube.com/watch?v=LnRXxsviw7A&t=505s) The Core Operating Framework: Two Safeguards and Three Production Response Tiers
To operationalize safe deployments, Printz details the framework's mechanics across the deployment lifecycle. The dual safeguard structure separates pre-deployment validation from live production monitoring: pre-deployment tests establish baseline behavior against known test sets, adversarial edge cases, and trace-level trajectory checks, whereas runtime monitoring tracks unpredictable production traffic against that validated baseline.
A critical operational discipline is defining the three production response tiers in advance:
- **Tier 1 (Log)**: Standard telemetry recording inputs, trajectory traces, and model diagnostics that fall within normal parameters.
- **Tier 2 (Review)**: Automated flagging of borderline signals or anomaly spikes that require human or secondary-system investigation.
- **Tier 3 (Pause)**: Circuit breakers that halt autonomous tool execution or trigger human-in-the-loop intervention when signals cross predefined safety thresholds.
Printz stresses that response tiers must never be improvised while an incident is unfolding in production. Defining escalation criteria and operational thresholds up front ensures teams know exactly when to trigger a full system retest and redeployment versus an evaluation rubric recalibration.
[11:46](https://www.youtube.com/watch?v=LnRXxsviw7A&t=706s) Building a Comprehensive Test Portfolio and Neutralizing Indirect Injections
A traditional "golden dataset" of question-and-answer pairs is entirely inadequate for validating autonomous agents. Printz outlines the five components required to construct an enterprise-grade agentic test portfolio:
| Test Portfolio Component | Primary Evaluation Focus |
|:--- |:--- |
| **Golden Data Set** | Curated reference benchmarks verifying standard prompt-and-response accuracy. |
| **Optimal Path Set** | Validates execution efficiency: correct tool selection, valid inputs, and avoiding redundant steps. |
| **Hallucination Traps** | Tests model resilience against missing, ambiguous, contradictory, or overly precise prompt contexts. |
| **Adversarial Edge Cases** | Introduces environment complexity, tool/API failures, malformed data, and prompt injections. |
| **Regression Suite** | Captures real-world production failures and edge cases, integrating them permanently into CI/CD suites. |
Printz highlights indirect prompt injection as the ultimate proof that agent safety cannot rely on base model compliance. While user prompts may be benign and policy-compliant, malicious instructions frequently lurk inside retrieved external data, such as parsed PDFs, partner web pages, or tool outputs. System architectures must treat all external content as untrusted data rather than executable instructions. Organizations enforce this boundary using provenance tracking, rigorous injection testing suites, strict egress and action-gate controls, and behavioral anomaly monitoring to prevent unauthorized tool execution even if an injection slips past input filters.
[14:53](https://www.youtube.com/watch?v=LnRXxsviw7A&t=893s) Evaluation Triangulation and Calibrating LLM-as-a-Judge
No single scoring methodology provides a complete assessment of AI safety. Rather than averaging disparate metrics into an uninformative blended score, New York Life employs a triangulation strategy that leverages three complementary evaluation lenses:
- **LLM-as-a-Judge**: Fast, scalable, context-aware, and cost-efficient for large test suites, though requiring continuous calibration and monitoring to prevent drift.
- **Rule-Based Deterministic Checks**: Highly transparent, fast, and repeatable; ideal for validating structured outputs, required fields, formatting rules, and strict schema compliance.
- **Human Expert Review**: The essential standard for nuanced policy interpretations, ethical edge cases, and unexpected failure modes, though constrained by cost and throughput.
Because LLM judges introduce generative components into the evaluation layer, continuous calibration against expert human ratings is mandatory. When human reviewers and LLM judges disagree, it does not mean automated judging must be abandoned. Instead, teams use disagreements as diagnostic signals to tighten evaluation rubrics, refine few-shot scoring prompts, adjust decision thresholds, or constrain the judge's scope of evaluation.
```mermaid
flowchart TD
accTitle: Evaluation Triangulation and LLM Judge Calibration Loop
accDescription: Triangulated evaluation using three distinct lenses, including the calibration feedback loop between human review and LLM-as-a-Judge.
[17:12](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1032s) Diagnostic Response Checks and Business Usefulness Metrics
Printz details four parallel diagnostic checks applied consistently across both pre-deployment testing and live production monitoring:
1. **Context Relevancy**: Assesses whether the retrieval mechanism pulled the correct, necessary evidence from underlying enterprise indexes.
2. **Answer Relevancy**: Determines whether the generated response directly answers the user's explicit question, independent of whether the response is grounded.
3. **Groundedness**: Verifies that every material claim in the generated output is fully supported by the retrieved context, guarding against hallucinations or invented facts.
4. **Completeness**: Checks whether the agent addressed all facets of a multi-layered inquiry or omitted critical constraints.
These metrics act as parallel diagnostic vectors rather than a single aggregated number, allowing engineering teams to isolate root causes and apply targeted technical fixes:
However, Printz cautions that achieving high scores across all four metrics does not guarantee operational value: an answer can be grounded, relevant, and complete while remaining practically useless to an advisor. To bridge this gap, technical metrics must be paired with business usefulness signals, including end-to-end task completion rates, system and user override frequencies, manual retry patterns, structured end-user feedback, and routine qualitative sample audits.
[21:01](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1261s) Production Telemetry and Agentic Trajectory Auditing
In production, technical diagnostics and business value tracking are integrated with continuous operational monitoring. Teams track input and environment drift alongside core AI Ops metrics such as token consumption rates, execution latencies, and computational complexity spikes.
For fully agentic systems, Printz reiterates that trajectory auditing forms the ultimate foundation of production safety. System telemetry must log and monitor the complete chain of execution: which tools were selected, what specific input payloads were passed, how intermediate paths evolved across steps, and what concrete side effects or action outcomes were produced. Capturing these execution traces ensures organizations can proactively identify behavioral drift, enforce security boundaries, and intervene before anomalies compromise enterprise workflows.
[22:19](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1339s) Production Response Tiers and Granular Kill Switches
Trajectory monitoring in a multi-agent system is not strictly a pass-or-fail safety gate; whether a system follows a narrow, constrained path or navigates a wide variety of execution steps depends heavily on the specific use case. What matters is visibility: understanding where agent handoffs occur, which sub-agents are selected, and how to verify that execution patterns become predictable and repeatable over time.
```mermaid
flowchart TD
accTitle: Production Response Tiers and Mitigation Controls
subgraph Sigs["Signal Severity Tiers"]
M["Minor Signal<br/><i>(Small blip vs. historical baseline)</i>"] --> L["Log Event & Review on Predefined Schedule"]
Mod["Moderate Signal<br/><i>(Metrics outside normal variance)</i>"] --> R["Assign to Designated Domain Owner"]
Sev["Severe Signal / Compounded Moderate"] --> P["Trigger Isolation / Kill Switch"]
end
subgraph Scope["Granular Isolation Scope"]
P --> T["Pause Specific Tool"]
P --> A["Restrict Action Space"]
P --> D["Sever Problematic Data Source"]
P --> U["Disable for Specific User Cohort"]
end
```
Operating AI agents safely in production requires establishing clear operational playbooks ahead of time for when metrics drift or signals trip thresholds. When minor deviations occur relative to historical patterns, they are logged and tracked for regular, scheduled operational reviews. If moderate signals breach normal operating bounds, a designated owner investigates root causes. When severe anomalies arise—or multiple moderate signals trip concurrently—the system requires actionable pause capabilities. Rather than flipping an indiscriminate global kill switch, production environments require fine-grained isolation mechanisms that constrain specific blast radiuses.
- **Selective tool pausing**: Disabling an individual misbehaving integration without taking the entire agent offline.
- **Action space constraints**: Forcing high-risk operations to require mandatory human-in-the-loop approval.
- **Data source detachment**: Isolating corrupted or hallucination-inducing knowledge stores.
- **User cohort segmentation**: Pausing access for specific subsets of users while validating root-cause fixes.
---
[25:32](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1532s) Summary: A Production Governance Framework for Deployable AI
The complete framework establishes an enterprise governance layer that bridges pre-deployment verification and real-time operations. It organizes AI risk management across two primary safeguards, four core response quality checks, and three operational response tiers, augmented by trajectory tracking for autonomous multi-agent workflows.
| Framework Dimension | Operational Elements | Primary Objective |
|:--- |:--- |:--- |
| **Two Safeguards** | 1. Pre-deployment offline evaluation<br/>2. Real-time production traffic monitoring | Prevent regression before launch and catch runtime drift. |
| **Four Response Checks** | Groundedness, completeness, context relevancy, answer relevancy | Systematically evaluate output quality against retrieved sources and user queries. |
| **Three Response Tiers** | Logging (minor), owner review (moderate), pausing/isolation (severe) | Predefined operational escalation based on threshold violations. |
| **Agentic Trajectory Controls** | Handoff tracking, action space constraints, human approval gates | Govern multi-step reasoning paths and tool execution. |
These governance mechanisms do not replace the standard optimization and engineering roadmap—such as expanding feature sets or refining prompting logic—but they provide the essential control plane that makes AI systems safely deployable in an enterprise context:
> "None of those going to make the agent better, right? We often talk about how we make agent better performance... optimization road map... But essentially, this is the governance layer. It makes the agent deployable and safe."
---
[27:23](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1643s) Q&A: Tooling Ecosystem and Enterprise Semantic Layers
During the open Q&A session, Imran Chaudhry from Progress Software asked about the technology stack underpinning the framework, noting that no single commercial vendor covers all required evaluation, monitoring, and agent governance capabilities. Marina Printz confirmed that off-the-shelf, one-stop solutions do not exist for this breadth of requirements. Advanced enterprises inevitably rely on a bespoke composite architecture that integrates external software providers with custom internal tooling and orchestrations.
Chaudhry also inquired about the role of an enterprise semantic layer in improving agent accuracy. Printz acknowledged that semantic layers are actively under consideration as New York Life prepares for broader agentic rollouts, reinforcing that structured metadata and uniform semantic definitions are key components for high-accuracy reasoning in multi-agent environments.
---
[28:57](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1737s) Q&A: The Capability Layer and Enterprise-Wide AI Literacy ("Ignite AI")
Valeriy from BD Ecosystem asked about the capability layer on the organizational and people side. Printz connected the governance architecture back to New York Life's broader enterprise transformation framework, which is organized into three pillars:
1. **Empower**: Driving personal and individual workforce productivity.
2. **Elevate**: Deploying targeted point solutions delivering quantifiable ROI.
3. **Reimagine**: Pursuing domain-level business transformation.
To scale the "Empower" tier, New York Life has rolled out generative AI access across its entire workforce, distributing ChatGPT Enterprise to 12,000 agents and advisors as well as 12,000 corporate employees. Employees have access to Microsoft Copilot, while specialized cohorts—including engineering and data science teams—use Anthropic's Claude Chat and Claude Code.
```mermaid
flowchart LR
accTitle: Organizational AI Enablement and Literacy Structure
subgraph Enterprise["Enterprise AI Tool Deployment"]
C["ChatGPT Enterprise<br/><i>(12,000 Advisors + 12,000 Staff)</i>"]
M["Microsoft Copilot<br/><i>(Enterprise-Wide)</i>"]
A["Claude Chat & Claude Code<br/><i>(Specialized / Engineering Cohorts)</i>"]
end
subgraph Literacy["Ignite AI Enablement Program"]
U["End-User Enablement<br/><i>(Custom GPTs, drafting, summarization)</i>"]
S["AI-Enabled SDLC<br/><i>(Engineering workflows & code generation)</i>"]
D["Department Champions<br/><i>(Cross-functional AI adoption spearheads)</i>"]
end
Enterprise --> Literacy
```
To coordinate this transformation across business units, the enterprise established a comprehensive program called **"Ignite AI"** in partnership with Human Resources, Change Management, and Learning & Development. This initiative blends formal coursework, hands-on sessions, and departmental champions who showcase advanced techniques and lead adoption within their respective business domains.
---
[31:47](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1907s) Q&A: Traceability, Governance Speed, and Qualitative User Feedback
An attendee asked how traditional software engineering standards—specifically explainability, traceability, and repeatability—are upheld in an agentic setting. Printz explained that auditability is paramount in a heavily regulated financial services and insurance environment, where the AI governance program maintains formal oversight and reporting accountability directly to the Board of Directors. Every step in an agent's execution path must be preserved to satisfy regulatory requirements.
Rana from a fintech firm raised the operational tension between rapid model innovation and rigorous governance, asking how New York Life keeps pace with evolving user expectations and tool updates. Printz clarified that pure engineering metrics must be complemented by qualitative evaluation mechanisms:
- **End-user focus groups**: Conducting recurring sessions to capture shifting user expectations, pain points, and edge cases.
- **Service call listening**: Auditing live customer service interactions where agents use AI assistants to observe real-world operational workflows.
- **Continuous refinement**: Combining qualitative feedback loops with telemetry data to maintain system safety and agility as agent deployments scale.
## Notable quotes
> [25:32](https://www.youtube.com/watch?v=LnRXxsviw7A&t=1532s) None of those going to make the agent better, right? We often talk about how we make agent better performance... optimization road map... But essentially, this is the governance layer. It makes the agent deployable and safe. — Marina Printz
## Mentioned
Ai4, Anthropic, BD Ecosystem, ChatGPT Enterprise, Claude Chat, Claude Code, Ignite AI, Imran Chaudhry, Marina Printz, Microsoft Copilot, National Association of Insurance Commissioners (NAIC), New York Life, Progress Software, Rana, Valeriy
## Video description
Marina Printz - VP, AI and Data Science, New York Life
How do you know if GenAI answer is actually right, not just confident sounding? This talk covers how we evaluate and monitor GenAI in production. It gives a practical way to think about scoring and monitoring your own systems. Useful for anyone building or reviewing AI systems before launch.
Marina Printz, Vice President of AI and Data Science at New York Life, argues that deploying autonomous AI agents in regulated financial enterprises requires shifting evaluation from surface text generation to end-to-end trajectory governance and pre-planned operational safety controls.
Regulatory Demands and Multi-Tier Strategy (2:44)
Operating across 12,000 agents and advisors in life insurance, wealth management, and long-term care, New York Life's automated workflows cross multiple trust boundaries. Flawed outputs risk advisor confusion, compliance vulnerabilities, or unauthorized state changes. Heightened scrutiny, including the NAIC AI governance bulletin adopted in 24 states, requires documented testing protocols, guardrails, and direct Board-level reporting.
To balance adoption and risk, New York Life categorizes AI deployments into three capability tiers: Empower (broad personal productivity tooling), Elevate (custom point solutions delivering measured ROI), and Reimagine (autonomous domain-level redesigns). Printz cautions that every deployment requires strict cost-benefit analysis, noting that simpler non-agentic copilots should be maintained whenever they satisfy business requirements without unnecessary architectural overhead.
Trajectory Auditing and Test Portfolio Rigor (6:54)
Because agentic systems iteratively plan, query external tools, observe results, and execute actions, validating only the final output is insufficient. Evaluators must audit the entire multi-step trajectory to verify appropriate tool selection, valid parameters, and compliance with authorization boundaries. Tracing these intermediate paths allows engineers to identify specific failure points before compound errors affect downstream workflows.
Traditional question-and-answer benchmarks are inadequate for autonomous agents. Printz specifies an expanded test portfolio consisting of five components: golden data sets, optimal path sets for execution efficiency, hallucination traps, adversarial edge cases, and regression suites integrated into CI/CD pipelines. Treating retrieved external data as untrusted instructions is essential to defend against indirect prompt injections hidden in PDFs, web pages, or tool outputs.
Triangulated Scoring and Parallel Diagnostic Checks (14:53)
Rather than relying on a single aggregated score, New York Life triangulates evaluation across three distinct methods: LLM-as-a-judge for contextual scalability, deterministic rule-based checks for structured schemas, and expert human review for policy edge cases. Discrepancies between human experts and LLM judges serve as diagnostic signals to tighten rubrics and prompt calibrations rather than discard automated scoring.
Both pre-deployment validation and live monitoring evaluate four parallel diagnostic metrics: context relevancy, answer relevancy, groundedness, and completeness. Pairing these vectors isolates technical root causes; for example, high context relevancy combined with low answer relevancy signals prompt synthesis failure rather than an indexing defect. To ensure operational value, technical diagnostics are further paired with business usefulness metrics such as task completion rates, override frequencies, and structured user feedback.
Operational Telemetry and Predefined Escalation Tiers (22:19)
The operating framework enforces two structural safeguards—offline pre-deployment evaluation and continuous runtime traffic monitoring—coupled with three predefined response tiers. Rather than improvising during incidents, teams pre-agree on thresholds for Tier 1 logging, Tier 2 review by designated domain owners for moderate deviations, and Tier 3 circuit breakers for severe or compounded anomalies.
When anomalies breach safe limits, mitigation relies on granular containment rather than broad system shutdowns. Operators can selectively pause a single failing tool integration, restrict action spaces by enforcing mandatory human approval on high-risk steps, detach corrupted knowledge bases, or isolate access for specific user cohorts while fixes are deployed.
Enterprise Literacy and Organizational Enablement (28:57)
Governance controls operate alongside broad workforce enablement. New York Life deployed ChatGPT Enterprise to its 12,000 agents and 12,000 corporate staff, rolled out Microsoft Copilot broadly, and provisioned specialized engineering teams with Anthropic's Claude tools. To coordinate adoption across units, the enterprise established the 'Ignite AI' program in partnership with HR and Change Management, combining structured coursework, hands-on sessions, and departmental champions.
Printz emphasizes that while trajectory auditing, response tiers, and governance layers do not directly optimize core model capabilities, they form the non-negotiable control plane that makes autonomous AI deployable and safe in regulated enterprises. In response to Q&A inquiries, she noted that off-the-shelf software remains incomplete, requiring bespoke composite architectures and potential enterprise semantic layers to maintain auditability and data consistency.
[25:32] Marina Printz: None of those going to make the agent better, right? We often talk about how we make agent better performance... optimization road map... But essentially, this is the governance layer. It makes the agent deployable and safe.
Original transcript
[0:04] Good afternoon, everyone. Uh I'm Marina Prince.
I'm vice president of AI and data science at
[0:09] New York Life, and I'm wondering, right,
if we should have started drinks at 4:00.
[0:15] Maybe [laughter] it would have been a little bit
more people, but nevertheless, looking forward
[0:21] to sharing with you some of my um experiences and
also how I look at the things going forward. Maybe
[0:28] we can start with a little bit thought experiment,
not just about, you know, 5:00 drinks, but what
[0:35] does it mean around deploying agentic system?
So, we're thinking about agentic system that
[0:41] can retrieve information, choose a tool, take an
action on someone's behalf, like draft a message,
[0:48] or maybe update a record, or maybe complete the
request, right? When we do a prototype, things
[0:55] look impressive very quickly, and that's the
intent of the prototypes. They do what they need.
[1:00] But then, when we are moving from prototype to
deploying, and then deploying actually at scale,
[1:07] and then system is considering to choose the tool,
and read external content, and update a workflow,
[1:14] or prepare an action, it's no longer did we get
the correct answer, but have we gotten there
[1:21] safely, correctly, and within our policy? And how
will we know if something changes? So, it might be
[1:30] that all these paths held so far, but it's no
longer going forward. The experiences I'm going
[1:36] to share here is a mixture of evaluation
frameworks that we've already deployed,
[1:42] and then how we are thinking going forward in
terms of agentic systems at scale. I'm going
[1:48] to introduce a practical operating framework that
can help us to move from prototypes to production.
[1:56] While we are thinking about that framework.
It's going to be consist of two safeguards,
[2:02] four response checks, and then three production
response tiers. And the main idea is evaluate
[2:11] before deployment, monitor once we go live, and
decide in advance what happens when signals cross
[2:22] or go above predefined thresholds. And this is not
about each foundational models wins if this models
[2:29] better or that model in terms of the benchmarks.
Models change, but we need to make sure the system
[2:36] contains regardless of how underlying models
evolve. Why it's very important especially for us?
[2:44] New York Life it's a life insurer and financial
industry solutions provider, and we operate in
[2:51] a regulated environment. We are B2B2C model. The
company supports a nationwide network of 12,000
[3:01] agents and advisors that offer professional
services across a broad range of financial
[3:07] products, including life insurance as our name
suggests, but also annuities, wealth management,
[3:14] long-term care long-term care, and other related
financial services. And that means AI systems that
[3:21] we are talking about here never or very rarely act
in isolation. That system may support an employee,
[3:30] an agent or advisor, or process that connects
the two, right? And then that will cross multiple
[3:36] trust boundaries that is very important for us to
maintain. And why it matters? Because the error
[3:43] will not only be a bad answer on the screen that
someone can catch. It can create a question or
[3:49] concern or rework for an advisor or change in
the system. It happened in every industry and
[3:56] in every trade, but in insurance financial
industry, it is especially important. So,
[4:03] what happens is National Association of Insurance
Commissioners NAIC, earlier this year adopted
[4:11] already 24 states adopted the framework that is an
increasing regulatory expectation that we require
[4:20] to maintain documented AI governance pro- program
with responsibility of reporting to the board.
[4:29] And then everything should be documented
including testing errors, testing protocols,
[4:36] and everything in between. So, essentially that
operating framework that I'm going to talk about
[4:42] can be a good infrastructure to support that
governance layer, and it can provide necessary
[4:50] um um necessary I guess like evidence, whatever
we're going to need to produce. So, with that,
[4:56] let me talk a little bit more of what capabilities
will need to happen in order for this program to
[5:02] happen. So, we can think about AI at three levels,
and this is essentially what you see on the screen
[5:08] is our AI strategy within New York Life.
Empower is broad access. We We have tools
[5:15] that help people to work more productively across
local use cases. And then elevate is targeted.
[5:23] We have custom solutions that produce measurable
business outcomes, and reimagine obviously is
[5:29] transformative. We are talking about domain
level reimagine or redesign that builds towards
[5:35] enterprise intelligence. And that's not just
the technology tiers, right? What type of tools
[5:41] support different different tiers here. We are
talking about increasing complexity of how those
[5:48] systems are integrated into business process,
what gets rely what is relying on enterprise data,
[5:55] and then obviously where increasing autonomy
happens. So, and use cases become more objective,
[6:03] validation will expand from just hey, let me make
sure the response is correct to was the action
[6:10] done correctly and within appropriate guardrails.
So, not necessarily all the use case going to
[6:16] require that full autonomous reimagine. It's still
everything is cost benefit at the end of the day,
[6:23] and if you case justified with a simple copilot
agent, let it be, right? Because not necessarily
[6:29] every summarization or document drafted requires
full autonomous um system. So, it's not excitement
[6:37] about technology one way or the other. It's really
a very uh strict thought process of what should
[6:44] be the right tool for the right program. So, that
brings me to the first point. How as we move from
[6:54] non-agentic to agentic, it really changes
how we are thinking about the interaction.
[7:00] So, when we are talking about non-agentic world,
it is pretty simple. We get prompt in and the
[7:07] answer goes out. So, we can compare an answer
to expected outcome, rubric, or human rating,
[7:14] and that's how we validate things. But,
agentic workflow is much more complex.
[7:19] There is a plan. Agentic system will plan, then
retrieve necessary tool, observe what happens,
[7:28] make a decision, and then produce an outcome.
The outcome might still be an answer, but it
[7:34] might be changing the system, it might be an
action, or it might be a downstream implication,
[7:41] especially if we are talking about multi-agent
system. So, correct answer validation is no longer
[7:47] enough. We need to make sure that agent chose
the right tool. It made an authorized action.
[7:54] It interpreted the observation correctly. And
then we also need to know where to pause in case
[8:01] something goes wrong. So, we need to validate not
just the final outcome, but the entire trajectory.
[8:08] How we arrived to that final response. It's
not just a validation check. It's also a way
[8:14] to us to know what happened in between. So, if
anything needs to be course course corrected,
[8:19] we know how to act. So, once those validation
target expands, that's where the framework
[8:25] comes in. So, I want to introduce this framework.
It's relatively simple as I'm thinking about it.
[8:33] Uh we are talking about two safeguards. We need
to evaluate things before we go into deployment.
[8:41] And then we monitor the production system after
we go live. So, that's the two safeguards. Second,
[8:48] we have four response check. And those apply
both as evaluation happens pre-deployment and as
[8:56] monitoring happens on the production traffic. And
the four response checks are answer relevancy,
[9:04] context relevancy, groundedness, and completeness.
Those are good old friends right like so to speak
[9:10] from the GNI and those are still very very
relevant. Lastly, when we are in production,
[9:17] we need to decide on the response tiers. What
should be logged and what is the threshold
[9:24] from logging to reviewing? And ultimately, what
is the threshold from reviewing to the to the
[9:30] pausing? And that is very important. This is not
something that things are already in production
[9:35] and we are observing things are happening. oh,
how should we ask? All of those response tiers,
[9:41] when we are talking about production environment,
should be decided up front. So, evaluate before
[9:48] deployment, monitor when we go live, and then
respond when signals surpass predefined threshold.
[9:56] So, the four those four checks are not the
complete evaluation system. This is in addition,
[10:02] when we are talking about agents and multi-agent
systems, we also monitor for trajectory,
[10:08] or we will need to monitor for trajectory, and
I'm going to introduce it later. So, with that,
[10:13] let's talk about the first idea, why there
are two safeguards and not one safeguard.
[10:19] Okay, we are talking about pre-deployment test,
and those obviously test for things that we can
[10:26] expect, right? We know what to look for. However,
production monitoring monitors production traffic,
[10:33] and then we know in reality what users ask, or
what the system um did. Plus, there is a change
[10:41] in the environment. So, before we deploy, there is
known questions and answers, right? There's like
[10:48] known test cases, we also have adversarial cases,
we have trace level scoring to determine whether
[10:55] specific version is doing things correctly, but
then, after we go live, we compare live simple
[11:02] live signals with validated baseline. So, we also
want to make sure we separate the system changes
[11:10] and evaluation changes, right? And how it gets
reflected. System changes might be changes in the
[11:18] uh in in in the model, right? In the tools, but
on the evaluation side, the more the underlying
[11:26] data set or a rubric can change. And then,
depending on that, we need to make a decision.
[11:32] Do we do full retest and then redeploy or do we
just do recalibration? And that also matters a
[11:39] lot. Obviously, different things require different
treatments. So, with this life cycle in place,
[11:46] let's talk about the first practical question
is how do we get that test portfolio? We used
[11:52] to talk in the gen AI space about golden data set,
which is obviously important, but that is not it.
[12:00] In addition to the golden data set, there are
few other components that are very important as
[12:05] we are thinking about the comprehensive testing
set. We have optimal path set, so whether the
[12:12] agent uses expected tools and which tools it's
supposed to do. Was it supplied the right inputs?
[12:19] Did it avoid redundant steps? Hallucination traps,
as the name suggests, we are testing for missing,
[12:26] potentially contradictory, or maybe overly precise
evidence. We have adversarial test and that's
[12:33] where we introduce ambiguity, complexity, tools
failures. And then, once system is live, there
[12:41] is regression sets. So, any actual failures in the
production, once those are corrected and acted on,
[12:48] we can add them back to the permanent data set
that we're going to be continuing and testing
[12:53] against. So, this is the full agentic
workflow. We score for the trajectory,
[12:59] not just for the final answer, and that's
why the golden data set is no longer enough.
[13:05] With all that, I want to double-click on
one adversarial category, which I think
[13:10] is very important. I want to talk about
data, right? And how data is no longer
[13:18] uh and and the content, apologies, and how content
uh is data point, it's not an instruction. We talk
[13:25] about a lot about prompt injection. I'm sure
you guys heard about it. And this is one of the
[13:32] clearest examples of why agent safety cannot
depend on the model behaving. So, a user may
[13:39] ask a benign question, right? Something very,
very specific within the predefined guardrails.
[13:46] But then, the malicious injection can come
maybe from a document, maybe from a webpage,
[13:52] or maybe from a tool output. So, it's no longer
something in the prompt that we can control
[13:58] for. This is how the architecture of the entire
solution should be designed that we know how to
[14:06] treat that external content as untrusted data and
not just explicitly add on. And those control will
[14:14] bound consequences. So, we have prevalence labels.
We have injection testing. We have egress and
[14:21] action gates and anomaly monitoring that all of
those help us in tandem to evaluate if something
[14:30] goes wrong. So, objective here is not to claim
that every injected instruction can be detected.
[14:38] But if something like that happens, we know how
to prevent unauthorized action. And that's what's
[14:45] most important here. So, once we've constructed
test portfolio, let me talk about the evaluation
[14:53] evaluation program. How we actually think about
evaluating those across the five components of
[14:59] the test portfolio that I've mentioned. LLM as a
judge is fast, it's context aware, it's scalable,
[15:07] it's relatively cheap compared to probably
human review that I'm going to mention later.
[15:13] However, the limitation is that it needs to be
calibrated and constantly monitored. Essentially,
[15:20] we're introducing another GNA component into the
system. Rule-based is amazing, and where it works,
[15:28] I absolutely recommend to use it because it is
transparent and it is deterministic. However,
[15:35] it doesn't fit for all the checks. It's
good if we're talking about exact values,
[15:40] we have our required fields, formats, etc.
Anything that can fit into the structured format.
[15:48] Human review is the last one. It's best
for the most complex, most nuanced check
[15:54] when we need policy interpretation, when we
need unexpected failure mode. But obviously,
[16:01] it is uh pretty expensive and hard to scale. So,
the idea is not let's test across all the three,
[16:08] let's average it out, come up
with a blended score, and use it.
[16:12] Absolutely not. Those are different components of
triangulation, and each of those pillars or lenses
[16:19] going to catch something that others may not. I
talked a lot here about LLM as a judge. Obviously,
[16:26] it has huge advantages, and we all pretty
mastered it at this point. But what I want
[16:33] to double-click on is the calibration, and that's
what I've mentioned before because it is part of
[16:40] AI solution. We need to make sure we calibrate it
going forward. So, this is how calibration going
[16:46] to work. We're going to calibrate it relative
to the human when evaluation. If both agree,
[16:52] great. But if they disagree, it doesn't mean
oh, that's it, we can't use LLM as a judge.
[16:58] It just requires more tightening, maybe stronger
rubric, maybe different threshold, or maybe
[17:05] changing that evaluation scope. And that's how we
going to continue and monitor it going forward.
[17:12] So, with that, the scoring system is calibrated.
We talked about three lengths, and now we have
[17:19] those share response check before deployment
and then monitoring the traffic as we go live.
[17:27] I've introduced those four checks before as part
of the framework. We have those four checks and
[17:33] those are shared across before deployment
and as we go live. Context relevancy, did we
[17:40] receive the right evidence? And that's primarily
retrieval, right? And source selection question.
[17:46] Answer relevancy, the retrieval might be correct,
but the response but we maybe didn't answer the
[17:53] question, right? That was asked. So, response
can be grounded, but it's not necessarily the
[17:59] question that was asked. The groundedness itself,
did we produce sufficient evidence to support any
[18:07] material claim that comes with that answer? And
that's where it can be some invented details,
[18:14] some part of hallucinations that goes beyond the
source. Lastly, we are talking about completeness,
[18:21] and that is especially important if the question
is complex or maybe multi-layered question.
[18:27] We might be answered for a certain part of the
question, but not entire span. Now, those are
[18:33] parallel diagnostic. It's not again like one
composite score because different different
[18:41] different response checks may help engineers to
start detecting what exactly needs to be tightened
[18:48] in the agent or in agentic framework to make
sure it's performing properly. So, these are
[18:56] few examples. If we for example, we ended up with
low context and low answer, what it may point to
[19:06] there's an retrieval problem or maybe there's
insufficient indexing it. Uh in in insufficient
[19:12] evidence. So, how should it be fixed? Potentially,
we can start with re-indexing or maybe changing
[19:18] the source coverage or maybe reconstruct the
query. If we have high context relevancy,
[19:25] but low answer relevancy, then we do have the
right evidence, but then the synthesis failed.
[19:31] The way to address it is maybe to intervene in the
prompt or how the tools interact with each other,
[19:38] the orchestration or the generation step.
There are few examples there. Obviously,
[19:43] that's not everything, but essentially, those
four response checks in tandem can point engineers
[19:51] where the root cause might be and how it should be
addressed or at least starting on the right track.
[19:58] What I want to make sure that we are not
thinking about those as just, "Oh, let's
[20:04] report those in the dashboard." Right? Because
we can hit all of those four metrics correctly,
[20:11] yet still from a user perspective, the response or
the action is not useful, right? So, the business
[20:21] usefulness is extremely important at that as
well. And you can't measure it with groundedness
[20:28] or answer relevancy or response relevancy.
So, essentially, what we are talking about is
[20:34] we're going to look at the task completion, we're
going to do at look at retries or overrides,
[20:40] whether it's by the system or what's more
important by the user. Ideally, also, we
[20:45] gather user feedback, and then they're absolutely
necessary to do sample reviews. Both going to help
[20:54] us to cover the correctness and the performance
of the system in addition to business usefulness.
[21:01] Okay. So, once we're in production, in
addition to those, there are a couple of other
[21:08] uh components that are very important for us
to monitor. And those signals are probably the
[21:13] last two. We are talking about the drift in the
input and the environment, and we are obviously
[21:19] talking about the AI ops, right? The tokens,
the complexity, and everything in between.
[21:25] And then, what it gives us in tandem is the
correct response layer. It's how we going to
[21:32] monitor it and the decision and the response
layer in production comparing to the baseline,
[21:39] assigning next action, or flagging when
some of the thresholds surpass. Okay.
[21:47] Now, let's make it a little bit more complex,
and I want to talk about agentic systems. So, we,
[21:55] in addition to what I've already covered before,
what is really, really important is trajectory.
[22:04] And trajectory will signal what change, right?
What tools were called and selected, what input
[22:10] went to the tools, what was the path, and how that
path evolved, and what was the action outcome.
[22:19] And it's not necessarily that won't be won't very
narrow path, or we want like a wide variety of
[22:24] passes. Those can indicate very different things,
and it's not necessarily safe safety decision. Oh,
[22:31] you have very narrow path, that that's why
the system is safe. And you can proceed, or
[22:36] the path is very uh very variable. It's really an
indication for a multi-agent system. How we want
[22:44] to look at it, where where the handles are, which
agents are selected. So, in essentially, it's just
[22:50] another tool of how we monitor, and then
how behavior becomes more repeatable.
[22:58] Okay.
[23:00] That brings me to the last part of the framework.
We We talked about two safeguards, four um
[23:09] four response levels, and then three response
tiers. So, once we are in production, we need
[23:15] to make a decision ahead of time. Oh, apologies.
What's going to happen if something goes wrong?
[23:22] When minor signals are off, it can
be a small blip, right? Something
[23:28] happens or a movement relative to historical
patterns. Obviously, we need to document it.
[23:35] And then there should be a predefined schedule
how things are reviewed, and that's where that
[23:41] uh that logging going to be reviewed. When
moderate signals are outside of the norm,
[23:48] there should be an owner who's going to look into
it. And obviously, with severe signals, there
[23:53] should be an ability to potentially pause and then
change the action path. Now, severe is one thing,
[24:02] but there can be a couple of moderate, right?
Like signals that can go off, and maybe a couple
[24:09] of moderate going to require certain actions as
well. So, it's not necessarily very, very linear.
[24:16] It really should be looked at it more uh
holistically. So, once those response tiers work,
[24:23] and then we have a safe system, that's where
the high-risk agents come in. And for high-risk
[24:31] agents, the controls must be built in, and then
in addition to obviously, you know, constraining
[24:38] the action space and requiring human approval, we
are talking about disabling and recovering or what
[24:44] often times it refers to is kill switch. And kill
switch is not necessarily, let's put everything on
[24:51] pause. There should be an ability to isolate, and
it might be putting a pause on a particular tool,
[24:58] on a particular action, potentially on a data
source, or even certain segment of users. And
[25:05] that's where going back why all of those outcomes
and they mentioned the variety of those across
[25:11] trajectories and across response qualities are
important because it can help us to understand do
[25:17] we really need to put a pause on the entire system
or other certain components or user segments,
[25:24] user groups that can be put on pause until we
validate and then we decide what to do next.
[25:32] Okay. So, that I guess like encompasses
everything. We are running pretty good on time,
[25:38] but I still I want to summarize. I've introduced
here a framework that talks about two safeguards.
[25:45] One is before we go live, how we evaluate, and
then the second part is how we monitor production
[25:52] traffic. We talked about four core response checks
in addition to monitoring the trajectory of an
[26:00] agent or an energetic system. And those four
response checks are groundedness, completeness,
[26:07] context relevancy, and answer relevancy. And
then we talked about three response tiers
[26:14] for the system in production. When signals
cross the threshold, what should we do? Logging
[26:20] if it's minor, if it's moderate, we're going to
review with the assigned owner and then pausing.
[26:27] And then as I mentioned already the trajectory
for agents that act, we're going to need to
[26:32] build those controls as well. So, evaluate before
deployment, monitor with live production traffic,
[26:39] and then respond with those predefined threshold
and signals. And none of those going to make the
[26:46] agent better, right? We often talk about how
we make agent better performance, Obviously,
[26:52] talking optimization road map. Let's add more
features. Let's add more complexity. This is very
[26:58] important. But essentially, this is the governance
layer. It makes the agent deployable and safe.
[27:07] And with that, I want to thank you. And we have
a little bit time for questions or if anyone
[27:12] wants to share their experiences, I would
like to hear from you as well. [applause]
[27:23] So, this is Imran Chaudhry from Progress
Software. Um you you covered a lot of ground.
[27:30] You talked a lot about a lot of functionality. I
don't know of any one software package that does
[27:35] all of the things you said. So, I I assume you're
rolling your own or you're using multiple vendors
[27:41] simultaneously. Like everyone else. Absolutely.
Absolutely. There's There's no single one
[27:48] There's no single There's no single solution.
I actually talked to few folks earlier today,
[27:54] not just in the in the exhibit hall, but
actually attendees. Yeah. Some of them more
[27:59] advanced companies, they already have their
own AI platforms with a lot of that control
[28:05] built in. But it's still it's it's never going to
come from a single tool. So, it's going to be a
[28:11] lot of I don't want to call it home grown because
you're still relying on um external providers,
[28:17] but it's it's a combination, right? It's like more
of the ultimately bespoke solution rather than
[28:23] something that's going to come off the shelf. That
That's a great call out. Sounds good. And then the
[28:28] other question that I have is I didn't see um any
kind of an enterprise semantic layer in there, but
[28:35] that seems to really help uh get get your accuracy
for your AI agents up. Have you considered that?
[28:42] Enterprise Say it again. Enterprise semantic
layers. Yep. That's That is something that
[28:48] we are considering. Again, like we don't have
yet full agentic systems in production as I've
[28:52] mentioned before, but yes, this is something that
we need Thank you. to consider. Uh thank you for
[28:57] presentation. My name is Valeriy. I'm from BD
Ecosystem. So, you very good described there
[29:05] mostly governance layer of agentic, let's say,
development and production. What about the
[29:14] capability layer? What you are doing on the people
side? Yep. This is This is a great question. So,
[29:22] maybe I'm going to reflect back to the
enterprise strategy, right? We had there empower,
[29:27] which is end user individual productivity. We have
elevate, which is the targeted use cases ROI, but
[29:35] we are talking about, you know, point solution,
right? So to speak. And then the reimagine,
[29:40] which is, you know, domain level transformation.
So, the importance of empower comes on many,
[29:46] many different layers. And that's That's the
biggest one is AI literacy and making sure
[29:52] everyone understands. We have 12,000 agents.
We have actually deployed ChatGPT Enterprise
[29:59] to all of our agent and advisors and to 12,000
employees as well. Also, all of our employees have
[30:06] Microsoft Copilot and we have I don't want to call
it limited, but somewhat scoped and segmented um
[30:16] uh segment of employees that also have Claude,
which can be, you know, Claude chat or Claude
[30:22] code actually for developers, right, in my team.
And that is part of AI literacy. Now, AI literacy
[30:29] comes into two, probably, like most important
things from my perspective. There is the end user
[30:35] and that's what, you know, they're building their
custom GPTs. They're learning how, you know, draft
[30:40] draft a letter, summarize. A lot of those, you
know, day-to-day productivity that we don't
[30:45] need to build the full agentic system. But then,
there is the SDLC, right? And the AI-enabled SDLC,
[30:52] which is critical for the engineering team.
And that's part of, you know, a different angle
[30:58] to AI literacy. And in addition to tools, it's
actually an enterprise-level problem program
[31:05] in collaboration with human resources, with with
change management, with learning and development.
[31:11] We call it ignite AI. So, there is like different
sessions and core course works. And we have
[31:18] um our um folks who are probably, you know,
more advanced, and then they're showcasing.
[31:25] We have representatives from all the groups,
and they're more like spearheading AI adoption
[31:31] in their departments. So, it is it is a massive,
and it is multi-layer transformation. So,
[31:37] I'm I'm I'm really glad you asked that. I kind of
didn't want to talk about that angle because it
[31:42] takes us away from the core engineering talk,
but yes, absolutely. I think the one row same
[31:47] all questions, right? [laughter] So, in
the agentic world that you're talking
[31:52] about deploying in productions, I know there is
this concept about explainability, traceability,
[31:59] and repeatability, and all those things, the
software engineering principles, right? How are
[32:02] you ensuring those principles are being adhered
to in this agentic world also? Is that framework
[32:08] ensuring that it's capturing all that? Yep. Yep,
there's absolutely that. And that is important
[32:14] both from an end-user perspective, and as we are
building that, and, you know, what traces we have.
[32:19] There's also auditability, right? That we need to
make sure, especially again, what I've mentioned,
[32:24] we are in highly regulated environment. And um
the the uh document that they are governance pro
[32:32] pro program that uh we stood up with, you know,
reporting responsibility to the board. Yes,
[32:38] all of that is important. Thank you. Sorry, I
have one question. Uh this is Rana. I actually
[32:43] come from a fintech. Um so I have questions
around like um I know that you discussed about
[32:49] all the governance framework, but we know that AI
is rapidly shaping up. And we know that, you know,
[32:55] people say that uh with governance it's difficult
to, you know, uh to keep the speed with the AI. So
[33:02] what do you do about uh when the users' feedback
are changing, right? The tools are changing.
[33:08] Um where do you then how do you see the challenges
with this governance framework? So on the agentic
[33:15] side, we're probably going to need to see, right,
once the full agentic system's going to go live,
[33:21] but we have, you know, a few single agents already
in production, and the user feedback may change.
[33:26] And in addition to, again, the engineering aspects
that I covered here, we also do focus groups
[33:33] with end users, right? To identify what goes well,
what goes not. Um what what doesn't go so well. Or
[33:42] I'll give you another example. We have an AI
agent which is assistant to our service reps.
[33:47] So sometimes we're going to go and listen to
the calls, right? And see how they've actually
[33:51] used that agent, and that helps us to trace. So I
don't think there's like a complete engineering,
[33:58] you know, foolproof. There's a lot of other
little bit more qualitative assessments that
[34:03] needs to happen, and again, I'm just sharing from
like my experience uh how we're going about it.
[34:09] The The challenge going forward is as it
scales, how we make that more scalable, right?
