Alon Fliess
Microsoft Regional Director, Foundry MVP, ZioNet CTO
Tel Aviv, Israel
Actions
Alon Fliess is a Microsoft Regional Director and Microsoft Foundry MVP with over 30 years of experience in software architecture. As the CTO and Founder of ZioNet, he specializes in Azure, AI integration, and scalable microservices systems. A frequent speaker at major global conferences, Alon recently delivered a lecture at Microsoft Build 2025 and served as a Subject Matter Expert at the Microsoft Foundry booth at Ignite 2025. He is the author of the book " Architecting Scalable Solutions " and a recognized community leader.
Speaker Highlights: Alon is a veteran speaker who delivers technical deep-dives and architectural insights at the world's premier developer conferences.
Microsoft Build 2025: Featured Lecturer.
Microsoft Ignite 2025: Expert at the Microsoft Foundry booth.
Regular Speaker at: NDC, VSLive!, DeveloperWeek, and other major international events.
Technical Expertise & Authority: Alon bridges the gap between high-level architecture and code-level implementation.
Microsoft Regional Director (since 2010) and MVP (since 2005).
Expertise: Cloud Architecture (Azure), AI/ML Integration, Microservices, and IoT.
Community Leader: Leads the Azure Israel developer community.
Links
Area of Expertise
Topics
Mastering MCP in C#: Advanced Patterns, Sampling, and "Brain Borrowing"
They say the Model Context Protocol (MCP) is the "USB-C for AI"—a standard to connect models to data. But if you treat MCP like a simple REST API, you are missing 80% of its potential.
A standard API is passive; it waits to be called. An MCP Server is active—it is like a robotic arm plugged into the AI's nervous system. It doesn't just execute commands; it can "borrow" the AI's brain to reason, plan, and adapt on the fly.
In this advanced, code-heavy session, we will skip the "Hello World" demos and go straight into the IDE to architect a production-grade Windows Diagnostic Agent using C# and the .NET MCP SDK.
We will live-code the implementation of Advanced MCP Capabilities:
The Bi-Directional Architecture: Moving beyond simple tools to build servers that can query the host, requesting user confirmation or additional context via Elicitation.
The "Brain Borrowing" Pattern: A deep dive into Sampling—the killer feature that allows your C# tool to send a prompt back to the LLM to generate dynamic code or queries on the fly (e.g., writing a custom PowerShell script to solve an unforeseen error).
Security & Feedback: Implementing Roots to define filesystem boundaries and Notifications for real-time agent feedback.
Scalable Transport: Switching from Stdio to Streamable HTTP (SSE) to prepare your agent for cloud deployment.
This session is for architects and senior C# developers who have completed the theory and want to see the actual code required to build autonomous, state-aware agents.
Key Takeaways
Beyond the Basics: Master the "hidden" features of MCP (Sampling, Roots, Elicitation) that enable true agency.
Architectural Pattern: Learn the "Brain Borrowing" pattern—how to offload cognitive load from your C# logic to the LLM during tool execution.
Production C#: Walk away with a reference implementation for a stateful, secure MCP server using the official .NET SDK.
Session Details (The Small Print)
Target Audience: Senior C# Developers and Software Architects.
Technical Level: 400 (Deep Dive / Code-Heavy).
Prerequisites: Proficiency in C# and .NET. Familiarity with the basic concept of MCP or AI Tools is recommended.
Format: 20% Architecture / 80% Live Coding & Code Walkthrough.
Note to Organizers: This session requires a high-resolution projector as we will spend significant time reading code in Visual Studio/VS Code.
The Agentic Revolution: From Code Builders to System Rulers
We are standing at the event horizon of a vertical shift in software engineering. The transition from Generative AI to Agentic Systems is not just a platform upgrade; it is a fundamental rewrite of our profession, moving us from deterministic code builders to probabilistic "System Rulers." In this session, we will navigate the 2026 landscape where AI is no longer just a tool, but a universal employee that requires a new kind of governance. We will explore how to tame the chaos of "vibe coding" through Spec-Driven Engineering—a rigorous methodology in which natural-language specifications serve as the single source of truth for autonomous agents. Beyond theory, we will architect the complete solution using the Microsoft Agents Universe: designing in Foundry, deploying stateful resources via the Agent Service, and connecting tools with the Model Context Protocol (MCP). Finally, we will address the critical "Anti-Shadow AI" challenge, demonstrating how to secure your digital fleet with Entra ID and Agent 365. Join us to learn how to stop building the machine and start ruling it.
Key Takeaways
The Mindset Shift: Understand the transition from "Deterministic Code Building" to "Probabilistic System Ruling," and what it means to govern a workforce of autonomous agents.
Spec-Driven Engineering: Learn how to eliminate the fragility of "Vibe Coding" by using rigorous, natural-language specifications as the compilation target for Agentic Systems.
The Microsoft Agent Stack: Master the architecture of the Microsoft Agents Universe, including designing in Foundry, hosting via the Agent Service, and connecting tools using the Model Context Protocol (MCP).
Governance & Security: Discover how to solve the "Shadow AI" problem by securing agents with Entra ID and managing the agent lifecycle through Agent 365.
Target Audience: Software Architects, CTOs, VP R&D, Senior Developers, and Engineering Leaders transitioning from traditional software design to AI-driven systems.
Preferred Session Duration: 60 Minutes (Flexible: 45–75 minutes).
Technical Requirements: Standard projector (HDMI/USB-C) and stable Internet connection (for live cloud-based demos of Microsoft Foundry and Agent 365).
Level: Advanced / Architectural Strategy (Level 300-400).
First Public Delivery: Agentic Architecture Day 2025 (Tel Aviv).
Developing Agentic Systems in .NET: From Concept to Code
Chatbots just talk; Agents act. We are leaving the era of passive AI assistants and entering the age of Agentic Systems—intelligent applications that perceive, plan, and execute complex goals. For the .NET developer, this is not just a new library; it is a fundamental architectural shift.
In this practical, code-focused session, we will use C# and the Microsoft Agent Framework (MAF) to build robust, autonomous agents. We will move rapidly from theory to implementation, telling the story of a production-ready agent through its four essential components. We start by constructing the Brain, implementing reasoning loops, memory, and state management using standard .NET abstractions. Once the agent can think, we give it Hands to interact with the real world, using the MAF function call capability and the Model Context Protocol (MCP) to connect to APIs, databases, and local systems securely.
As needs grow, we scale from a single agent to a Team, demonstrating how to orchestrate complex multi-agent workforces using patterns like Group Chat and Handoffs. Finally, we establish the Habitat, exploring diverse strategies for deploying stateful agents—whether self-hosted in ASP.NET Core and Azure Functions, or running on the fully managed Microsoft Agent Service (Foundry). We will conclude by securing this digital fleet with Agent 365, demonstrating the critical role of auditing and governance in the enterprise.
Target Audience: .NET Developers, Software Architects, and Engineering Leads.
Preferred Session Duration: 60 Minutes (Can be adapted to 45–75 minutes).
Technical Level: 300–400 (Code-heavy / Architectural).
Prerequisites: Familiarity with C# and basic Azure concepts. Knowledge of Generative AI basics (Prompts/LLMs) is helpful but not required.
First Public Delivery: .NET Conf Israel 2025.
Key Takeaways:
Cognitive Architecture: How to map the "Perception → Planning → Action" loop directly to C# code.
Universal Connectivity: Mastering the Model Context Protocol (MCP) to decouple your agents from their tools.
Production Ops: Practical patterns for hosting (including the new Microsoft Agent Service) and governing agents safely.
Zero Code: How I Built a Cross-Platform Game without Writing a Single Line of C#
We hear that "AI will write the code." So I put it to the ultimate test. I tasked an AI Agent with porting my legacy Windows strategy game to a modern .NET MAUI app on iOS, Android, and Windows. But I added one strict rule: I will not write a single line of code.
No quick fixes, no "I'll just tweak this function." If the UI broke, I had to write a Spec, not a patch. In this session, I will show you why this was the hardest thing I have ever done—and why it is the future of software engineering.
We will move from the failure of "Vibe Coding" (where the agent hallucinated spaghetti code) to the discipline of Spec-Driven Development. You will see how I architected a system where the Agent didn't just read errors—it "looked" at the app. I implemented an automation suite that captured screenshots on failure, creating a visual feedback loop that allowed the Agent to see UI glitches and fix them autonomously.
We will cover:
The "Handcuffs" Experiment: The agony of resisting the urge to code, and how it forced me to become a better Architect.
The "Steering Document": Replacing prompts with a living Constitution that prevented context drift.
Multimodal Debugging: How I built a pipeline where the Agent runs UI automation tests, analyzes the resulting screenshots, and self-corrects visual bugs.
The Result: A live demo of a game shipped 100% by AI, governed 100% by a human.
Target Audience: Developers, Architects, and Engineering Managers who are skeptical about AI's ability to handle complex, real-world engineering tasks.
Preferred Session Duration: 45–60 Minutes.
Technical Requirements:
Stable Internet connection (Critical for live AI Agent interaction).
Projector (HDMI/USB-C) for code and mobile emulator display.
Audio output (The demo includes game sound effects).
Theme Alignment: Fits tracks related to AI Engineering, .NET MAUI / Cross-Platform, and Software Architecture.
Key Takeaways
Discipline Over Syntax: Why the inability to write code forces you to master Architecture and Specification.
Visual Agents: How to implement Multimodal Testing (Logs + Screenshots) to let agents solve UI problems.
The "Steering" Methodology: Master the art of Spec-Driven Development by replacing vague prompts with a living "Steering Document" (Constitution) that prevents context drift and hallucination.
Architecting the Moving Target: Future-Proofing Smart Cities with Hybrid Agentic Design
As architects, we are paralyzed by a single question: "How do we design a massive, multi-year system today that won't be obsolete when AI changes everything in six months?"
In this deep architectural session, I will deconstruct the Blueprint of a Next-Gen Smart City Management System—an enterprise-scale platform architected in late 2025 to survive the uncertainty of the "Agentic Era." We will explore our "Hybrid Philosophy": designing a system where Deterministic Processes handle critical safety tasks (Incident Management). At the same time, Probabilistic AI Agents are integrated as first-class citizens for insight and decision support.
We will dismantle the architectural layers that make this future-proofing possible:
The Hubs: How we designed Integration Hubs to act as an Anti-Corruption Layer, responsible for the edge systems, while abstracting them via a collection of Digital Twins, shielding the core from hardware chaos. Each Hub exposes two interfaces: an API for deterministic processes and a Model Context Protocol (MCP) endpoint for Agents.
Logic as Configuration (The Core): Why we banished hardcoded business logic from the Core. We will show how BPM (Business Process Management) and BRE (Business Rules Engines) provide the flexibility of a NoCode/LowCode foundation and serve as a bridge to execute agentic code. Agents are invoked as specific "Tasks" within a rigid workflow, ensuring they operate within safe boundaries.
The Knowledge Bridge: How the architecture leverages Microsoft 365 and Integration Hubs not just for data storage, but as a semantic knowledge graph that allows Agents to "read" the city’s status and "reason" about infrastructure.
Safe Agency: Strategies for Identity and Governance. We will discuss how Agents are assigned Entra ID identities and how the system enforces mandatory Human-in-the-Loop gates for physical world actions (e.g., shutting down a water main).
This is a masterclass in placing the right architectural bets today to ensure your system remains relevant in 2030.
Target Audience: Software Architects, CTOs, and Engineering Leads responsible for long-lifecycle enterprise systems.
Technical Focus: Distributed Systems, IoT Architecture, BPM/BRE, Model Context Protocol (MCP), Entra ID.
Level: 300-400 (Architectural Strategy & Patterns).
Duration: 60 Minutes.
Key Takeaways
The Hybrid Pattern: How to weave Deterministic Workflows (BPM) with Probabilistic Agents without compromising safety.
Future-Proof Integration: Implementing Hubs and MCP to decouple your core domain from the rapidly changing edge.
Governance Architecture: Practical patterns for Identity, Permissions, and Human-in-the-Loop in an Agentic system.
Alon Fliess
Microsoft Regional Director, Foundry MVP, ZioNet CTO
Tel Aviv, Israel
Links
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