Microsoft Agent Skills .NET Enterprise Knowledge Pipeline

Microsoft Agent Skills Enterprise Knowledge Pipeline uses the Agent Skills for .NET GA release (July 7, 2026) to package domain expertise as portable skill packages that agents discover and load on demand. Instead of stuffing every policy, playbook, or reference document into a single system prompt, each skill lives in a directory with a SKILL.md frontmatter file, optional scripts, and reference resources. The agent loads only the skill it needs, when it needs it, through a four-stage progressive disclosure pattern. The AI reasoning step happens when the agent reads the skill description, decides the skill matches the current task, calls load_skill to pull the instructions, then reads resources and optionally runs scripts through the run_skill_script tool. The decision gate evaluates semantic fit between the user query and each skill description. If an employee asks about expensing a co-working space, the agent skips fifteen unrelated skills and loads only the expense-report skill. The SKILL.md format follows the open agentskills.io specification with YAML frontmatter containing name, description, license, compatibility, and metadata fields. Sergey Menshykh, Principal Software Engineer at Microsoft, announced the GA on July 7, 2026, stating the [Experimental] attribute is removed and the API is stable for production use. (Source: Microsoft DevBlog, Agent Skills for .NET Is Now Released, July 7, 2026.) Teams can compose skills from multiple sources — file directories, C# classes, inline code, or MCP servers — through a single AgentSkillsProvider instance. The measurable outcome: one enterprise team can author a policy compliance skill once and serve it across every employee-facing agent, eliminating the 6-10 hours per week spent manually answering the same policy questions in different channels.

BUSINESS PROBLEM

According to Microsoft's Agent Framework documentation (2026), enterprise teams building AI agents repeat the same domain-knowledge wiring for every agent instance. A compliance manager at a 500-person financial services company fields 8-12 hours of repetitive policy questions per week — expense limits, travel approval workflows, IT security guidelines — across Slack, email, and Teams. At a fully loaded $95/hour for compliance staff, that is $760-$1,140 per week in context-switching overhead: $39,520-$59,280 per year. Existing approaches fail for specific reasons. Hard-coding policies into agent system prompts creates context bloat — a single agent with three policy areas exceeds 8,000 tokens before any real conversation starts. Retrieval-augmented generation pipelines require embedding infrastructure, vector database maintenance, and chunking strategies that a compliance team cannot own. Semantic Kernel plugins offered function-calling patterns but lacked the progressive-disclosure model and built-in governance that production enterprise agents require. Microsoft Foundry announced at Build 2026 that Skills are now first-class in Toolboxes, versioned in a project-scoped catalog and discoverable as MCP resources by any agent in the project. (Source: Microsoft Foundry Blog, Build and Run Agents at Scale, June 2, 2026.) Early adopters like Telefonica and KPMG are already running agent skills in production, reporting that the skill isolation model lets compliance teams own policy content while engineering teams own the agent infrastructure — a separation of concerns that was not possible with monolithic prompt approaches.

WHO BENEFITS

For the .NET enterprise developer at a 50 to 500 person company building internal employee-facing agents. SITUATION: You need an agent that answers compliance, HR, and IT questions using the same policy documents you maintain in SharePoint. Every policy change requires editing the agent instructions and re-deploying. PAYOFF: Package policies as file-based skills in a shared Git repo. Compliance team edits SKILL.md files directly. The agent picks up changes on next load. First skill deployed in under 90 minutes.

For the platform architect at a 200+ person enterprise standardizing agent infrastructure. SITUATION: Your platform team supports 10+ agents across finance, HR, legal, and engineering, each with duplicated policy content and no governance model for what the agent can access. PAYOFF: One AgentSkillsProvider composes skills from multiple sources with filtering, deduplication, and caching. Human-in-the-loop approval is default for all skill operations. Tenant-isolated skill sets through per-key caching.

For the product manager or compliance lead who authors skill content without writing code. SITUATION: You own expense policies, IT security guidelines, or HR procedures and want agents to answer correctly without you learning C# or Python. PAYOFF: File-based skills use only SKILL.md with YAML frontmatter and Markdown instructions. Non-developer team members create and review skills through pull requests on a shared repository. Agent behavior changes propagate when the skill file changes — no agent code changes needed.

HOW IT WORKS

Step 1 — Create the Skill Directory · Tool: File system + SKILL.md · Time: 15 minutes

Input A directory named after the skill (expense-report/) with a SKILL.md file containing YAML frontmatter (name, description, compatibility) and Markdown instructions Action The agent calls load_skill when the skill description matches the user query. The SKILL.md body provides step-by-step guidance the agent follows for each policy scenario. Output expense-report/SKILL.md with frontmatter fields: name, description, license (Apache-2.0), compatibility (.NET 8), metadata (author, version). Body under 500 lines.

Step 2 — Add Reference Documents · Tool: File system · Time: 10 minutes

Input Markdown, JSON, or CSV files in references/ subdirectory with policy details, rate tables, or decision trees Action The agent calls read_skill_resource when the skill instructions reference a resource name. The provider returns the resource content on demand — not before. Output expense-report/references/POLICY_FAQ.md containing the full expense policy. Loaded only when the agent needs a specific policy detail.

Step 3 — Add Executable Scripts · Tool: .NET SubprocessScriptRunner · Time: 20 minutes

Input Python (.py), shell (.sh), or C# script (.csx) files in scripts/ subdirectory that perform calculations or validations Action The agent calls run_skill_script with JSON array arguments. File-based scripts execute via SubprocessScriptRunner.RunAsync as local subprocesses. Class-based and code-defined scripts run in-process as direct delegate calls. Output expense-report/scripts/validate.py that checks expense amounts against policy thresholds. Agent passes the expense value and receives a validated result.

