Jatin Chawla

Jatin Chawla

I am a Software Engineer at Microsoft (AI Commercial Engineering)

Bengaluru, India

Actions

As a Software Engineer, my work revolves around infusing AI, building Agentic capabilities and using Data Driven Intelligence to produce insights and recommendations in areas that include Sales Strategy, Business, Operations for 60K sellers at Microsoft Commercial.

I am deeply involved in architecting multi-agent systems for our internal Sales Org and have spent the last few years infusing them with guardrails and state-management patterns - to make agentic systems deterministic and reliable.
I have worked on building enterprise grade agentic systems to enhance seller pitches, assist customer conversations, generate customer/account insights with recommendations to tap whitespaces, enhance up-selling contributing to $100M in revenue in the last one year.

Area of Expertise

  • Business & Management
  • Information & Communications Technology

Topics

  • AI
  • Machine Learning
  • AI/LLMs
  • AI Evals
  • Agentic AI and Frameworks
  • Data Science
  • Business strategy
  • Software Development
  • Data Science & AI
  • Multi-Agents System
  • AI Agents

Engineering the Reasoning Audit for the 2026 Agentic Economy

In 2026, we have a trust problem, as AI agents transition from "chatting" to "acting" within sovereign borders.
An unmonitored agent isn't just a technical bug, it’s a liability and a potential $20M compliance breach. The "vibe check" is officially dead, replaced by the necessity of rigorous, automated, and scalable eval frameworks.
Drawing from my experience building reasoning engines contributing to more than $100M cost savings for Microsoft, this session moves past static benchmarks to the tactical "How" of Agentic MLOps. We will deconstruct the architecture of domain-specific custom evaluations applied across two critical tracks: Real-Time Guardrails for immediate reasoning safety and Offline Deep-Dives for high-fidelity audits. I will share the blueprint for integrating "LLM-as-a-Judge" into CI/CD pipelines using specialized SLMs to ensure low-latency, cost-effective oversight without sacrificing data sovereignty.

Key Takeaways -
> The Hybrid Eval Stack: Audience will architect a Real-Time SLM judge for production safety and learn about frameworks for deep reasoning audits. Demo - How Logic Traceability could be implemented to audit multi-step task execution and catch the logical chain breaks before production roll-outs.
> Domain Specific Customization: Audience will get to know how to build custom evalsets tailored to specific industry use-cases and constraint, and leverage AI to generate thousands of adversarial edge cases that traditional training data misses.

Beyond the Chatbox: Building Generative UI for AI Apps People Actually Want to Use

Chatbots are clunky for real work. This talk demonstrates how to build "Generative UI"—AI applications that respond not with walls of text, but by instantly building interactive, custom software interfaces (like charts, sliders, and forms) tailored exactly to the user's needs.

Developers default to the standard chat interface (like ChatGPT) for almost every AI app, which creates a frustrating user experience. If a user asks an AI to compare sales data, adjust a budget, or plan a project, they don't want to read a 500-word essay. Text is a terrible medium for conveying complex data or completing multi-step tasks. If we want non-technical users to adopt AI in their daily workflows, we have to stop forcing them to read massive text blocks and start giving them the visual, interactive software tools they are used to. We need to shift from generating text to generating actual user interfaces. The solution is Generative UI. Instead of the AI writing a paragraph, you teach it to output a simple blueprint. Your application reads this blueprint and instantly snaps the right visual blocks together on the user's screen.

This session would also feature a demo, where for some basic user prompts we’ll, peek under the hood to see how the AI selects the right visual components, and watch as the application transforms that AI logic into a beautifully rendered, fully clickable interface in real-time.

We’ll see live, when a user asks "Can I afford a $400k house?" Instead of a long paragraph explaining interest rates, the AI instantly renders a custom "Home Affordability Dashboard." This interface features an interactive down-payment slider, a live pie chart of their monthly budget, and a one-click pre-approval button. The AI acts as an on-demand software engineer, building the exact tool the user needs in real-time.

Key Takeaways -
1.Core Architecture: Learn how Generative UI bridges AI text models with visual frontends.
2.Component Toolboxes: Discover how to train AI to output interactive components (sliders, charts) instead of conversation.
Live Application and Blueprint: Experience an end-to-end demo building a dynamic dashboard from a simple prompt and walk away with the framework to build AI apps that feel like premium, interactive software.

This session would be a first public delivery and would just require a screen share to project the end to end live demo for the attendees.

It is intended for audiences working directly or indirectly in a software industry where they could be a developer building AI apps, a consultant trying out a customer POC, a founder prepping for their next investor pitch and many more.

The preferred session duration is around 45 minutes (atleast 30 minutes).

Beyond Copilot: Securing and Scaling AI Reasoning Engines with Zero Trust and MCP

