The demonstration program discussed (and used) in the previous blog posts ran entirely locally as a console application. This week I set out to migrate it to Foundry. To do so, I enlisted the help of Bruno Capuano and Jon Galloway, both of Microsoft, and, of course, Copilot, as documented in these videos (part 1 and part 2).

The change log is here. The architectural design can be found here. The complete demonstration solution is here.

The tl;dr is that we created projects for each of the four agents and deployed them individually to Foundry. The rest of the code stayed on the local machine. Each agent is independently deployed and each has its own managed compute and its own Entra ID, exposing an OpenAI-compatible /responses endpoint (as explained in the architectural design document).

The demonstration program will continue to evolve, but this marks a significant milestone… let’s call it version 3.0 (1.0 was LangChain/Python, 2.0 was the port to Microsoft Agent Framework/C#)

tl;dr
Copilot code review gives every pull request a fast, consistent first pass — catching typos, missing null checks and small bugs so human reviewers can focus on architecture, design and higher‑risk decisions.

What is Copilot code review?
Copilot code review is an AI‑powered reviewer that runs inside your pull‑request workflow (GitHub and integrated Azure DevOps/Azure Repos). It reads the PR diff (and respects repository custom instructions, if configured), posts inline comments as the user “GitHub Copilot,” and — where applicable — offers suggested fixes you can apply as commits directly from the PR UI. The goal is a fast, consistent first pass on correctness, style, security and maintainability so humans can spend their time on higher‑value review work.

I wanted to deploy my demonstration program, a local console application, to Foundry. The short answer is that without a front end (e.g. a Blazer Application) it made sense only to host the agents (and the tool) on Foundry, and leave the actual application on my local machine.

To do this, I consulted with Bruno Capuano and Jon Galloway, both of Microsoft. The result is a video that you can find here: Microsoft Agent Framework and Foundry Part 2.

tl;dr
How do you reliably combine deterministic business logic, parallel retrieval, and noisy LLM calls in production? The Microsoft Agent Framework answers this by modeling workflows as directed graphs: Executors (the nodes) perform the work, and Edges (the connections) define how strongly‑typed messages move between them. That separation makes orchestration explicit, testable, and observable.

Why the graph model matters
Treating a workflow as a directed graph of Executors and Edges gives you:

tl;dr
GitHub Spec Kit is a lightweight toolkit and workflow designed to make Spec‑Driven Development (SDD) practical.

Specify (Spec Kit) scaffolds a spec‑first process, provides templates and editor/agent slash‑commands, and produces a set of structured artifacts (constitution.md, spec.md, plan.md, tasks.md) that become the single source of truth for design, implementation, and verification. By converting human intent into predictable, machine‑readable inputs, Specify helps teams align product intent, engineer implementation, AI coding agents, and CI checks — shortening the product‑to‑code loop while improving traceability and cross‑discipline collaboration.

Microsoft’s Agent Framework treats retrieval as a first‑class capability so agents can fetch only what they need (or always fetch), attach source metadata, and call search as a tool during reasoning. The result: more efficient, auditable, and controllable Retrieval‑Augmented Generation (RAG) for production assistants.

tl;dr

• Microsoft Agent Framework implements RAG via TextSearchProvider (an AIContextProvider) and a Semantic Kernel bridge to many vector stores.
• Two retrieval modes: BeforeAIInvoke (automatic injection) and OnDemandFunctionCalling (agent calls search as a tool).
• Recommended starting defaults: top_k = 3–5, chunk size ≈ 500–1,000 characters with 10–20% overlap, and prefer OnDemandFunctionCalling for cost/latency control.
• Key production concerns: chunking, metadata for citations, latency and cost management, freshness, security and telemetry.

~2 hours a day for 16 weeks + 3 projects. Excellent program.

Our friends at Microsoft have paired Copilot with Microsoft Agent Framework. This powerful combination allows developers to create intelligent agents that can automate tasks, enhance productivity, and streamline workflows. This blog post will explore how to effectively use GitHub Copilot with the Microsoft Agent Framework, covering key features, real-world use cases, installation steps, and practical examples.

When it comes to deploying Microsoft Agent Framework applications, Microsoft Foundry offers a robust platform that simplifies the process. This guide will walk you through one approach to deploying your application.

If you want to hold costs down, efficient resource management is paramount. One of the critical resources in AI applications is token usage. Tokens are the basic units of text that models process, and managing them effectively can lead to significant cost savings and improved performance. This post explores various techniques for measuring and minimizing token usage within the Microsoft Agent Framework.

In the previous blog post I mentioned Neo4j. In this post I will provide an overview of this important framework.

A Graph Database

In the era of big data, the way we store and manage information has evolved significantly. Traditional relational databases, while effective for many applications, often struggle with complex data relationships. Enter Neo4j, a leading graph database that allows users to model and query data in a way that reflects real-world relationships. This guide will walk you through the essentials of using Neo4j, from installation to practical applications, ensuring you have a solid foundation to leverage this powerful tool.