{"id":5607,"date":"2026-07-30T10:18:53","date_gmt":"2026-07-30T17:18:53","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/agent-framework\/?p=5607"},"modified":"2026-07-30T10:18:53","modified_gmt":"2026-07-30T17:18:53","slug":"building-agent-teams-with-agent-framework-github-copilot-cli-and-squad","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/agent-framework\/building-agent-teams-with-agent-framework-github-copilot-cli-and-squad\/","title":{"rendered":"Building agent teams with Agent Framework, GitHub Copilot CLI and Squad"},"content":{"rendered":"

Microsoft Agent Framework supports creating agents that use the\u00a0GitHub Copilot SDK<\/a> as their backend. GitHub Copilot agents provide access to powerful coding-oriented AI capabilities, including shell command execution, file operations, URL fetching, Model Context Protocol (MCP) server integration, and can be integrated into your existing development pipeline.<\/p>\n

using GitHub.Copilot;\r\nusing Microsoft.Agents.AI;\r\nusing Microsoft.Extensions.AI;\r\n\r\nAIFunction weatherTool = AIFunctionFactory.Create((string location) =>\r\n{\r\n    return $\"The weather in {location} is sunny with a high of 25C.\";\r\n}, \"GetWeather\", \"Get the weather for a given location.\");\r\n\r\nawait using CopilotClient copilotClient = new();\r\nawait copilotClient.StartAsync();\r\n\r\nAIAgent agent = copilotClient.AsAIAgent(\r\n    tools: [weatherTool],\r\n    instructions: \"You are a helpful weather agent.\");\r\n\r\nConsole.WriteLine(await agent.RunAsync(\"What's the weather like in Seattle?\"));<\/code><\/pre>\n
We recently shipped this integration to v1.0 in C# and Python – fully supported and stable. Find out more here: MS Learn | Agent Framework | GitHub Copilot Agents <\/a>and check out the samples here: .NET<\/a> | Python<\/a><\/p>\n
A great example of using MAF and GitHub Copilot together is Squad. Squad<\/strong> is an open-source multi-agent framework that runs on top of the GitHub Copilot CLI\/SDK \u2014 you describe a small team (a coordinator plus a few specialists, each with a charter), and the coordinator dispatches the work, lets the specialists argue, and ships a result. (aka.ms\/copilot-squad<\/a>). What gets interesting is the combination <\/strong>of MAF and Squad: MAF gives you the agent runtime, model abstraction, hosting, and telemetry; the GitHub Copilot CLI\/SDK gives you a coding agent that already knows how to read repos, edit files, and run shells. Wire them together in one .NET app and you get to enjoy both worlds in the same IServiceCollection.<\/p>\n
Because Squad already runs on the Copilot CLI\/SDK and MAF has a first-party adapter for it, the bridge between them is almost free. Squad.Agents.AI<\/strong> is a small NuGet that wraps a Squad team as a regular MAF AIAgent. You wire it into your IServiceCollection like any other agent, MAF treats it as a peer, and Squad keeps orchestrating underneath.<\/p>\n
The integration in C#<\/h3>\n
using Microsoft.Agents.AI;\r\nusing Microsoft.Extensions.DependencyInjection;\r\nusing Microsoft.Extensions.Hosting;\r\nusing Squad.Agents.AI;\r\n\r\nvar builder = Host.CreateApplicationBuilder(args);\r\nbuilder.Services.AddSquadAgent(o =>\r\n{\r\n    o.SquadFolderPath = @\"C:\\path\\to\\your\\team-root\";\r\n});\r\n\r\nusing var host = builder.Build();\r\nvar squad = host.Services.GetRequiredService<AIAgent>();\r\nvar session = await squad.CreateSessionAsync();\r\nvar response = await squad.RunAsync(\"What can this Squad team do?\", session);\r\nConsole.WriteLine(response.Text);<\/code><\/pre>\n
That’s the whole integration. AddSquadAgent() registers your Squad team as both AIAgent (so MAF sees it through the standard abstraction) and SquadAgent (so callers that want Squad-specific knobs can drop down).<\/span><\/p>\n
Under the hood<\/h3>\n
SquadAgent is a thin composition of the two pieces Shawn just announced. The Copilot SDK already knows how to talk to copilot.exe; Squad.Agents.AI just points it at a Squad team folder, sets up a session, and hands the result to MAF as a regular AIAgent. The whole class is essentially this:<\/p>\n
public sealed class SquadAgent : DelegatingAIAgent\r\n\r\n{\r\n    public SquadAgent(SquadAgentOptions options) \r\n        : base(BuildInnerAgent(options))\u00a0\u00a0\u00a0 \/\/ \u2190 inner AIAgent passed to DelegatingAIAgent\r\n    {\r\n    }\r\n    \/\/ DelegatingAIAgent forwards RunAsync, RunStreamingAsync, CreateSessionAsync\r\n    \/\/ to whatever inner AIAgent we hand the base ctor. SquadAgent doesn't override\r\n    \/\/ any of that \u2014 the Copilot-backed agent does the work; we just expose the seam.\r\n    private static AIAgent BuildInnerAgent(SquadAgentOptions options)\r\n    {\r\n        \/\/ 1. Copilot SDK client, pointed at the Squad team root\r\n        var client = new CopilotClient(\/* CLI path, env, token, etc. *\/);\r\n        \/\/ 2. Tell the CLI to auto-discover the .squad\/ folder so it picks up\r\n        \/\/\u00a0\u00a0\u00a0 team agents, skills, instructions, and MCP servers at session start.\r\n        var teamRoot\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = options.SquadFolderPath;\r\n        var squadConfigDir = Path.Combine(teamRoot, \".squad\");\r\n\r\n        var sessionConfig = new SessionConfig\r\n        {\r\n             WorkingDirectory\u00a0\u00a0\u00a0\u00a0\u00a0 = teamRoot,\r\n             ConfigDirectory\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = squadConfigDir,\r\n             EnableConfigDiscovery = true,\r\n             OnPermissionRequest\u00a0\u00a0 = PermissionHandler.ApproveAll,\r\n        };\r\n\r\n        \/\/ 3. Lift the Copilot client into a MAF AIAgent \u2014 this is the inner\r\n        \/\/\u00a0\u00a0\u00a0 agent that DelegatingAIAgent will forward every call to.\r\n        return client.AsAIAgent(sessionConfig, name: options.AgentName ?? \"Squad\");\r\n    }\r\n}<\/code><\/pre>\n
The constructor chain is the part that ties it together. BuildInnerAgent<\/span> produces a Copilot-backed AIAgent<\/span>; the public ctor passes that straight to : base(…)<\/span>, and DelegatingAIAgent<\/span> forwards every RunAsync<\/span>, RunStreamingAsync<\/span>, and CreateSessionAsync<\/span> call to it. No protocol, no extra runtime, no overrides \u2014 just inheritance plus delegation. Three lines do the work that matters: build a CopilotClient<\/span> (Copilot SDK), describe a SessionConfig<\/span> that aims it at your team’s .squad\/ folder, then call client.AsAIAgent(…)<\/span> \u2014 the extension from Microsoft.Agents.AI.GitHub.Copilot<\/span> that turns it into a MAF agent.<\/p>\n
The EnableConfigDiscovery<\/span> flag is what makes the CLI auto-load your team’s charters, skills, and MCP servers at session start instead of forcing the agent to re-read them via runtime file tools every turn. That’s the part you’d otherwise have to rebuild by hand. (SquadAgent.cs<\/a>)<\/p>\n
Streaming uses the same surface \u2014 await foreach (var update in squad.RunStreamingAsync(prompt, session))<\/span> does what you’d expect. The depth \u2014 keyed multi-team registration, BYOK token delegates, security defaults \u2014 lives in the README<\/a>.<\/p>\n
Why Squad inside MAF?<\/h3>\n
A MAF workflow already lets you mix deterministic steps, stateless AI calls, and targeted agents you’ve prompt-engineered. Each of those resets to zero on every invocation \u2014 they know exactly what their prompt tells them, nothing more.<\/p>\n
A Squad is different. It’s a self-learning team<\/strong> that accumulates domain knowledge with use:<\/p>\n
    \n
  1. It remembers decisions.<\/strong> “We chose Postgres over Cosmos for this service” \u2014 logged once, respected by every specialist on every future call. You don’t re-explain your architecture each invocation.<\/li>\n
  2. It extracts skills.<\/strong> The first time an agent figures out your deployment flow, it writes a skill file. The tenth time, it just reads the skill and executes. Patterns compound instead of being rediscovered.<\/li>\n
  3. It respects your corrections.<\/strong> Say “we never use that library” once. The directive is captured. The team won’t suggest it again \u2014 not because you hardcoded a blocklist, but because the team learned<\/em>.<\/li>\n
  4. It onboards new specialists instantly.<\/strong> Add a security reviewer to the team next month. They inherit the full decision ledger and skill library on their first session \u2014 same way a new hire reads the team wiki.<\/li>\n<\/ol>\n
    That self-learning nature changes what the Squad-as-AIAgent slot means inside a MAF pipeline:<\/p>\n