Building Developer Tooling for Microsoft Foundry: Lessons from Shipping a VS Code Extension

Most Foundry talks focus on using the platform to build agents. This one is about building for the people who build with it. I'll do a code-level walkthrough of designing and shipping Foundry Trace Inspector, a VS Code extension for debugging Foundry agents without leaving the editor — covering the actual engineering decisions:

- which Foundry API surfaces (tracing, telemetry, agent state) I hooked into and why.
- how the extension architecture handles async agent execution and streaming trace data, the UX trade-offs in surfacing multi-step agent behavior as inline decorations vs. a webview panel, and the debugging dead-ends I hit along the way.

I'll close with what I'd redesign if starting over, and a framework for evaluating whether a platform's developer experience gap is worth building tooling to fill.

Extension link: https://marketplace.visualstudio.com/items?itemName=jubinsoni.foundry-trace-inspector

Building AI Agents on Microsoft Foundry: From Chatbots to Autonomous Workflows

Move beyond simple Q&A chatbots to build AI agents that plan, execute multi-step tasks, and integrate with your existing systems — using Microsoft Foundry's Agent Service as the foundation. This session explores the architectural patterns and practical techniques for creating agents that handle complex workflows autonomously, grounded in real build experience on the platform.

What You'll Learn:
- Agent Architecture Patterns on Microsoft Foundry: Task planning, tool integration, and decision-making frameworks powering autonomous agents built on Foundry Agent Service
- From Simple to Smart: The evolution from basic chatbots → function-calling bots → multi-step agents → autonomous workflows, and where Foundry's tooling accelerates each stage
- Tool Integration Strategies: How Foundry agents interact with APIs, databases, file systems, and external services safely and effectively — including patterns for zero-trust identity and networking between agents and tools
- Real-World Examples: Customer support automation, content generation pipelines, and data analysis workflows built and deployed on Foundry
- Safety & Control Mechanisms: Implementing guardrails, approval workflows, cost governance, and observability to prevent runaway automation in production agent systems

Taming the Tail: Engineering Predictable Latency in Serverless Event Processing

Serverless platforms scale beautifully until they don't. In event-driven architectures, unpredictable P99 latencies often emerge from cold starts, retries, uneven shard processing, or misconfigured concurrency controls. These "long tail" latency spikes can go unnoticed in dashboards but wreak havoc on end-user experience and downstream systems.

In this talk, I’ll share engineering strategies we've used to tame tail latencies in large-scale serverless event pipelines. We’ll look at techniques like shuffle sharding to reduce noisy-neighbor effects, adaptive token management to avoid timeouts during AI inference, and observability patterns that help catch latency cliffs before they hit production.

Expect practical code-level takeaways and architecture patterns designed to bring performance predictability to inherently bursty, decoupled systems. Whether you're building real-time data pipelines or transactional event workflows, this talk will equip you to chase—and tame—those elusive P99s.

Orchestrating Multi-Agent Systems with the Microsoft Agent Framework

Coordinating multiple agents that collaborate and hand off work is a different engineering problem than building a single agent with a few tools. The Microsoft Agent Framework SDK gives you several orchestration patterns for this - concurrent, sequential, group chat, handoff, and Magentic - each with real trade-offs. In this talk I build the same multi-agent problem multiple ways using these patterns and show where each one breaks down, where it shines, and how to decide which fits your workload. We'll cover how agent state passes between orchestration steps, common failure modes under each pattern, and how to debug a multi-agent system when something goes wrong several agents deep. If you've built single-agent systems and are now facing the "do I need multiple agents or one smart one" decision, this talk gives you the code and the framework to make that call.

Feature Engineering at Scale: Apache Spark and Delta Lake on Azure Databricks

Feature engineering pipelines that work fine on a laptop-sized dataset often fall apart at production scale - data skew, slow joins, and reprocessing costs pile up fast. This talk walks through building scalable feature engineering pipelines using Apache Spark and Delta Lake on Azure Databricks, covering partitioning and join strategies that avoid common performance traps, using Delta Lake's versioning and time travel for reproducible feature sets, and structuring pipelines so MLOps and data science teams aren't fighting over the same tables. I'll share concrete lessons from building and debugging these pipelines in production, including where Spark's lazy evaluation quietly causes reprocessing you didn't intend.

Building Production RAG on Microsoft Foundry: Vector Indexes, HNSW, and Retrieval at Scale

Retrieval-augmented generation looks simple in a demo and falls apart in production — recall drops, latency spikes, and relevance tuning becomes guesswork. This talk walks through building a real RAG pipeline for agents on Microsoft Foundry, backed by Azure AI Search: HNSW vector index configuration, hybrid search profiles, and the retrieval tuning decisions that actually move the needle on answer quality once a Foundry agent is grounding its responses in your data at scale.
What You'll Learn:

