pull-requests
>
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.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README

Welcome to Microsoft Agent Framework!
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
- Agent Skills for Coding Agents
- More Examples & Samples
- Community & Feedback
- Troubleshooting
- Contributor Resources
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
- Overview - High level overview of the framework
- Quick Start - Get started with a simple agent
- Tutorials - Step by step tutorials
- User Guide - In-depth user guide for building agents and workflows
- Migration from Semantic Kernel - Guide to migrate from Semantic Kernel
- Migration from AutoGen - Guide to migrate from AutoGen
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