While out-of-the-box AI Agents/Copilots offer excellent productivity, the future of the Modern Workplace lies in custom, autonomous AI agents that can securely execute IT operations, provisioning, and complex workflows. But how do you deploy an autonomous reasoning engine considering security and compliance are not compromised?

Drawing from my experience building Agentic AI solutions deployed to thousands of users, this session unpacks the blueprint for building and securing enterprise AI. We will move beyond basic API calls and dive deep into the architecture of task-oriented MCP Engines.

The audience will learn how to implement Model Context Protocol to securely connect AI agents to APIs, tools and Azure resources governed by Microsoft Entra ID and strict Zero Trust principles. We will dissect the "AI shared responsibility model," demonstrating how to enforce Just-In-Time (JIT) access, manage non-human agent identities, and implement semantic caching to deploy reasoning engines that are deterministic, powerful and compliant.

Learning Objectives
- Understand the architectural shift from standard LLM prompts to autonomous reasoning engines capable of executing complex workflows.

- Learn how to implement the Model Context Protocol (MCP) behind an API gateway to safely bridge AI agents with enterprise backend systems and Microsoft Graph.

- Master the integration of Microsoft Entra ID to assign and manage "Agent Identities," enforcing Conditional Access and least privilege (JIT/JEA) when the agent drives autonomous actions.

Turning Probabilistic Agent Trajectories into Production Skill Stores

Deploying autonomous agents to handle multi-step operational workflows (e.g., incident triage, cloud resource migration, database re-indexing) faces fundamental production bottlenecks: probabilistic latency and variance to name a few.

When an LLM agent executes a 10-step workflow, every step involves a probabilistic tool call. This creates three critical issues in production environments:

1. Compounding Non-Determinism: A 95% single-step accuracy rate degrades to a ~60% success rate across a 10-step agent loop.

2. Latency & Cost Inflation: Re-evaluating system prompts, tool schemas, and multi-turn history on every single request wastes millions of tokens and introduces severe execution delays (often taking 30–90 seconds per task).

3. Context Rot & Drift: As intermediate tool outputs accumulate in the context window, the agent risks missing edge-case constraints or sometimes gets stuck in retry loops.

Our Approach:
Instead of forcing LLMs to re-evaluate repetitive multi-step plans, our Agent Compiler converts dynamic agent trajectories into deterministic code.
When an agent solves a new problem, an offline node sanitizes its execution logs, injects schema guardrails, and compiles the sequence into a statically typed script saved to a centralized Skill Store.
Future matching requests bypass the LLM planning loop via semantic dispatch—running the compiled artifact directly at 1/100th the token cost and 10x the speed.

Tech-Stack
- Agent Orchestration: LangGraph / FastAgency / OpenTelemetry Tracing
- Compiler & Parsing Layer: Python (AST, Pydantic v2 runtime validation)
- Tool Protocol: Model Context Protocol (MCP)
- Skill Store Infra: Redis / VectorDB + Git/S3 for script versioning

Target Audience: Software Engineers, Architects, Applied Scientists, Solution Engineers, Problem Solvers.

Key Takeaways:

1. Master the architecture for capturing dynamic, probabilistic LLM reasoning and compiling it into fast, deterministic, statically typed code.

2. Learn exact engineering strategies to slash token costs by up to 90% and cut multi-step task execution latency from 45 seconds down to under 1 second.

3. Design a version-controlled, rollback-ready Skill Store with automated contract testing, semantic dispatch routing, and human-in-the-loop review boundaries.

Deploying autonomous agents for multi-step operational workflows (incident triage, cloud provisioning) hits severe production walls: non-deterministic failure, high latency, and compounding cost. In a 10-step loop, a 95% single-step accuracy degrades to ~60% overall, while expanding context windows introduce latency (30–90s) and context rot.

Instead of forcing LLMs to re-evaluate repetitive plans, our Agent Compiler architecture converts dynamic trajectories into deterministic code. When an agent solves an unscripted problem, an offline compiler node sanitizes execution logs, injects runtime schema guardrails, and compiles the sequence into a statically typed script committed to a centralized Skill Store. Future matching requests bypass the LLM planning loop via semantic dispatch—executing compiled artifacts directly at 1/100th the token cost and 10x the speed.

Key Takeaways:

Master the design pattern for compiling probabilistic LLM reasoning into statically typed zero-token execution code.

Slash token costs by 90% and cut multi-step task latency from 45 seconds to under 1 second.

Build a rollback-ready Skill Store complete with automated contract testing, semantic routing, and human-in-the-loop review boundaries.

Target Audience: Software Engineers, Architects, Applied Scientists, Solution Engineers, Problem Solvers.

Session Duration: 45 mins to 1 hour

Jatin Chawla

I am a Software Engineer at Microsoft (AI Commercial Engineering)

Bengaluru, India

Actions

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