Augustine Correa's Speaker Profile @ Sessionize

🧠 Build Your First AI Agent

AI agents are no longer just research buzzwords—they’re becoming the backbone of modern automation, productivity, and intelligent systems. This session introduces developers to the world of AI agents using the [AI Agents for Beginners](https://github.com/indcoder/ai-agents-for-beginners) OSS curriculum, co-developed with Microsoft.

Whether you're curious about agentic design patterns, multi-agent orchestration, or integrating tools like Semantic Kernel and Azure AI Agent Service, this talk will walk you through the fundamentals with live demos and code samples. No prior GenAI experience needed—just bring your curiosity and a laptop!

**What you'll learn:**
- What makes an AI agent different from a chatbot or LLM app
- How to use OSS frameworks like AutoGen and Semantic Kernel
- Agentic RAG, planning, and tool-use patterns in action
- How to deploy your first agent using GitHub-hosted models or Azure AI Foundry

**Who it's for:** Beginners, students, OSS contributors, and anyone curious about building intelligent systems with open tools.

🔧 From Local to Cloud: Building Scalable AI-Ready Apps with .NET Aspire

Modern applications increasingly rely on distributed backends—spanning APIs, databases, real-time communication, and AI services. Managing this complexity during local development can be a major bottleneck. In this talk, we’ll explore how .NET Aspire helps developers tame this chaos and build scalable, cloud-native apps with confidence.
Using Visage, an open-source event management platform for OSS communities, I’ll demonstrate how Aspire streamlines development with features like service discovery, dependency injection, and Blazor Hybrid integration. You’ll see how Aspire accelerates the inner loop, simplifies debugging with integrated observability, and handles service interactions with built-in resilience.

New for this session: I’ll showcase how Aspire interoperates seamlessly with Node.js and Python apps, making it a powerful choice for polyglot teams building AI-ready systems.
Forget abstract theory—this is a hands-on, code-first session packed with practical insights, architecture diagrams, and lessons learned from building Visage. Whether you're a .NET veteran or exploring Aspire for the first time, you’ll leave equipped to build faster, debug smarter, and scale confidently

With .NET and AI, our community app "aspires" to be on cloud nine

We are the largest Open-Source Software [OSS] community with its longest running (> 10 years) tech meetup in Bombay.

And as such we are mostly houseful [
https://x.com/search?q=learnAspireMumbai&src=typed_query&f=live]. As a community that is committed to diversity and inclusiveness, most of our efforts and time is expended on registration triaging. And the next biggest friction in our meetup management is to ensure attendee check-ins and check-outs for building/civic code adherence

So as a tech community, to solve this, we did the only thing we love to do: build an app. That too on .NET 9. We will tell you why .net9 is the best .NET yet and share what are the gotchas we had to look out for.

In this session, we will explore the development of our community app using the latest features of .NET 9: Aspire, Semantic Kernel, Blazor Hybrid. This app leverages the power of .NET 9 to create a cloud-native, and intelligent platform that enhances user engagement and community interaction. We will delve into the integration of AI models to provide personalized experiences and improve overall functionality to building an inclusive and diverse community

Also, our demo would include how GitHub Copilot and Copilot Workspace turbo charged our development to debut the app in time for .NET Conf 2024.

And we wouldn't be an OSS community, if it's not on GitHub [https://github.com/HackerspaceMumbai/Visage/tree/dotnet9]. Contributors welcome 🙏

Who Are You? Identity, Authorization, and AI Agents in OSS Security

The rise of AI agents and model-driven workflows has introduced new identity surfaces, authorization challenges, and privacy risks. This talk extends the IAM conversation into the age of autonomous agents and the Model Control Plane (MCP). We will examine how agents and models acting on behalf of users, organizations, or other agents complicate traditional notions of identity, trust, and authorization, and we will map those risks to operational control plane patterns.

Key themes include:

1. Agent identity and trust: how do we authenticate and authorize autonomous agents, and what does "Who are you?" mean when the actor is non-human?

2. The death of the static API key: why long-lived secrets are a fatal threat to agentic workflows and how to phase them out.

3. Keycloak in action (demo): a consolidated, hands-on demonstration using Keycloak, a CNCF incubating project, to implement agent-focused IAM patterns, including:
a. issuing just-in-time, least-privilege tokens via token exchange (RFC 8693) to minimize blast radius;
b. enforcing context-aware policies (attribute-based and time-based) to limit agent actions by runtime context;
c. binding tokens to agent cryptographic keys using proof-of-possession (DPoP) to mitigate token theft and replay.

3. Model Control Plane security: identity and lifecycle for models, model signing and provenance verification, runtime attestation, mTLS between control plane and runtimes, and auditability for model promotions and deployments.

4. Protocol extensions and standards: applying and adapting OAuth 2.0, OpenID Connect, etc. to agent-to-agent and MCP interactions.

5. Threat modeling for AI agents and MCPs: prompt injection, agent impersonation, supply-chain and model poisoning, and practical mitigations.

6. Privacy and compliance: ensuring agent-driven workflows respect GDPR, data minimization, and privacy-preserving techniques.

By combining IAM best practices, MCP security patterns, and an open-source demo, this session will give developers and security engineers a practical, standards-based playbook for building trustworthy, least-privilege, and privacy-preserving systems in the era of AI agents.

When AI Becomes the Insider: Identity, Authorization, and Privacy Risks of Autonomous Agents

AI agents increasingly act on our behalf - accessing data, automating decisions, and communicating across systems. But when non‑human actors inherit human privileges, traditional identity, authorization, and privacy assumptions break down. This session explores how autonomous agents become insider threats, why OAuth‑era security models fail, and which practical, standards‑based patterns can restore accountability, auditability, and privacy in agent‑driven systems.

We are not just a .NET Community, we run our community on .NET

We are the largest Open-Source Software [OSS] community with its longest running (> 10 years) tech meetup in Bombay.

And as such we are mostly houseful [
https://twitter.com/hackmum/status/1694780944778186885?s=20]. As a community that is committed to diversity and inclusiveness, most of our efforts and time is expended on registration triaging. And the next biggest friction in our meetup management is to ensure attendee check-ins and check-outs for building/civic code adherence

So as a tech community, to solve this, we did the only thing we love to do: build an app. That too on .NET 8. We will tell you why .net8 is the best .NET yet and share what are the gotchas we had to look out for.

And we wouldn't be an OSS community, if it's not on GitHub [https://github.com/HackerspaceMumbai/Visage/issues/69]. Contributors welcome 🙏

VS Code GitHub Copilot Agent Lab

Build a Social Bingo game while mastering VS Code's Agent Mode with GitHub Copilot. Learn context engineering, custom agents, and AI-first development workflows.

⚠️ Agenda Update: VS Code GitHub Copilot Agent Lab

Due to recent changes to GitHub Copilot Individual plans, published by GitHub at the start of this week[20th April], some cloud‑based agent features may no longer be consistently available to all attendees using free or individual Copilot tiers.

As a result, we’ve had to make a last‑minute adjustment to ensure everyone still gets a high‑quality, hands‑on learning experience.

✅ What’s Changing

The VS Code GitHub Copilot Agent Lab will proceed where supported, focusing on agentic workflows and real‑world usage inside VS Code.
In parallel, we have provisioned a backup workshop: AI Agents for Beginners, designed to work without requiring Copilot cloud agents.

This ensures that every attendee—regardless of Copilot plan—can actively participate and take away practical knowledge.
🧠 Backup Workshop: AI Agents for Beginners
If cloud agent features are unavailable for your setup, you’ll be guided through:

Core concepts of AI agents and agentic workflows
How agents reason, plan, and execute tasks
Using local and in‑editor techniques to simulate agent behavior
Mental models you can apply to GitHub Copilot, MCP‑based tools, and future agent platforms

This session is beginner‑friendly, practical, and technology‑agnostic, making it a strong complement to the primary lab.

🙏 Our Apologies
We sincerely regret this late change to the agenda. The update was driven by an external product change announced close to the event date, and our priority is to ensure:

No one is blocked from participating
The workshop remains hands‑on and valuable
Everyone leaves with actionable learning

Thank you for your understanding and flexibility; we truly appreciate it.
We’re excited to build, learn, and explore the future of AI‑assisted development with you this Saturday.

Supercharge your developer productivity with GitHub Copilot and VS Code

A demo-first session for developers that shows how the latest features from GitHub Universe 2025 and VS Code Insiders turbocharge real-world workflows. Using the community blog repo as the canonical demo source and Visage to visualize Aspire/agent interactions, the session runs Speckit, Plan Mode, Agent HQ, Awesome Copilot, Copilot CLI, Dev Containers, and reproducible traces end-to-end so developers can immediately adopt and extend these patterns.

Securing a Blazor WASM app deployed on Azure Static Web App

Azure Static Web Apps [Azure SWA] is aimed at the current rage in the frontend market, SSG. It is a service that automatically builds and deploys full stack web apps to Azure from a code repository. So its super easy to deploy MVPs, PoCs, and hobby projects. But for a production app, you need to get Authentication & Authorization [IAM] perfect. This talk will deep dive into the elaborate synchronization required amongst the principals involved: code, infrastructure, and Authentication Provider; while at the same time maintaining developer productivity. Since Azure SWA is a relatively new offering and programmatic roles is a preview feature of SWA, we will also dwell on a few gotchas you need to be aware.

SDD in the Trenches: Taming Copilot Agents in Community Codebases

As GitHub Copilot agents become part of everyday development, a new bottleneck has emerged: unclear intent. When Copilot is driven by vague or non‑deterministic prompts, it generates code that is inconsistent, brittle, and misaligned with project architecture. This problem is amplified in community‑driven FOSS projects, where architectural rules are often implicit or undocumented.

In this session, we share lessons from building and maintaining Visage—our primary Spec Kit–driven platform—along with hackmum.in, our community website, by adopting Spec‑Driven Development (SDD) as the control layer for Copilot agents. Using Spec Kit and the lightweight OpenSpec framework, we show how specifications become the primary instruction set for AI—before Copilot writes a single line of code.

Instead of prompt‑first development, we demonstrate spec‑first, agent‑executed workflows that turn Copilot from a guessing engine into a predictable collaborator.

What you’ll see

Takeaways

Attendees will leave with an open‑source blueprint for using GitHub Copilot agents responsibly:

Improve determinism in AI‑assisted coding

Preserve architectural intent in community projects

Scale contributions without increasing review burden

This talk is for developers who want Copilot agents to amplify engineering discipline - not replace it.

SDD in the Trenches: Spec Kit and OpenSpec for Reliable FOSS Web Development

The shift to AI-assisted coding has revealed a critical failure point: vague requirements. When an AI agent is given a non-deterministic prompt, the resulting code is often inconsistent, brittle, and violates the project's architecture. This is especially challenging for community FOSS projects where architectural governance is informal.

This session presents a practical solution: Spec-Driven Development (SDD), using the open-source toolkit Spec Kit alongside the lightweight OpenSpec framework. This combination forces clarity by making the specification the primary, executable, and reviewable artifact.

We use hackmum.in, our community website and its Astro (JavaScript) repository as a live case study to demonstrate how to transition an existing FOSS codebase into an SDD-governed environment.

You will learn the unified FOSS-centric SDD workflow:

Establishing the Constitution: Using Spec Kit's constitution feature to define non-negotiable project principles (e.g., "Must be Astro-compatible," "All new features must pass Lighthouse accessibility standards") that guide the AI agent's decisions.

The FOSS-Friendly Artifact Model: Implementing OpenSpec's separation of specs/ (the source of truth) from changes/ (the proposal). This ensures clean, auditable diffs and makes human code review easier, which is crucial for community collaboration.

The Agent's Execution Pipeline: A live walkthrough of the Spec Kit four-phase process (Specify, Plan, Tasks, Implement) to develop a complex feature (e.g., a community event tracker), showing how the AI agent is guided by the markdown specifications to generate clean, high-quality JavaScript code.

Beyond Greenfields: Demonstrating how this methodology is superior for modifying existing functionality—the common reality of FOSS maintenance—ensuring new code adheres to the existing architecture of the hackerspaceMumbai/blog repository.

Attendees will leave with a clear, open-source blueprint for adopting Spec Kit and OpenSpec to maintain code quality, accelerate contribution velocity, and tame the chaos of AI-assisted development in any web project.

Scaling our Community Events with .NET 10, Aspire, and AI Agents

Managing a thriving Open Source Software (OSS) community is a complex orchestration of logistics, data privacy, and inclusive growth. For over a decade, the Bombay tech scene has faced the challenge of "houseful" events where manual curation is no longer feasible. Enter Visage: an open-source ecosystem built to automate and elevate community management.

In this session, we demonstrate how Visage stays at the bleeding edge by moving beyond simple LLM integrations to leveraging Azure AI Foundry and Agentic workflows. Using the Microsoft .NET AI extensions, we have built intelligent agents capable of curating registrants to ensure diversity and inclusivity while adhering to the strict data residency requirements of India’s DPDP Act.

We will explore the underlying architecture powered by .NET 10 and .Aspire, showing how we use a Shared UI Library in Blazor Hybrid to deliver a consistent experience across Web, Mobile, and Desktop.

Key Takeaways
• Orchestration with .NET Aspire:
Managing a microservices mesh (Event Management, Registrations, and AI) with seamless service discovery.
• Next-Gen AI with Foundry & Agents: Moving from prompts to Agents that handle complex curation logic and natural language interactions via Azure AI Foundry.
• Domain-Driven Integrity: Eliminating "Primitive Obsession" in high-scale systems using StructId for lexicographically sortable Ulids and Vogen for strict domain validation.
• Secure-by-Design Compliance: Handling DPDP (India's GDPR) by keeping sensitive community data within local jurisdictions through Azure Container Apps.
• Modern Testing Maturity: Achieving high reliability with TUnit, Playwright, and chaos testing via Stryker

Maximizing GitHub Copilot for OSS: Navigating the Free Plan

With the introduction of a free plan for GitHub Copilot, many developers are eager to understand how to best utilize this powerful suite of tools, despite its limitations. Are you looking to optimize your OSS projects with GitHub Copilot? Or perhaps you’re skeptical about AI’s real impact on developer productivity? It's a common sentiment, but the key lies in how you interact with GitHub Copilot.

In this session, we’ll explore GitHub Copilot as a suite of tools, showcasing when to use each one. We’ll dive into essential prompt crafting techniques that every OSS developer should master to significantly boost productivity. Learn how to maximize GitHub Copilot’s capabilities and transform your open-source projects, even with the free plan.

We'll start with a blank project and demonstrate how to leverage the Copilot suite to build a full-fledged application from scratch.

Throughout the demo, we'll discuss the strengths and weaknesses of each Copilot tool, and provide strategies for maximizing their value, even within the limitations of the free plan.

Discover how to make the most of GitHub Copilot and revolutionize your coding experience without breaking the bank!

Don't miss out on learning how to get the absolute most out of GitHub Copilot for your OSS projects!

Idea to production-ready agent in seconds on AI-native runtime

Agentic apps behave differently from traditional services. They make decisions, coordinate steps, and react to changing inputs. This session shows how to run agentic workloads on a fast, AI native runtime on Azure Container Apps. The focus is on reliability and speed so you can move from idea to production‑ready agents. We'll cover patterns for deployment, configuration, safe scaling for bursty traffic, and observability so teams can run agentic systems in production without surprises.

GitHub Copilot: Your AI Companion for Every Workflow

GitHub Copilot has evolved into a full AI teammate across the entire software development lifecycle. In this session, we explore the new agentic SDLC through live demos of Copilot in VS Code, GitHub.com, terminals, JetBrains, and more. We’ll unpack Agent Mode, Plan Agent, Coding Agent, MCP servers, custom skills, and AGENTS.md - and show how AI now supports planning, coding, testing, reviewing, modernizing, and deploying.
We’ll also cover cloud‑backed background development, app modernization for Java/.NET, and how to embed agents inside your own apps with the Copilot SDK.
This is your end‑to‑end guide to AI‑native engineering and hybrid dev teams.

Get Started with Models in Microsoft Foundry to Build AI Apps

In this hands-on lab, you will build a production-ready AI application using Microsoft Foundry, with no fine-tuning or deep machine learning expertise required. You will discover and select models, provision a Foundry project, and connect to a hosted model using the OpenAI SDK. You'll implement a comment moderation workflow, compare model outputs, and package the solution as a hosted agent using Python, ready for real-world integration.

From Zero to Deployed on Azure with AI Agents

The Deep Dive: What happens when you let AI agents do the building? In this practical lab, you'll go from an empty terminal to a deployed app on Azure-with GitHub Copilot CLI and coding agents handling the scaffolding, coding, debugging, and deployment. You'll use the latest ecosystem tools to provision resources and wire up services through natural language, no portal required.

The Takeaway: This isn't a demo you watch. You'll walk out with a real, working development workflow you can take straight to your next project

From Zero to Deployed on Azure with AI Agent

What happens when you let AI agents do the building? In this practical lab, you'll go from an empty terminal to a deployed app on Azure-with GitHub Copilot CLI and coding agents handling the scaffolding, coding, debugging, and deployment. You'll use the latest ecosystem tools to provision resources and wire up services through natural language, no portal required.

From Scratch to Smart: Building AI Chat Agents with Microsoft Agent Framework, Chainlit & GitHub Mod

In this practical workshop, you’ll learn how to design and implement a fully functional AI chat agent from the ground up. Using the Microsoft Agent Framework, Chainlit, and GitHub Models, you’ll progressively build an intelligent assistant capable of:
- Holding natural, contextual conversations
- Calling external tools (e.g., fetching live weather data)
- Integrating seamlessly with the Model Context Protocol (MCP) for extended functionality

By the end of the session, you’ll have a working agent prototype that demonstrates real-world capabilities, from answering questions to orchestrating tool calls, and a clear roadmap for extending it into production-ready solutions.

This workshop is ideal for developers, students, and AI enthusiasts eager to gain hands-on experience with modern agent frameworks and practical integrations. Bring your laptop and curiosity: we’ll provide the code, guidance, and inspiration to get your agent up and running.

From Pair Programmer to AI Teammate: AI Assisted Development in the Agentic SDLC

AI assisted development has evolved far beyond code completion. In 2026, it is no longer just a pair programmer - it is an AI teammate embedded across the entire software development lifecycle.
In this session, we’ll explore how modern developers and teams can embrace the Agentic SDLC, where humans and AI agents collaborate to plan, build, test, review, modernize, and deploy software. Using real‑world demos, we’ll look at how GitHub Copilot integrates seamlessly across VS Code, GitHub.com, terminals, and cloud workflows to support both synchronous and asynchronous development.
We’ll cover:

The evolution of GitHub Copilot from autocomplete to agentic workflows
Using Agent Mode in VS Code for complex, multi‑file tasks
Delegating background work using the GitHub Copilot Coding Agent
Leveraging MCP (Model Context Protocol) servers and custom instructions to provide richer context to AI agents
Practical workflows for code review, testing, and app modernization
How hybrid teams (developers + agents) are reshaping day‑to‑day engineering

This session is demo‑driven, practical, and opinionated, focusing on how GitHub Copilot is used in real development environments- not theory or future promises.
Whether you’re new to GitHub Copilot or already using it daily, you’ll leave with a clear mental model for AI‑native engineering and concrete ideas to apply agentic workflows in your own projects.

From Dough to Deployment: Building a Pizza Ordering Agent with Microsoft Foundry & MCP

Hungry for practical AI agent skills? 🍕 In this workshop, participants will learn how to design and deploy domain-specific agents using Microsoft Foundry Agent Service. Starting from a simple baseline agent, you’ll progressively enhance it with:
- System prompts & custom instructions to shape behavior
- Retrieval-Augmented Generation (RAG) for knowledge integration
- Tool calling (e.g., a pizza calculator) to extend functionality
- MCP (Model Context Protocol) connections to external services for live menu and order handling.

By the end of the session, you’ll have built your very own Contoso PizzaBot: an intelligent agent capable of answering customer questions, recommending pizzas, and managing orders in real time.

This workshop is ideal for developers, AI enthusiasts, and students who want hands-on experience with agent frameworks and practical integrations. Bring your laptop and appetite for learning — we’ll serve up both code and pizza logic!

Distributed Intelligence: Human-in-the-Loop Multi-Agent Systems with MCP

Most AI agent demos stop at autonomous task execution. Real-world systems must balance autonomy with identity, governance, fairness, and human accountability.
In this session, I'll share lessons from building Bethuya, a cloud-native, multi-agent platform used to plan, curate, and operate large-scale technical community events. We'll explore how agents collaborate through MCP, use trusted tools and knowledge sources, and remain governed by explicit human approval workflows rather than opaque decision-making. Inspired by production challenges such as cohort curation, scheduling, and operational planning, the architecture combines agent orchestration, secure identity, observability, and human-in-the-loop controls to create systems that users can trust.
Attendees will leave with practical patterns for building secure, auditable, cloud-native agent systems that go beyond chatbot demos and are ready for real-world adoption.

Developer Tools & Frameworks: From CLI to PR: Automating the Path to Merged Code

Everyone talks about agents, but the real challenge is applying them to daily sprints. Moving beyond conversational chat, this session shows how GitHub Copilot functions as a true agentic partner in your workflow by live-coding a full cycle-from planning in the terminal to delegating work to the cloud and automating PR reviews.

What You'll Learn: No high-level abstractions here. We are breaking down the strict technical mechanics: context management, advanced features with Copilot CLI, and the specific architecture patterns that make agentic development workflows actually stick in production.

Building Model Context Protocol (MCP) Servers for Developers

A hands-on, outcome-driven workshop for Python* developers to understand, build, and extend Model Context Protocol (MCP) servers: unlocking new possibilities in AI-assisted learning and research.

🎯 What You'll Build

1. 🐍 Python Study Buddy App
An interactive console-based learning companion powered by a custom MCP server. It adapts to beginner, intermediate, and expert levels to help developers master Python concepts.
Core Outcomes:
- Configure a custom MCP server tailored for Python learning
- Model learning concepts using Python dataclasses
- Build interactive study sessions with progress tracking
- Generate personalized coding challenges and explanations
- Explore how AI assistants can enhance developer education
Key Learning Objectives:
- Build a basic MCP server in Python
- Use prompts effectively with MCP
- Integrate basic tools into MCP workflows

2. 🧠 AI Research Learning MCP Server
A personalized research assistant that discovers trending AI/ML papers, summarizes breakthroughs, and generates study plans—powered by an advanced MCP server.
Core Outcomes:
- Create an AI/ML research paper discovery service
- Implement tools for summarization, ranking, and trend detection
- Automate personalized study plan generation
- Store daily research notes in a GitHub repo
Key Learning Objectives:
- Connect to and use external MCP servers
- Add and manage resources with MCP
- Automate tasks and workflows using MCP

This workshop is ideal for Python* developers curious about agent frameworks, AI-enhanced tooling, and building reproducible, intelligent assistants. Participants will leave with two fully functional MCP servers and the skills to extend them for their own use cases.

* We can customize this for JS and C# folks too.

Building a RAG with PostgreSQL

Explore leveraging intelligent functionalities within a managed PostgreSQL service on Azure. This guide covers environment setup, data introduction, and the application of AI-powered features to improve your solutions.

Build your first AI Agent Service

Dive into the world of intelligent conversational agents with Azure AI Agent Service, a seamless blend of service and SDK that simplifies the development of robust AI-driven solutions. In this hands-on workshop, you’ll learn to create a powerful agent capable of answering sales-related queries, performing data analysis, generating visualizations, and integrating external data sources to deliver enhanced business insights.

Build your code-first app with Azure AI Agent Service

A practical, code-first workshop that teaches developers how to build, test, and operate semi‑autonomous AI agents using the Azure AI Agent Service. Participants will deploy end‑to‑end agents, connect memory and knowledge sources, instrument behavior with traces, and create CI pipelines for reproducible agent runs they can reuse in real projects

AI Agents for Beginners: Building Your First Intelligent Agent

AI agents are rapidly becoming the backbone of modern applications: from copilots that assist developers to autonomous systems that solve real-world problems. This hands-on workshop introduces participants to the fundamentals of AI agents using the open-source AI Agents for Beginners curriculum by Microsoft.

In this workshop, attendees will learn how to:
- Understand the core concepts behind agentic AI systems
- Build simple agents that can reason, plan, and act
- Explore frameworks and tools that make agent development approachable
- Experiment with practical scenarios to see agents in action

Whether you’re a student, developer, or curious technologist, this workshop will demystify agentic AI and empower you to start building your own intelligent systems.

AI Agents for Beginners

This workshop provides fundamental knowledge and applied samples for building AI Agents.

A DevOps Guide to Building Cloud-Native AI ready apps with .NET Aspire

We increasingly build distributed backends powering our applications – involving multiple services, APIs, databases, and real-time communication. Managing this complexity, especially during the local development loop, can significantly impact productivity and time-to-market. Join me as I dive into .NET Aspire, a powerful framework for cloud-ready stack designed to tackle these challenges head-on, through the lens of Visage - an open-source event management platform designed for OSS communities. In this talk, I’ll break down how .NET Aspire streamlines development with features like service discovery, dependency injection, and Blazor Hybrid integration, making it a go-to for core developers tackling scalable projects. Drawing from my FOSSAsia 2025 talk in Bangkok on Identity and Access Management (IAM), I’ll also show how we implemented secure authentication and access control in Visage, ensuring robust security without compromising performance. Expect practical insights, code snippets, and lessons learned from building Visage, equipping you to leverage .NET Aspire in your own web and app development workflows." Also, I will demonstrate how it embraces and works seamlessly with apps written in node.js, Python. Forget abstract concepts; we'll focus on how Aspire delivers tangible benefits for Core Developers: 1. Accelerated Inner Loop: See how Aspire's application host and orchestration simplify running and debugging multi-service backends (like Visage's web, AI, and comms components) locally, letting you iterate faster. 2. Integrated Observability: Explore the Aspire Dashboard – a powerful tool providing unified logs, distributed traces, and metrics across all your backend services, drastically simplifying debugging of distributed behaviors. 3. Simplified Service Interaction: Learn how Aspire streamlines service discovery, handles transient faults with built-in resilience patterns, and standardizes communication between your backend services (e.g., a web frontend reliably calling a backend API service). 4. Effortless Dependency Management: Understand how Aspire helps manage essential backing services like databases, caches, or messaging queues directly within your local development environment. You'll walk away with practical knowledge on how .NET Aspire can help you reduce boilerplate, gain better insights into your running system, and ultimately ship complex, distributed applications more efficiently.

A Developer’s Guide to Building Cloud-Native AI ready apps with .NET Aspire

We increasingly build distributed backends powering our applications – involving multiple services, APIs, databases, and real-time communication. Managing this complexity, especially during the local development loop, can significantly impact productivity and time-to-market.

Join me as I dive into .NET Aspire, a powerful framework for cloud-ready stack designed to tackle these challenges head-on, through the lens of Visage - an open-source event management platform designed for OSS communities. In this talk, I’ll break down how .NET Aspire streamlines development with features like service discovery, dependency injection, and Blazor Hybrid integration, making it a go-to for core developers tackling scalable projects. Drawing from my FOSSAsia 2025 talk in Bangkok on Identity and Access Management (IAM), I’ll also show how we implemented secure authentication and access control in Visage, ensuring robust security without compromising performance. Expect practical insights, code snippets, and lessons learned from building Visage, equipping you to leverage .NET Aspire in your own web and app development workflows." Also, I will demonstrate how it embraces and works seamlessly with apps written in node.js, Python.

Forget abstract concepts; we'll focus on how Aspire delivers tangible benefits for Core Developers:

1. Accelerated Inner Loop: See how Aspire's application host and orchestration simplify running and debugging multi-service backends (like Visage's web, AI, and comms components) locally, letting you iterate faster.

2. Integrated Observability: Explore the Aspire Dashboard – a powerful tool providing unified logs, distributed traces, and metrics across all your backend services, drastically simplifying debugging of distributed behaviors.

3. Simplified Service Interaction: Learn how Aspire streamlines service discovery, handles transient faults with built-in resilience patterns, and standardizes communication between your backend services (e.g., a web frontend reliably calling a backend API service).

4. Effortless Dependency Management: Understand how Aspire helps manage essential backing services like databases, caches, or messaging queues directly within your local development environment.

You'll walk away with practical knowledge on how .NET Aspire can help you reduce boilerplate, gain better insights into your running system, and ultimately ship complex, distributed applications more efficiently.

.NET Conf 2025 Recap — The AI-First Future of .NET

A fast-paced, insight-rich recap of .NET Conf 2025, spotlighting how AI is reshaping the .NET ecosystem: from developer tooling to intelligent apps. This session distills the most impactful announcements and demos, with a pragmatic lens for community builders, educators, and enterprise developers.

🔍 What We’ll Cover

1. .NET 10 and the AI-Ready Runtime
- Performance and security upgrades for AI workloads
- New primitives for integrating AI agents and context-aware services
- Enhanced support for model hosting and inference pipelines

2. Visual Studio 2026: Your AI Pair Programmer
- Deep GitHub Copilot integration for Razor, Hot Reload, and diagnostics
- AI-assisted testing, upgrade paths, and refactoring
- FluentUI redesign for faster, more intuitive workflows

3. Aspire: Cloud-Native AI Workloads Made Simple
- How Aspire simplifies microservice orchestration for AI-first apps
- Built-in support for MCP agents, vector stores, and model endpoints
- Developer-first diagnostics and service composition

4. Visage-Powered Demos: AI in Action
- Live walkthrough using Visage to visualize Aspire service maps
- Real-time tracing of MCP agent interactions across services
- How Visage helps debug, demo, and teach AI-native architectures

5. MCP and Agent Frameworks in .NET
- How .NET is embracing Model Context Protocols (MCP)
- Building intelligent assistants with .NET and OSS tools
- Use cases for education, research, and enterprise automation

Augustine Correa

Actions

Links

Area of Expertise

Augustine Correa

Links

Actions