Step 4 — Wire the Skills Provider · Tool: AgentSkillsProvider · Time: 10 minutes

Input C# code using AgentSkillsProvider pointing at the skill directory and optionally passing SubprocessScriptRunner.RunAsync for script execution Action The provider discovers all SKILL.md files up to two levels deep. It registers load_skill, read_skill_resource, and run_skill_script as tools the agent can call. The builder applies automatic deduplication and caching. Output An AgentSkillsProvider instance ready to attach to any AIAgent. Single provider can aggregate file-based, code-defined, class-based, and MCP-based skills.

Step 5 — Attach Provider to Agent · Tool: Azure OpenAI ResponsesClient · Time: 5 minutes

Input AIAgent constructed with AzureOpenAIClient, DefaultAzureCredential, and the skills provider in AIContextProviders Action The provider advertises skill names and descriptions in the system prompt at each run start — about 100 tokens per skill. The agent evaluates every user query against these descriptions to decide which skill to load. Output A running AIAgent with domain expertise. The agent answers policy questions by loading the matching skill, reading resources, and optionally running scripts — all governed by approval defaults.

Step 6 — Add Multi-Source Composition via Builder · Tool: AgentSkillsProviderBuilder · Time: 15 minutes

Input AgentSkillsProviderBuilder chaining UseFileSkill, UseSkill (for inline skills), UseMcpSkills, and UseFilter Action The builder aggregates skills from all sources, deduplicates by name, applies filtering predicates, wraps with caching, and produces a single provider. This is the production pattern when skills come from multiple teams. Output A composed skills provider that draws from file directories, C# class libraries, NuGet packages, and MCP servers. Skill filtering restricts each agent to its authorized skill set.

Step 7 — Add Human-in-the-Loop Approval · Tool: AgentSkillsProviderOptions · Time: 10 minutes

Input All three skill tools (load_skill, read_skill_resource, run_skill_script) require approval by default. Relax selectively for trusted operations via tool approval configuration. Action Before any skill content loads or any script executes, the framework pauses and requests human approval through the configured channel. The agent resumes from the exact pending step on approval. Output A governed agent where every skill operation is visible and approvable. Compliance teams audit which skills loaded, which resources were read, and which scripts executed.

Step 8 — Deploy to Foundry Hosted Agent · Tool: Foundry Agent Service · Time: 5 minutes

Input The .NET project configured with FoundryChatClient and deployed to Foundry Agent Service Action Foundry hosts the agent in sandboxed sessions with managed identity, durable state, and OpenTelemetry tracing. Skills resolve once and cache. MCP-based skills connect through Foundry Toolboxes. Output A production agent running on Foundry infrastructure with skill-based domain expertise, human-in-the-loop governance, and end-to-end observability across every skill operation.

TOOL INTEGRATION

TOOL: Microsoft Agent Framework v1.13 (.NET packages Microsoft.Agents.AI) Role: Core framework that provides AgentSkillsProvider, AgentSkillsProviderBuilder, AIAgent, and the three skill tools (load_skill, read_skill_resource, run_skill_script)

ROI METRICS

Metric Before After Source Policy question resolution time 6-10 hrs/week manually answering 15-30 mins/week agent handles (Microsoft, Agent Skills Docs, July 2026) Skill authoring time per policy 4-8 hrs engineering + prompt tuning 90 min SKILL.md file creation (community estimate) Multi-agent policy consistency Different answers per agent channel Single skill, same answer (Microsoft, Agent Skills Blog, July 2026) New skill onboarding 3-5 days engineering sprint 15 min adding directory (community estimate) Human-in-the-loop overhead No governance on agent content loads Approval default on all skills (Microsoft, Agent Skills Docs, 2026)

The week-1 signal: package one existing policy document as a SKILL.md file with two reference docs. Attach it to any agent. Ask the agent a policy question. If the agent loads the skill and answers from the policy documents instead of generating a guess, the pipeline works. The strategic implication: once skills become the standard knowledge layer, compliance owns content and engineering owns infrastructure — a separation that eliminates the 3-5 day coordination cycles that currently block every agent content update.

CAVEATS

1. (significant risk) The load_skill tool is always advertised in the system prompt regardless of whether a skill matches. With 20+ skills loaded in the provider, the skill name and description list adds roughly 2,000 tokens to every system prompt before any conversation starts. This is by design (advertise stage) but teams with large skill catalogs should apply FilteringAgentSkillsSource to expose only relevant skills per agent or tenant. A predicate that filters by agent name keeps the advertise stage lean.

2. (moderate risk) File-based script execution uses a subprocess runner that has no built-in sandboxing, resource limits, or timeout. A script that enters an infinite loop or allocates unbounded memory consumes host resources until the process is killed externally. Microsoft's docs mark SubprocessScriptRunner as demonstration-only. For production, implement a wrapper with process timeout, memory cap, and filesystem isolation. The AgentSkillsProvider accepts a custom IRunner — use it from day one.

3. (moderate risk) Skill caching is enabled by default with no expiry. Once a skill list is resolved on the first request, it never refreshes unless the process restarts. During development when skill content changes frequently, call DisableCaching() on the builder. In production, set a RefreshInterval via CachingAgentSkillsSourceOptions. I updated a SKILL.md file and spent 20 minutes wondering why the agent still used old instructions — the cache had not expired.

4. (minor risk) MCP-based skills from remote servers can bundle archive-type skills (ZIP or TAR) but scripts in archive-type skills are never executed. This is a deliberate security measure, but it means remote skill sources cannot provide executable logic. Teams that distribute skills over MCP must restrict themselves to instructions and reference documents only. For script execution, package the skill as class-based or code-defined and distribute through NuGet.