version unknown

pull-requests

microsoft@microsoft⭐ 14.7k stars· last commit 3d ago· 673 open issues

>

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

6.8/10
Verified
Oct 11, 2026

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 14.7k on GitHubGitHub ↗

Very popular

🟢ProSkills ScoreAI Verified
6.8/10
📍

Not yet listed on ClawHub or SkillsMP

// README

Microsoft Agent Framework

Welcome to Microsoft Agent Framework!

Microsoft Foundry Discord MS Learn Documentation PyPI NuGet GitHub stars

Microsoft Agent Framework (MAF) is an open, multi-language framework for building production-grade AI agents and multi-agent workflows in .NET and Python.

Microsoft Agent Framework is built for teams taking agents from prototype to production. It provides a consistent foundation for building, orchestrating, and operating agent systems across Python, .NET and Go, while keeping architecture choices open as requirements evolve, and supports a broad ecosystem including Microsoft Foundry, Azure OpenAI, OpenAI, and the GitHub Copilot SDK, with samples and hosting patterns for both local development and cloud deployment.

[!NOTE] For the Go SDK, including its documentation, samples, contribution guidance, and issue tracker, visit microsoft/agent-framework-go.

Is this the right framework for you?

MAF is a strong fit if you:

  • are building agents and workflows you expect to run in production,
  • need orchestration beyond a single prompt or stateless chat loop,
  • want graph-based patterns such as sequential, concurrent, handoff, and group collaboration,
  • care about durability, restartability, observability, governance, or human-in-the-loop control,
  • need provider flexibility so your architecture can evolve without major rewrites.

Key Features

Explore new MAF capabilities and real implementation patterns on the official blog.

  • Python and C#/.NET Support: Full framework support for both Python and C#/.NET implementations with consistent APIs
  • Go Support: For the Go SDK, including its documentation, samples, contribution guidance, and issue tracker, visit microsoft/agent-framework-go.
  • Multiple Agent Provider Support: Support for various LLM providers with more being added continuously
  • Middleware: Flexible middleware system for request/response processing, exception handling, and custom pipelines
  • Orchestration Patterns & Workflows: Build multi-agent systems with graph-based workflows supporting sequential, concurrent, handoff, and group collaboration patterns; includes checkpointing, streaming, human-in-the-loop, and time-travel
  • Foundry Hosted Agents (new): Deploy and host your agents to Foundry-hosted infrastructure with just 2 additional lines of code
  • Observability: Built-in OpenTelemetry integration for distributed tracing, monitoring, and debugging
  • Declarative Agents: Define agents using YAML for faster setup and versioning
  • Agent Skills: Build domain-specific knowledge bases from multiple sources—files, inline code, class libraries—for agents to discover and use
  • AF Labs: Experimental packages for cutting-edge features including benchmarking, reinforcement learning, and research initiatives
  • DevUI: Interactive developer UI for agent development, testing, and debugging workflows

Table of Contents

Getting Started

Installation

Python

pip install agent-framework
# This installs the standard package set; install `agent-framework-lab` separately for experimental modules.
# It may take a minute on first install on Windows.

.NET

dotnet add package Microsoft.Agents.AI
# For Foundry integration (used in the .NET quickstart below):
dotnet add package Microsoft.Agents.AI.Foundry
dotnet add package Azure.AI.Projects
dotnet add package Azure.Identity

Learning Resources

Quickstart

Basic Agent - Python

Create a simple Azure Responses Agent that writes a haiku about the Microsoft Agent Framework

# pip install agent-framework
# Use `az login` to authenticate with Azure CLI
import os
import asyncio
from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential


async def main():
    # Initialize a chat agent with Microsoft Foundry
    # the endpoint, deployment name, and api version can be set via environment variables
    # or they can be passed in directly to the FoundryChatClient constructor
    agent = Agent(
      client=FoundryChatClient(
          credential=AzureCliCredential(),
          # project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
          # model=os.environ["FOUNDRY_MODEL"],
      ),
      name="HaikuAgent",
      instructions="You are an upbeat assistant that writes beautifully.",
    )

    print(await agent.run("Write a haiku about Microsoft Agent Framework."))