- Vector index fundamentals: Configuring HNSW parameters and hybrid search profiles in Azure AI Search for use as a Foundry agent's retrieval layer
- Where RAG breaks in production: Recall degradation, latency spikes, and relevance drift that don't show up in a demo but surface immediately at scale
- Retrieval tuning that actually moves the needle: Chunking strategy, embedding choice, and reranking decisions, evaluated against real answer-quality metrics
- Grounding Foundry agents reliably: Connecting retrieval quality to agent evaluation — how bad retrieval quietly becomes bad agent behavior downstream
- Debugging retrieval failures: A practical framework for diagnosing whether a bad agent answer is a retrieval problem, a prompt problem, or a model problem

Serverless AI: Event-Driven Architecture with Azure Functions and Cosmos DB

Pairing serverless compute with AI workloads changes how you think about scaling, cost, and state. This talk covers designing event-driven AI pipelines on Azure Functions and Cosmos DB — from trigger patterns to cost optimization — using real architecture decisions from production systems.

Designing APIs for Microsoft Foundry Agents (or other AI Agents)

For years, API teams invested in SDKs, client libraries, and documentation to make APIs easy for developers to consume. AI agents are changing that model.

Instead of relying on SDKs, AI agents can discover and invoke APIs directly from OpenAPI specifications. When your primary consumer is an AI agent instead of a developer, schema quality determines whether the right endpoint is selected, response payloads influence autonomous decisions, and traditional approaches to versioning and deprecation no longer fit.

In this session, you'll learn how to design APIs that work reliably with Microsoft Foundry agents and other AI agent frameworks—without rewriting your existing APIs.

What You'll Learn
- Why schema quality is the new developer experience—how agents use OpenAPI to discover and invoke APIs.
- Designing responses for AI agents—structuring payloads that enable reliable decisions while minimizing unnecessary data exposure.
- Rethinking versioning and deprecation—how dynamic API discovery changes compatibility strategies.
- Making existing APIs agent-ready—practical techniques for improving schemas, endpoint descriptions, and API design.
- Real-world failure modes—common mistakes that cause agents to select the wrong endpoint or misuse an API.

How to contribute to Open Source Projects? Hardest part isn't writing code.

Getting your first PR merged into a major open-source project is harder than it looks - not because the code is hard, but because nobody explains the unwritten process: how to find an issue worth taking, how maintainers actually triage contributions, and why technically correct PRs still get rejected.

This talk walks through the real mechanics of contributing to large projects, drawn from merged and rejected PRs across Apache Spark, Apache Flink, and Elasticsearch.

I'll cover finding good first issues, writing PRs maintainers actually want to review, navigating JIRA/review workflows, and what to do when a PR gets closed instead of merged - because that happens too, and it's not the end of the story.

Suitable for developers who've never contributed to open source and want a concrete starting point, as well as engineers who've tried and gotten stuck in review purgatory. Includes real examples of merged, closed, and open PRs with what made the difference.

Integrating MCP Tools with Azure AI Agents on Microsoft Foundry

Static tool registration works fine until your agent needs access to a growing, changing set of capabilities - that's where MCP (Model Context Protocol) changes the game.

This talk is a code-level dive into connecting MCP-hosted tools to Azure AI agents built on Microsoft Foundry:
- how the MCP server/client model handles tool discovery and invocation
- how to wrap MCP tools as async functions and register them with an agent
- how to build an agent that dynamically discovers and calls tools at runtime instead of at build time.

I'll walk through the actual plumbing - client-server handshake, async function wrapping, and the failure modes that show up when tool discovery happens dynamically (timeouts, schema mismatches, tools disappearing mid-session) - and share debugging techniques for when an agent picks the wrong tool or fails to invoke one correctly.

Azure Databricks Hands-on: Building a Medallion Architecture Pipeline using PySpark and MLFlow

Medallion architecture (bronze, silver, gold) is easy to draw on a whiteboard and easy to get wrong in practice - the hard part is deciding what transformation logic belongs at each layer and how to track model experiments across a pipeline that's constantly reprocessing data.

This is a hands-on build: I'll construct a full medallion pipeline on Azure Databricks using Apache Spark for the bronze-to-gold transformations and MLflow for experiment tracking and model versioning at the gold layer, covering schema evolution as raw data changes, incremental processing so you're not reprocessing your entire bronze layer on every run, and wiring MLflow tracking into the pipeline so model training stays reproducible as the underlying data evolves. Real code, real data, real mistakes included.