Microsoft Reactor Toronto

----------------------------------------------
Explore the repo

📢 Join the conversation on Discord!

📌 This session is a part of the Model Mondays series. Learn more here!

📌 This session is a part of a series! Learn more here

• Un navegador y acceso al Portal de Azure
• Una suscripción de Azure proporcionada o usa la tuya propia: https://github.com/GlobalAICommunity/agentcon-pizza-workshop/blob/main/docs/get-azure
• Un entorno de desarrollo con Python 3.10+ instalado
• Familiaridad con los conceptos básicos de Python (¡no se requiere experiencia profunda en IA!)

## 🌎 Americas Stream
Program order to come; please check jdconf.com for the latest details

---

1. Building the Agentic Future Together — Keynote

Speakers: Rod Johnson (Embabel), Bruno Borges (Microsoft), Ayan Gupta (Microsoft)

Software has entered a new era where intelligence is open, AI agents collaborate with people and among other agents, while developers remain in control. Join this keynote to see how software development teams move from traditional tooling to agentic workflows, modernize millions of existing applications, and safely integrate AI using open frameworks. See how GitHub Copilot agents, Microsoft Foundry, and the Java ecosystem work together to deliver governed, production‑grade AI capabilities while reinforcing the value of open source, existing systems, and developer choice in the enterprise.

---
2. Secrets of Agentic Memory Management

Speaker: Brian Sam-Bodden (Redis)

Memory is what gives agents continuity, personalization, and depth—but managing it is far from simple. This talk explores current best practices in agentic memory, from short-term working memory with summarization to long-term stores with semantic retrieval and metadata filters. We'll cover how modern systems handle promotion, deduplication, and background consolidation, as well as how protocols like MCP expose memory as first-class tools. We'll illustrate design trade-offs and practical strategies for building memory-aware agents in Java.

---

3. Modernizing a Java App, with Node Frontend, with GitHub Copilot

Speakers: Ed Burns (Microsoft)

Legacy applications rarely live in isolation. Many real-world systems combine technologies like Node.js and Java—and over time, outdated dependencies and runtimes become a major barrier to security, performance, and innovation.

In this session, we'll take a typical enterprise Java app with a Node.js front end that hasn't been updated in years and modernize it end-to-end using GitHub Copilot App Modernization. We'll start by upgrading ill-maintained Node.js dependencies, addressing breaking changes and security issues along the way. Then we'll turn to the backend Java service, upgrading it from an older Java version to a modern, supported JDK, resolving compatibility issues and improving maintainability.

---

4. Building Scalable Multi-Agentic AI Systems in Java: Orchestrating Agents with Event-Driven Approach

Speaker: Mary Grygleski (Java Champion)

This talk will guide Java developers through the design and implementation of multi-agent generative AI systems using event-driven principles. Attendees will learn how autonomous GenAI agents collaborate, communicate, and adapt in real-time workflows using modern Java frameworks and messaging protocols.

Cover core patterns such as pub/sub, orchestrator, and supervisor for managing agent communication, memory, and workflow state. Discuss interoperability with MCP (Model Context Protocol) and how Java event streaming tools like Kafka, Pulsar, and Spring Messaging facilitate high throughput and reliability.

---

5. From Cloud Native to AI Native: Harnessing Quarkus, MCP, and Azure OpenAI

Speaker: Daniel Oh (IBM)

Modern Java applications demand speed, scale, and intelligence. Join us as we explore how Quarkus helps developers build AI-native microservices that seamlessly connect with enterprise systems through the Model Context Protocol (MCP). We'll demonstrate how Azure MCP servers provide a secure operational bridge between AI and application data, while Azure OpenAI delivers powerful model intelligence directly into your workflows.

This session features a hands-on technical deep dive and a live demo, showing the complete journey from code to a production-ready, AI-enhanced service running on Azure.

---

6. Building LLM Apps in Java with LangChain4j

Speaker: Bazlur Rahman (Hammerspace)

AI is revolutionizing the software landscape. However, for many Java developers, integrating these powerful AI tools into existing enterprise applications can feel daunting. This hands-on session will demystify the process and show you how to build LLM-powered features directly into your Java codebase.

Using Java and the LangChain4j library, we'll explore RAG, a cutting-edge technique that combines the vast knowledge of LLMs with the precision of your own data. We'll explore how to create both few-shot and zero-shot RAG models and then add practical features like summarization and similarity search, backed by an embedding database.

Through a live coding demo, we'll walk through constructing an AI-powered online store backend and provide practical insights into the architecture and code.

---

7. Intelligent Java Tooling: How AI Is Changing Build, Test, and Deployment Pipelines

Speaker: Savi Grover (NBC Universal)

AI is transforming the Java software lifecycle—from how we build code, generate tests, and detect failures, to how we deploy and monitor services in production. This talk explores how AI-assisted tools are reshaping the Java ecosystem: predictive builds, autonomous test generation, self-healing functional tests, AI-guided deployment decisions, and intelligent anomaly detection powered by observability signals. Attendees will learn modern patterns, tools, and real-world use cases illustrating how Java teams can integrate these capabilities into their CI/CD pipelines to improve velocity, reliability, and responsible automation across the SDLC.

---

8. From Vulnerability to Victory: Mastering the CVE Lifecycle for Java Developers

Speaker: Anthony Dahanne (HeroDevs)

This session demystifies the CVE lifecycle for Java developers. We'll explore how vulnerabilities are discovered, scored via CVSS, and disclosed through responsible processes. You'll learn about major vulnerability databases (NVD, GitHub Advisory, OSS Index), their differences, and which security tools rely on each source.

The practical half equips you with remediation strategies using automated tools like Dependabot, Renovate, and IDE integrations. We'll tackle the challenge of transitive dependencies in Maven and Gradle with hands-on techniques for resolving conflicts. Finally, we'll discuss framework (Spring, Quarkus, etc.) End-of-Life situations with the different options available.

Walk away understanding the entire vulnerability ecosystem, implementing automated dependency updates in CI/CD pipelines, handling dependency conflict resolution, and developing pragmatic approaches to framework EOL scenarios.

---