Ron Dagdag
Microsoft MVP / Research Engineering Manager @ Thomson Reuters
Fort Worth, Texas, United States
Actions
Ron Dagdag has spent 25 years figuring out which tool fits the problem. Today he leads AI research engineering at Thomson Reuters and builds agentic systems that hold up in production — not just on stage. He's been a Microsoft MVP since 2017 — recognized today in Web Development and Microsoft Foundry, previously AI, Mixed Reality, and IoT. He speaks internationally, organizes community events across DFW, and keeps a side stack of sensors, robots, and half-finished ideas. He tinkers. He teaches. 🛠️ Code > Create > Coach > Repeat.
Badges
Area of Expertise
Topics
Tracing Agents in Production with OpenTelemetry
Your agent passed every test and shipped. Two weeks later, someone asks why it approved something it should not have—and the logs cannot explain the decision. Infrastructure monitoring says the service was healthy, but a black box made the wrong call.
Traditional telemetry—latency, error rate, and uptime—shows whether an agent is running. It does not show which context it received, which tools it called, how much each step cost, or where a multi-step decision drifted. This talk builds an agent-observability layer from the ground up with OpenTelemetry. A live failure moves from mystery to trace: instrument the reasoning boundary, capture tool calls and handoffs, correlate cost and latency, and follow the decision to its root cause.
Attendees will leave able to distinguish infrastructure monitoring from agent tracing, instrument an agent pipeline, troubleshoot a failed decision, and define the minimum observability required before an agent reaches production.
Audience: Engineers and technical leads operating agent systems in or near production.
Format: 60–75-minute technical talk with a live tracing demonstration.
Demo: Microsoft Agent Framework on Azure instrumented with OpenTelemetry; concepts transfer to other runtimes.
Evidence: New session; currently in evaluation for Visual Studio Live! Las Vegas 2027.
Materials: Talk-specific repository, slides, and recording are not yet published.
Vendor scope: Vendor-neutral observability model with a Microsoft implementation.
Levels of Agent Autonomy: A Framework for Permissions and Control
Every agent system decides how much can happen without a person, but many teams never make that decision explicitly. They default to one of two extremes: approve every step or let the agent run freely. Neither is right for every task.
This talk introduces five autonomy levels—operator, collaborator, consultant, approver, and observer—and treats autonomy as a per-task design choice rather than a platform-wide setting. In a live refund-approval demo, the same request runs at three levels. The comparison exposes what changes in speed, permissions, evidence, recovery, and the cost of a mistake.
Attendees will leave able to explain the five levels and their tradeoffs, match autonomy to a task’s risk profile, design permission and approval boundaries, and identify where an existing agent is over- or under-autonomous. The goal is not maximum autonomy; it is deliberate, observable control.
Audience: Engineers and engineering leaders designing agents that can take actions.
Format: 60–75-minute framework talk with a live comparative demo.
Demo: One refund request executed at three autonomy levels with different permission, evidence, and approval boundaries.
Evidence: New session; currently in evaluation for Visual Studio Live! Las Vegas 2027.
Materials: Talk-specific assessment worksheet, repository, slides, and recording are not yet published.
Vendor scope: Vendor-neutral design framework.
Processing Documents, Audio, and Video with Azure Content Understanding
Business workflows rarely arrive as one clean document. A case may contain a PDF form, scanned evidence, a call recording, screenshots, and a video clip. The challenge is not producing a summary; it is extracting structured data with enough evidence and confidence to drive a real process.
This session builds one end-to-end case-intake pipeline in C# with Azure AI Content Understanding. We define a reusable schema, submit multimodal content to an analyzer, collect structured results, validate required fields, apply confidence gates, redact sensitive data, and route uncertain results to human review. Brief comparisons show when Document Intelligence or a custom LLM pipeline is the better fit.
Attendees will leave able to model a multimodal extraction schema, implement the analyzer workflow, design confidence and review boundaries, and choose the appropriate Azure service based on content type, customization, cost, and operational risk.
Audience: Engineers, data practitioners, and architects building production content pipelines.
Format: 45–60-minute Azure-focused technical talk with live C# demonstrations.
Demo: A multimodal case file processed through schema extraction, validation, confidence gates, PII handling, and human review.
Evidence: Previously delivered at AI Community Day on December 5, 2025 as a 45-minute session.
Materials: Talk-specific repository, slides, and recording are not yet published.
Vendor scope: Microsoft-specific; uses Azure AI Content Understanding and compares adjacent Azure services.
From Vibes to Specs: Choosing the Right AI Coding Workflow
AI can sketch a working feature from a conversational prompt. That vibe-coding style is fast and useful for exploration, but it becomes risky when the result must survive security review, changing requirements, and a team that did not share the original conversation.
This session builds the same feature three ways. First, we use vibe coding for a quick spike. Next, we add context engineering: repository instructions, domain documentation, API schemas, examples, and tool permissions. Finally, we make the work spec-driven with explicit contracts, acceptance criteria, tasks, tests, and CI gates. The comparison shows where each workflow saves time, where it creates hidden work, and when moving to the next level is worth the cost.
Attendees will leave able to choose a workflow based on risk and lifecycle, design useful context for an AI coding tool, and create a lightweight specification that produces reviewable code instead of an impressive but ownerless demo.
Audience: Developers and engineering leads adopting AI coding workflows.
Format: 45–60-minute technical talk with one feature implemented three ways.
Demo: Vibe-coded spike → context-engineered revision → spec-driven pull request with tests and CI checks.
Take-home artifact: Workflow decision matrix and specification/checklist templates; talk-specific package is not yet published.
Evidence: Submitted to six conferences; prior NDC Sydney submission was withdrawn.
Vendor scope: Vendor-neutral workflow; examples can be demonstrated with common AI coding assistants.
How to Test AI Features Before Your Users Do
LLM-powered features often succeed in demos and still fail in production. A prompt change, model upgrade, or retrieval tweak can quietly reduce answer quality, break grounding, or introduce risky behavior. This talk shows engineers and tech leads how to build a practical eval loop for AI features using the same mindset they already bring to testing software.
Using an anonymized internal knowledge assistant as the running example, we will start with a small app that appears to work, then expose three realistic failure modes: unsupported claims, missed key information, and brittle behavior after a change. From there, we will build a lightweight eval suite that turns those failures into repeatable checks. The demo covers a compact golden dataset, simple scoring patterns, and a regression workflow for prompts, models, and retrieval changes.
Attendees will leave able to distinguish benchmarks from application evals, compare pass/fail, rubric, and pairwise scoring, create a small but useful eval dataset, and diagnose whether a failure came from retrieval, generation, or system design.
Audience: Software engineers and technical leads building LLM or RAG features.
Format: 45–60-minute conference talk with live demonstrations. This reusable profile is not the 120-minute workshop version.
Demo: An anonymized knowledge assistant, three failure modes, a golden dataset, scoring, and a regression workflow.
Evidence: Accepted for The Commit Your Code Conference 2026.
Materials: Talk-specific repository, slides, and recording are not yet published.
Vendor scope: Vendor-neutral testing patterns; implementation examples use C#/.NET.
Choosing an Agent Runtime: SDKs, Harnesses, and Frameworks Compared
Many agent projects begin with a technology choice before the team has decided what the runtime must own. Does the application need a small SDK around one tool-using loop, a harness that manages context and execution, or a framework that coordinates multiple agents and services? Confusing those layers leads to unnecessary complexity and expensive rewrites.
This session starts with the minimum anatomy of an agent—model, tools, memory, state, and an action loop—then compares runtime options against the same requirements. We will examine the Claude Agent SDK, GitHub Copilot SDK, and Microsoft Agent Framework, focusing on lifecycle control, tool boundaries, persistence, observability, hosting, and lock-in. A single tool-using task is mapped across the three approaches so the differences stay concrete.
Attendees will leave with a decision matrix, a vocabulary for separating SDKs, harnesses, and frameworks, and a repeatable way to choose a runtime based on workload constraints rather than product familiarity.
Audience: Developers and architects selecting an agent stack.
Format: 45–60-minute comparison talk with code excerpts and one shared scenario.
Demo: The same tool-using task mapped across Claude Agent SDK, GitHub Copilot SDK, and Microsoft Agent Framework.
Evidence: Submitted to NDC Oslo 2026 and Live! 360 Tech Con Orlando 2026; no prior public delivery.
Materials: Talk-specific decision matrix, repository, slides, and recording are not yet published.
Vendor scope: Comparative and vendor-neutral; Azure deployment implications are identified explicitly.
Private, Offline AI in the Browser with WebGPU and Transformers.js
Modern browsers include a GPU, a neural-network runtime, and enough compute to run useful AI models locally. That creates a different architecture for features that need privacy, offline operation, or low-latency interaction: no inference request has to leave the device.
This session runs text generation, image classification, and semantic search directly in a browser tab using Transformers.js, ONNX Runtime, and WebGPU. Along the way, we will examine the limits that determine whether a model belongs in the browser: download size, quantization, warm-up time, memory pressure, browser support, and the point where a server is still the better answer.
Attendees will leave able to select browser-appropriate models, choose between WebGPU and WASM fallbacks, design an offline-capable inference flow, and explain the privacy and operational tradeoffs of client-side AI.
Audience: Web developers and architects evaluating client-side AI.
Format: 45–60-minute technical talk with live browser demonstrations.
Demo: Local text generation, image classification, and semantic search with no inference backend.
Technology reference: https://github.com/huggingface/transformers.js
Evidence: New reusable session; currently in evaluation for Live! 360 Tech Con Orlando 2026.
Materials: Talk-specific repository, performance notes, slides, and recording are not yet published.
Vendor scope: Vendor-neutral web standards and open-source runtimes.
Building Interactive Agent UIs with AG-UI, A2UI, and MCP Apps
Agent backends are maturing, but the interaction layer remains fragmented. When an agent needs to show progress, request consent, collect structured input, or return an interactive result, many teams still glue chat bubbles to custom React components.
This session compares three emerging approaches. AG-UI streams agent state and tool progress into the application. A2UI lets an agent describe a trusted interface as structured data. MCP Apps lets a tool return an interactive experience inside a sandboxed surface. In one end-to-end expense-approval demo, we will wire all three together: stream the plan, pause for authorization, render a form, and return an interactive audit view.
Attendees will leave able to explain where the protocols overlap, choose the right boundary for state and UI generation, implement consent-first actions, and design an agent interface that remains testable and secure.
Audience: Front-end, full-stack, and agent developers building interactive web applications.
Format: 45–60-minute technical talk with one end-to-end live demo.
Demo: An expense-approval agent using AG-UI state events, an A2UI form, and an MCP App audit view.
Technology reference: https://github.com/ag-ui-protocol/ag-ui
Materials: Talk-specific repository, slides, and recording are not yet published.
Vendor scope: Protocol-focused and vendor-neutral; web examples use React and TypeScript.
Engineering Agent Loops: Tool Use, Verification, Events, and Termination
Most agent demos stop at the prompt. Production failures often happen after turn one, inside the loop that selects tools, evaluates progress, retries work, reacts to events, and decides when to stop.
This session compares four loop patterns: a tool-use loop that runs until a goal condition is met, a verification loop that grades and retries, an event-driven loop that resumes from external signals, and an optimization loop that improves behavior from traces. We will compare their latency, token cost, persistence needs, and characteristic failure modes. Then we will build a persistent goal-condition loop in C#/.NET, deliberately trigger a non-termination failure, and add evaluation and budget boundaries that stop it safely.
Attendees will leave able to recognize the loop hidden inside an agent product, choose a loop based on the job, implement explicit state and termination conditions, and diagnose loops that silently burn time or tokens.
Audience: Developers who understand basic prompting and tool calling and now need reliable agent control flow.
Format: 45–60-minute technical talk with a live C#/.NET build.
Demo: Persistent goal-condition loop, per-turn evaluator, deliberate non-termination failure, and budget-based termination.
Evidence: New session; no prior public delivery.
Materials: Talk-specific repository, state diagram, slides, and recording are not yet published.
Vendor scope: Framework-agnostic loop patterns with a C#/.NET implementation.
Your Tests Pass. Does Anyone Understand the Code?
Consider a common failure pattern: a pull request arrives with clean naming, full coverage, and every check green. It is approved quickly. Months later, the module breaks and nobody can explain the design decisions because the intent lived in an AI conversation that was never preserved.
This is not only a hypothetical risk. In a randomized study of 52 developers learning a new library, the AI-assisted group did not finish significantly faster and scored 17% lower on a follow-up comprehension test. The strongest AI users asked conceptual questions and deliberately rebuilt understanding instead of delegating the entire task.
This session shows engineers and engineering leaders how AI-authored code fails differently: plausible duplication, hidden assumptions, unnecessary abstractions, brittle tests, and lost intent. Attendees will leave able to identify AI-specific review risks, apply a practical comprehension checklist, and make explainability an explicit quality signal before code is merged.
Audience: Software engineers, reviewers, and engineering leaders using AI coding tools.
Format: 45–60-minute evidence-driven talk with a pull-request review exercise.
Demo: Review an illustrative AI-authored module, expose five failure modes, and apply a comprehension checklist.
Research: Anthropic’s randomized developer study: https://www.anthropic.com/research/AI-assistance-coding-skills
Materials: Talk-specific checklist, slides, and recording are not yet published.
Vendor scope: Vendor-neutral.
Tech Fuse Des Moines 2026 Sessionize Event Upcoming
The Commit Your Code Conference 2026! Sessionize Event Upcoming
AgentCon 2026 - Dallas Sessionize Event
CodeMash 2026 Sessionize Event
AI Community Day Sessionize Event
Festive Tech Calendar 2025 Sessionize Event
The Commit Your Code Conference 2025! Sessionize Event
dev up 2025 Sessionize Event
Azure Spring Clean 2025 Sessionize Event
The Commit Your Code Conference Sessionize Event
Data Saturday Dallas 2024 Sessionize Event
Developer Week '24 Sessionize Event
Render Atlanta 2024 Sessionize Event
DevSum 2024 Sessionize Event
Visual Studio Live! Las Vegas 2024 Sessionize Event
Global XR Conference 2023 Sessionize Event
Metaverse One 2023 Sessionize Event
Techorama 2023 Belgium Sessionize Event
Azure Spring Clean 2023 Sessionize Event
Virtual Boston Azure User group Sessionize Event
CodeMash 2023 Sessionize Event
Azure Developer Community Day 2022 (hybrid Edition) Sessionize Event
Microsoft Azure + AI Conference Fall 2022 Sessionize Event
Festive Tech Calendar 2022 Sessionize Event
Update Conference Prague 2022 Sessionize Event
Global XR Conference 2022 Sessionize Event
Global AI Developers Days Sessionize Event
Little Rock Tech Fest 2022 Sessionize Event
Azure Back to School 2022 Sessionize Event
NDC Melbourne 2022 Sessionize Event
Global Azure 2022 Philippines Sessionize Event
CodeStock 2022 Sessionize Event
Azure Spring Clean 2022 Sessionize Event
philly.NET Code Camp 2022 Sessionize Event
DataMinutes #2 Sessionize Event
Cumbre Virtual 2021 Sessionize Event
Azure Developer Community Day 2021 (hybrid Edition) Sessionize Event
Global XR Conference Community 2021 Sessionize Event
Comunidad AI Live 2021 Sessionize Event
WeAreDevelopers JavaScript Congress 2021 Sessionize Event
.NET Conf 2021 : West Africa Sessionize Event
Azure Community Bootcamp Sessionize Event
DeveloperWeek Austin 2021 Sessionize Event
Granite State Code Camp 2021 Sessionize Event
Colorado Springs Tech (un)Conference 2021 Sessionize Event
Azure Community Conference 2021 Sessionize Event
AI DevWorld 2021 Sessionize Event
Big Mountain Data and Dev Conference Sessionize Event
Northern VA CodeCamp Fall 2021 Sessionize Event
DataSaturdays #13 - Minnesota - Oct 16 2021 Sessionize Event
Virtual Azure Community Day #4 Sessionize Event
PowerShell, DevOps and Cloud Conference Sessionize Event
Azure Summit Sessionize Event
Javascript & Friends Conference 2021 Sessionize Event
Azure Day Rome 2021 Sessionize Event
Global AI On Virtual Tour 2021 Sessionize Event
DeveloperWeek 2021 Sessionize Event
CodeGen 2021 Sessionize Event
philly.NET Code Camp 2021 Sessionize Event
dotNet OpenSource Days 2020 Sessionize Event
AzConf Sessionize Event
Granite State Code Camp 2020 Sessionize Event
Code PaLOUsa 2020 Sessionize Event
Global AI Community - On virtual tour Sessionize Event
CodeMash 2020 Sessionize Event
Music City Tech 2019 Sessionize Event
CodeMash 2019 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top