What's Inside
- What Microsoft's Azure AI Foundry Workshop actually covers, stage by stage
- Why it's now archived — and what that does and doesn't change about its value
- Where it fits next to the platform and governance content we've already written
- What we'd tell a team using it as a real starting point today
Microsoft publishes a lot of learning material for Azure AI Foundry, and most of it is scattered across docs pages, sample repos, and conference talks that go stale the moment nobody's watching them. The Azure AI Foundry Workshop is a more deliberate attempt: a single, sequential, hands-on path — 4 to 5 hours, entirely in Python notebooks — that takes you from authentication through a complete end-to-end agent application. It's also, as of this writing, archived. Both facts matter, and neither one cancels the other out.
What the Workshop Actually Covers
The repository is organized as three stages, meant to be worked through in order:
Introduction (1-introduction/) — authentication setup, environment configuration, and a quick-start pass to confirm your Azure AI Foundry access actually works before you build anything on top of it.
Main workshop (2-notebooks/) — the substantive part, split across three notebooks: chat completion and retrieval-augmented generation (RAG), agent development against the Azure AI Agent Service, and a module on quality attributes, observability, and evaluation using Azure's evaluation framework and Azure Monitor OpenTelemetry integration. That last module is the one most workshops skip — plenty of tutorials show you how to get an agent to respond, far fewer show you how to tell whether its responses are actually any good.
End-to-end project (3-ai-native-e2e-sample/) — a complete sample application that pulls the pieces together, running throughout on a health-and-dietary-advice example domain rather than the generic "customer support bot" every other tutorial reaches for.
The full stack it exercises: Azure AI Foundry's SDK and platform, the Azure AI Agent Service, Azure OpenAI model deployment, Azure AI Search, Bing Search grounding, and Azure's evaluation and observability tooling. If you want the code-level mechanics of what those pieces look like wired together, this is a genuinely useful reference — MIT-licensed, so there's no ambiguity about reusing it.
It's Archived — Here's What That Actually Means
Worth being direct about this rather than glossing over it: GitHub's own repository status shows Azure/ai-foundry-workshop was archived by Microsoft on September 14, 2026, and is now read-only — no new commits, no issue triage, no pull requests. That's a fact worth knowing before you invest the 4-5 hours, not something to discover halfway through when a notebook cell throws an error against a changed API.
What archiving doesn't do is delete the value of the code that's there. The concepts — how chat completion and RAG fit together, how the Agent Service expects to be called, how evaluation and observability get wired into an agent instead of bolted on afterward — don't expire because nobody's maintaining the repo anymore. What it does mean is that if a notebook cell fails against a since-changed API surface, there's no one coming to fix it, and you should check current Microsoft Foundry SDK documentation before copying any specific call into something you're shipping. Read it as a snapshot of a correct pattern as of its archive date, not a living reference.
Where This Fits Next to the Platform Work
This workshop teaches the application layer — the actual code that calls the SDK, builds the agent, and evaluates its output. It deliberately doesn't touch the layer underneath: how that agent gets deployed with governed identity and networking, or how an organization keeps a second and third team's agents from becoming an ungoverned sprawl once the first one works. That's the gap our own Azure AI Landing Zones write-up and running agentic AI at enterprise scale cover — and it's the same split we described in standing up a governed agentic AI platform for an oil & gas environment: the platform has to exist before the use case, and the use case still needs someone who actually knows how to write the agent code that runs on it.
A workshop like this one is a reasonable way to build that second kind of knowledge — how to actually write the agent — as long as it's paired with someone thinking about the first kind, the governed platform it's going to run on.
What We'd Tell a Team Using It Today
- Treat the archived status as a scoping decision, not a disqualifier — fine for learning and prototyping, but verify any SDK call against current docs before it reaches production
- Do the evaluation and observability notebook, not just the agent-building ones — it's the module most workshops skip, and it's the one that actually tells you whether an agent is good, not just functional
- Pair this with a real platform story — identity, networking, governance — before the resulting agent goes anywhere near production traffic
- If you want something still actively maintained instead, Microsoft's agentic-ai-lab covers similar ground and, as of this writing, isn't archived
If you're trying to move from a working notebook to a governed platform teams can actually build on, see our Agentic DevOps work, or book a discovery call.
Kevin Evans
Fractional CTO & Founder, Code To Cloud Inc.
Kevin Evans is a fractional CTO and technology advisor based in Calgary, Alberta. He spent nearly five years at Microsoft — rising to Senior Solutions Engineer — leading cloud and AI platform strategy, and now leads enterprise and mid-market engagements at Code To Cloud. More about Kevin
Frequently Asked Questions
Is the Azure AI Foundry Workshop still available to use?
Yes, but with a caveat worth knowing before you start: GitHub's own archive flag on Azure/ai-foundry-workshop shows it was archived by Microsoft on September 14, 2026, and is now read-only. The code and notebooks are still there and MIT-licensed, but there's no one merging fixes or updating it for API changes going forward.
What does the workshop actually teach?
Three stages: environment and authentication setup, a main workshop covering chat completion and RAG, agent development against the Azure AI Agent Service, and evaluation/observability — then a complete end-to-end sample application that ties all three together. It's entirely Python, delivered as Jupyter notebooks, built around a running health-and-dietary-advice example.
Is it worth using if it's archived and unmaintained?
For learning the concepts and reading real, working code against the Azure AI Foundry SDK, yes — an archived MIT-licensed repo doesn't stop teaching. What it can't do is guarantee the exact SDK calls still match the current API surface, since nobody's merging updates. Treat it as a snapshot of a working pattern from its archive date, and check current Microsoft Foundry SDK docs before copying code into anything production-bound.
What are the prerequisites for the workshop?
Python 3.10 or higher, an active Azure subscription with AI Foundry access, the Azure CLI and Git, a development environment (VS Code, GitHub Codespaces, or Jupyter), and GPT and embedding models already deployed in Azure AI Foundry. Budget 4-5 hours for the full path.
How does this relate to Code To Cloud's other Microsoft Foundry and AI Landing Zones content?
This workshop teaches the application/SDK layer — writing the agent code itself. Our other content covers the platform layer underneath it: Azure AI Landing Zones for the governed infrastructure an agent runs on, and enterprise governance patterns for running many agents safely at scale. The workshop is a reasonable place to learn the code; the platform and governance decisions still need to come from somewhere else.