if __name__ == "__main

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • .github/skills/pull-requests/SKILL.md5.1 KBupstream ↗
    ---
    name: pull-requests
    description: >
      Guidance for creating pull requests and handling PR review comments in the
      Agent Framework repository. Use this when writing a PR description (filling out
      the PR template) or when responding to and resolving review comments on an
      existing PR.
    ---
    
    # Pull Request Workflow
    
    This skill covers two tasks: (1) writing a high-quality PR description, and
    (2) handling review comments on an existing PR.
    
    ## 1. Writing the PR description
    
    Always follow the repository PR template at
    [`.github/pull_request_template.md`](../../pull_request_template.md). Keep its
    exact structure and headings. Fill every section:
    
    ### `### Motivation & Context`
    Explain *why* the change is needed: the problem it solves and the scenario it
    contributes to. Describe the net change relative to `main` — this is implied, so
    do **not** spell out "vs main" explicitly.
    
    ### `### Description & Review Guide`
    Describe the changes, the overall approach, and the design. Answer the three
    prompts:
    - **What are the major changes?**
    - **What is the impact of these changes?**
    - **What do you want reviewers to focus on?** — This item is for **human
      reviewers only**. Automated/AI reviewers must ignore it and review the entire
      change rather than narrowing scope to it.
    
    ### `### Related Issue`
    Link the issue the PR fixes using a GitHub closing keyword (`Fixes #123` /
    `Closes #123`) so it closes automatically on merge. A PR with no linked issue may
    be closed regardless of how valid the change is. Before opening, confirm there is
    no other open PR for the same issue; if there is, explain how this PR differs.
    
    ### `### Contribution Checklist`
    Check every item that applies. For the breaking-change item:
    - Leave **"This is not a breaking change."** checked for the common case.
    - If the change **is** breaking, add the `breaking change` label **or** put
      `[BREAKING]` in the title prefix, before or after a language prefix such as
      `Python:` or `.NET:` — workflows keep the label and the title prefix in sync
      automatically (see `.github/workflows/label-title-prefix.yml` and
      `.github/workflows/label-pr.yml`).
    
    ### Do not
    - Do **not** add ad-hoc sections such as "Validation" or "Tests run"; CI/CD and
      the checklist already cover validation status.
    - Do **not** remove or reorder the template's headings.
    
    ### Stable specifications
    
    For Python function-calling loop changes, read
    [`docs/specs/004-python-function-calling-loop.md`](../../../docs/specs/004-python-function-calling-loop.md)
    and validate the PR against it. Do not edit that specification by default. It
    is a stable cross-package contract, not a per-PR changelog. A specification
    change is warranted only when the PR intentionally changes normative behavior,
    the scenario inventory, an acknowledged coverage gap, or the authoritative
    scenario-to-test mapping; keep any such edit to the smallest affected sections.
    
    ### Creating the PR
    Open new PRs as **drafts** until they are ready for review. Example:
    
    ```bash
    gh pr create --repo microsoft/agent-framework --base main \
      --head <your-fork-owner>:<branch> --draft \
      --title "<concise title>" --body "<body following the template>"
    ```
    
    ## 2. Handling review comments
    
    When a PR receives review comments, follow this sequence — **do not start editing
    code before the user has reviewed the plan**:
    
    1. **Review the comments.** Read every review comment and thread on the PR,
       including inline code comments and general review summaries.
    2. **Make a plan.** Produce a concrete plan describing how each comment will be
       addressed (or why it should not be, with reasoning).
    3. **Let the user review the plan.** Present the plan and wait for the user's
       approval or adjustments before implementing anything.
    4. **Implement.** Make the agreed changes.
    5. **Reply to every comment.** Add a reply to **all** comments explaining how it
       was addressed, preferably citing the commit containing the change. If the
       feedback was not addressed, explain why. Leave no comment unanswered.
    6. **Resolve completed threads yourself.** After replying and completing any
       necessary discussion, resolve the review thread. Do not wait for the reviewer
       or a maintainer to resolve it. Leave a thread open only while it has an
       unanswered question or active discussion.
    
    ### Useful commands
    
    List review comments and threads:
    
    ```bash
    # Inline review comments
    gh api repos/{owner}/{repo}/pulls/{pr}/comments
    
    # Review threads with resolution state (GraphQL)
    gh api graphql -f query='
      query($owner:String!,$repo:String!,$pr:Int!){
        repository(owner:$owner,name:$repo){
          pullRequest(number:$pr){
            reviewThreads(first:100){
              nodes{ id isResolved comments(first:50){ nodes{ id body author{login} } } }
            }
          }
        }
      }' -F owner={owner} -F repo={repo} -F pr={pr}
    ```
    
    Reply to an inline review comment:
    
    ```bash
    gh api repos/{owner}/{repo}/pulls/{pr}/comments/{comment_id}/replies \
      -f body="Addressed in <commit>: <explanation>"
    ```
    
    Resolve a review thread (needs the thread node id from the GraphQL query above):
    
    ```bash
    gh api graphql -f query='
      mutation($threadId:ID!){
        resolveReviewThread(input:{threadId:$threadId}){ thread{ isResolved } }
      }' -F threadId={thread_id}
    ```
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/microsoft-agent-framework-github-skills-pull-requests.md

// REPO STATS

14.7k stars
673 open issues
Last commit: 3d ago