Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
Important
Items marked (preview) in this article are currently in public preview. This preview is provided without a service-level agreement, and we don't recommend it for production workloads. Certain features might not be supported or might have constrained capabilities. For more information, see Supplemental Terms of Use for Microsoft Azure Previews.
As agents grow beyond simple prototypes, teams accumulate behavioral guidelines that need to be consistent across every conversation. A support agent should always follow a specific escalation policy, a code-review agent should always apply the same checklist, and a sales agent should always respect certain messaging constraints. Embedding these guidelines directly in each agent's system prompt or code creates duplication: when the policy changes, you need to update and redeploy every agent that uses it.
Skills solve this problem by decoupling behavioral guidelines from agent code. A skill is a SKILL.md file you author once, store centrally in Foundry through the versioned Skills API, and then deliver to agents in two modes: attach to a toolbox so any MCP client can discover and load them alongside tools, or download directly into a Hosted or local agent project for direct injection into each session's context. Skills are versioned: every update creates a new immutable version while the parent skill tracks a default_version. When you update a skill, you create a new version, test it, then promote it to default without changing any agent code.
In this article, you learn how to:
- Create versioned skills and manage them through the Skills API.
- List, get, and delete skills and skill versions.
- Download skill content for use in a Hosted agent.
- Attach skills to a toolbox.
Feature support
| Feature | REST API | Python | .NET | JavaScript | Toolbox | Hosted agent |
|---|---|---|---|---|---|---|
| Create skill version (JSON inline content) | ?? | ?? | ?? | ?? | N/A | N/A |
| Create skill version (ZIP file upload) | ?? | ?? | ?? | ?? | N/A | N/A |
| List, get, and delete skills and versions | ?? | ?? | ?? | ?? | N/A | N/A |
| Download skill content | ?? | ?? | ?? | ?? | N/A | N/A |
| Update skill default version | ?? | ?? | ?? | ?? | N/A | N/A |
| Attach skills to a toolbox | ?? | ?? | ?? | ?? | ?? | N/A |
Prerequisites
An active Microsoft Foundry project.
RBAC: Foundry User role on the Foundry project.
Important
The Foundry RBAC roles were recently renamed. Foundry User, Foundry Owner, Foundry Account Owner, and Foundry Project Manager were previously named Azure AI User, Azure AI Owner, Azure AI Account Owner, and Azure AI Project Manager. You might still see the previous names in some places while the rename rolls out. The role IDs and core permissions are unchanged by the rename.
Author a skill
Skills follow the Agent Skills specification format. A skill is a Markdown file with a YAML front matter block:
---
name: greeting
description: Generate a personalized greeting for the user.
---
# Greeting Skill
You're a friendly greeting assistant for Foundry Hosted Agents.
## Instructions
- Include the user's name if they provided one.
- Keep greetings concise, 1 to 2 sentences.
- Thank the user for trying out Foundry Hosted Agents and this sample skill.
| Field | Required | Rules |
|---|---|---|
name |
Yes | Skill name used as the URL path key. Lowercase letters, numbers, and hyphens only. Must not start or end with a hyphen or contain consecutive hyphens. Maximum 64 characters. Pattern: ^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$. Must be unquoted in YAML. |
description |
Yes | One-liner shown in skill listings. Maximum 1,024 characters. Must be unquoted in YAML. |
| Body | Yes | Free Markdown. Becomes the skill's injected instructions. |
Important
- The
nameanddescriptionvalues must be unquoted in the YAML front matter. - Skill names follow the pattern
^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$(lowercase, numbers, and hyphens, no leading/trailing hyphens, max 64 characters). Invalid names cause aninvalid_payloaderror on version creation.
Place each skill in its own subdirectory under the agent root directory. For example, greeting/SKILL.md, not SKILL.md at the root.
Attach skills to a toolbox (preview)
After you create skill versions, attach them to a toolbox version so any MCP client can discover and load them alongside tools from the same endpoint. Toolbox-based skill discovery is in preview and follows the Skills extension for the Model Context Protocol specification (SEP-2640).
Important
Skills attached to a toolbox must exist in the same Foundry project. Cross-project references aren't supported.
When an agent or MCP client connects to the toolbox endpoint, skills appear as MCP Resources. Clients that support the MCP Resources protocol call resources/list once at startup to discover all attached skills, then resources/read to download the content. Any MCP client — GitHub Copilot, Claude Code, or your own agent harness — can consume skills this way without any Foundry SDK.
For REST, Python, .NET, JavaScript, and azd examples of adding skill references to a toolbox version, see the Attach skills to a toolbox section in the toolbox article. The Azure Developer CLI exposes skill references both declaratively (a skills: block in azd ai toolbox create --from-file) and imperatively (azd ai toolbox skill add, azd ai toolbox skill list, azd ai toolbox skill remove); changes don't take effect for MCP clients until you promote the new version with azd ai toolbox publish.
Manage skills with the REST API
The Skills API is versioned: creating a skill version auto-creates the skill if it doesn't exist yet. Each update creates a new immutable SkillVersion. The parent Skill object tracks default_version (the active version) and latest_version.
Skills endpoint: {FOUNDRY_PROJECT_ENDPOINT}/skills
Authentication: Bearer token from DefaultAzureCredential with scope https://ai.azure.com/.default.
Preview header: All Skills API calls require Foundry-Features: Skills=V1Preview.
| Object | Key fields | Description |
|---|---|---|
Skill |
id, name, description, created_at, default_version, latest_version |
The skill container. default_version points to the active version. |
SkillVersion |
id, skill_id, name, version, description, created_at |
An immutable snapshot of the skill content. |
Tip
For an end-to-end Python CRUD walkthrough — create two versions, switch default_version, fetch, list, delete — see the sample_skills_crud.py sample in the azure-ai-projects SDK.
Create a skill version
Creating a version auto-creates the parent skill if it doesn't exist. After creating a version, call Update default version to make it the active version.
You can create a version in two ways: submit the content directly as JSON via inline_content, or upload a ZIP archive containing a SKILL.md file.
Option 1: Create from inline content (JSON)
Use this option when you want to supply the skill's instructions text directly without packaging a file.
POST {endpoint}/skills/greeting/versions?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json
Accept: application/json
Foundry-Features: Skills=V1Preview
{
"inline_content": {
"description": "Generate a personalized greeting for the user.",
"instructions": "You are a friendly greeting assistant. Keep greetings brief and warm."
},
}
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import SkillInlineContent
# Create Foundry project client
endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
with (
DefaultAzureCredential() as credential,
AIProjectClient(
endpoint=endpoint, credential=credential, allow_preview=True
) as project,
):
# Create skill version from inline content
created = project.beta.skills.create(
name="greeting",
inline_content=SkillInlineContent(
description="Generate a personalized greeting for the user.",
instructions="You are a friendly greeting assistant. Keep greetings brief and warm.",
),
)
print(
f"Created skill: {created.name} version: {created.version}"
)
#pragma warning disable AAIP001
using Azure.AI.Projects.Agents;
using Azure.Core.Pipeline;
using Azure.Identity;
var projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT");
AgentAdministrationClientOptions options = new();
options.AddPolicy(new FeaturePolicy("Skills=V1Preview"), PipelinePosition.PerCall);
AgentAdministrationClient agentsClient = new(endpoint: new Uri(projectEndpoint), tokenProvider: new DefaultAzureCredential(), options: options);
ProjectAgentSkills skillsClient = agentsClient.GetAgentSkills();
AgentsSkill created = skillsClient.CreateSkill(
name: "greeting",
description: "Generate a personalized greeting for the user.",
instructions: "You are a friendly greeting assistant. Keep greetings brief and warm.");
Console.WriteLine($"Created skill: {created.Name}, Id: {created.SkillId}");
// FeaturePolicy: inject the preview feature header on every request.
internal class FeaturePolicy(string feature) : PipelinePolicy
{
public override void Process(PipelineMessage msg, IReadOnlyList<PipelinePolicy> pipeline, int idx)
{
msg.Request.Headers.Add("Foundry-Features", feature);
ProcessNext(msg, pipeline, idx);
}
public override async ValueTask ProcessAsync(PipelineMessage msg, IReadOnlyList<PipelinePolicy> pipeline, int idx)
{
msg.Request.Headers.Add("Foundry-Features", feature);
await ProcessNextAsync(msg, pipeline, idx);
}
}
import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
// Create Foundry project client
const projectEndpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>";
const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
const skillVersion = await project.beta.skills.create("greeting", {
inlineContent: {
description: "Generate a personalized greeting for the user.",
instructions: "You are a friendly greeting assistant. Keep greetings brief and warm.",
},
});
console.log(`Created skill: ${skillVersion.name} version: ${skillVersion.version}`);
Use the azure.ai.skills Azure Developer CLI extension (Preview).
Prerequisites:
azd extension install azure.ai.foundry
azd extension install azure.ai.skills # while in Preview, build from source if not in the public registry
az login
$PE = "https://<account>.services.ai.azure.com/api/projects/<project>"
azd ai agent project set --endpoint $PE
Endpoint resolution order: -p flag ? azd env AZURE_AI_PROJECT_ENDPOINT ? global config extensions.ai-skills.project.context.endpoint (falls back to extensions.ai-agents.project.context.endpoint) ? env var FOUNDRY_PROJECT_ENDPOINT.
Create the first version with inline metadata:
azd ai skill create greeting `
--description "Generate a personalized greeting for the user." `
--instructions "You are a friendly greeting assistant. Keep greetings brief and warm." `
-p $PE --no-prompt -o json
Or from a SKILL.md file. The name: field in the file must equal the positional argument:
---
name: greeting
description: Generate a personalized greeting for the user.
---
# Greeting assistant
You are a friendly greeting assistant. Keep greetings brief and warm.
azd ai skill create greeting --file ./SKILL.md -p $PE --no-prompt -o json
Add a new version to an existing skill (auto-promoted to default_version):
azd ai skill update greeting --file ./SKILL.md -p $PE --no-prompt -o json
# Or with inline flags:
azd ai skill update greeting `
--description "Updated description." `
--instructions "Updated instructions." `
-p $PE --no-prompt -o json
Example response (SkillVersion object):
{
"id": "skillver_abc123",
"skill_id": "skill_abc123",
"name": "greeting",
"version": "v1",
"description": "Generate a personalized greeting for the user.",
"created_at": 1741305600
}
Option 2: Create from a SKILL.md ZIP
Use multipart form upload when you have a SKILL.md file. The skill name comes from the {name} path parameter. Upload a single ZIP file or multiple individual files. The SKILL.md is parsed to populate the version description and instructions.
POST {endpoint}/skills/greeting/versions?api-version=v1
Authorization: Bearer {token}
Content-Type: multipart/form-data
Accept: application/json
Foundry-Features: Skills=V1Preview
--boundary
Content-Disposition: form-data; name="files"; filename="SKILL.md"
Content-Type: text/markdown
<SKILL.md content>
--boundary--
from pathlib import Path
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
# Create Foundry project client
endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
with (
DefaultAzureCredential() as credential,
AIProjectClient(
endpoint=endpoint, credential=credential, allow_preview=True
) as project,
):
# Create skill version from ZIP / SKILL.md file
imported = project.beta.skills.create(
name="greeting",
file=Path("greeting.zip").read_bytes(),
)
print(
f"Created skill: {imported.name} version: {imported.version}"
)
#pragma warning disable AAIP001
// See the FeaturePolicy class definition and client setup in the Create a skill section above.
// CreateSkillFromPackage accepts a local directory containing a SKILL.md file.
AgentsSkill imported = skillsClient.CreateSkillFromPackage("path/to/greeting-directory");
Console.WriteLine($"Created skill from directory: {imported.Name}, Id: {imported.SkillId}");
import { readFileSync } from "fs";
const zipBytes = readFileSync("greeting.zip");
const skillVersion = await project.beta.skills.createFromFiles("greeting", {
files: [{ contents: zipBytes, filename: "greeting.zip", contentType: "application/zip" }],
});
console.log(`Created skill: ${skillVersion.name} version: ${skillVersion.version}`);
The CLI accepts a single .zip archive containing a SKILL.md plus any sibling assets. Bare folders are rejected — zip them first.
# Lay out the package, then zip it
mkdir skill-src\assets
# ... author skill-src/SKILL.md and any sibling assets ...
Compress-Archive -Path skill-src\* -DestinationPath greeting.zip -Force
# Upload as a new skill
azd ai skill create greeting --file ./greeting.zip -p $PE --no-prompt -o json
azd ai skill update rejects .zip. To replace an existing skill with a new package, use create --force — this deletes the existing skill and all of its versions first, then uploads v1 from the new zip:
azd ai skill create greeting --file ./greeting-v2.zip --force -p $PE --no-prompt -o json
Note
For ZIP uploads, the server extracts and validates the SKILL.md content. For individual file uploads, files are validated as-is.
Example response (SkillVersion object):
{
"id": "skillver_def456",
"skill_id": "skill_def456",
"name": "greeting",
"version": "v1",
"description": "Generate a personalized greeting for the user.",
"created_at": 1741305600
}
List skills
GET {endpoint}/skills?api-version=v1&limit=20&order=desc
Authorization: Bearer {token}
Accept: application/json
Foundry-Features: Skills=V1Preview
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
# Create Foundry project client
endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
with (
DefaultAzureCredential() as credential,
AIProjectClient(
endpoint=endpoint, credential=credential, allow_preview=True
) as project,
):
# List all skills in the project
skills = list(project.beta.skills.list())
print(f"Found {len(skills)} skill(s)")
for skill in skills:
print(f" {skill.name} (default: {skill.default_version})")
#pragma warning disable AAIP001
// See the FeaturePolicy class definition and client setup in the Create a skill section above.
List<AgentsSkill> skills = [.. skillsClient.GetSkills()];
Console.WriteLine($"Found {skills.Count} skill(s).");
foreach (AgentsSkill item in skills)
{
Console.WriteLine($" - {item.Name} (default: {item.DefaultVersion})");
}
const skills = project.beta.skills.list({ limit: 20, order: "desc" });
for await (const skill of skills) {
console.log(`${skill.name} (default: ${skill.default_version})`);
}
azd ai skill list -p $PE -o table
Example response:
{
"data": [
{
"id": "skill_abc123",
"name": "greeting",
"description": "Generate a personalized greeting for the user.",
"created_at": 1741305600,
"default_version": "v1",
"latest_version": "v1"
}
],
"has_more": false,
"first_id": "skill_abc123",
"last_id": "skill_abc123"
}
Use last_id with the after query parameter for forward cursor-based pagination.
Get a skill
GET {endpoint}/skills/{name}?api-version=v1
Authorization: Bearer {token}
Accept: application/json
Foundry-Features: Skills=V1Preview
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
# Create Foundry project client
endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
with (
DefaultAzureCredential() as credential,
AIProjectClient(
endpoint=endpoint, credential=credential, allow_preview=True
) as project,
):
# Get skill by name
skill = project.beta.skills.get(name="greeting")
print(f"{skill.name}: default version {skill.default_version}")
#pragma warning disable AAIP001
// See the FeaturePolicy class definition and client setup in the Create a skill section above.
AgentsSkill skill = skillsClient.GetSkill(skillName: "greeting");
Console.WriteLine($"Retrieved skill: {skill.Name}, description: {skill.Description}");
const skill = await project.beta.skills.get("greeting");
console.log(`${skill.name}: ${skill.description}`);
azd ai skill show greeting -p $PE -o json
Returns the skill metadata. Returns HTTP 404 if the skill doesn't exist.
Download skill content
Downloads the skill content as a ZIP archive. Use the default version endpoint to get the active version, or the version-specific endpoint to get a specific version.
# Download default version content
GET {endpoint}/skills/{name}/content?api-version=v1
Authorization: Bearer {token}
Accept: application/zip
Foundry-Features: Skills=V1Preview
# Download a specific version's content
GET {endpoint}/skills/{name}/versions/{version}/content?api-version=v1
Authorization: Bearer {token}
Accept: application/zip
Foundry-Features: Skills=V1Preview
import tempfile
from datetime import datetime
from pathlib import Path
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
# Create Foundry project client
endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
download_folder = Path(tempfile.gettempdir()).resolve()
with (
DefaultAzureCredential() as credential,
AIProjectClient(
endpoint=endpoint, credential=credential, allow_preview=True
) as project,
):
# Download skill package
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
download_path = download_folder / f"greeting_{timestamp}.zip"
download_path.write_bytes(
b"".join(project.beta.skills.download_content("greeting"))
)
print(f"Downloaded skill package to: {download_path}")
#pragma warning disable AAIP001
// See the FeaturePolicy class definition and client setup in the Create a skill section above.
string savePath = Path.GetFullPath("saved_skill");
skillsClient.DownloadSkill("greeting", savePath);
Console.WriteLine($"Skill saved to: {savePath}");
const response = await project.beta.skills.download("greeting");
const blob = await response.blobBody;
// blob is the ZIP archive (default version). For a specific version, use downloadVersion(name, version).
Default mode extracts the skill into a directory (defaults to ./.agents/skills/<name>/):
# Default version
azd ai skill download greeting --output-dir ./downloaded -p $PE --no-prompt -o json
# A specific version
azd ai skill download greeting --version 2 --output-dir ./downloaded-v2 -p $PE --no-prompt -o json
Raw mode keeps the original .zip archive untouched:
azd ai skill download greeting --raw --output-dir ./downloaded-raw -p $PE --no-prompt -o json
Pass --force to overwrite existing files in the output directory.
Note
The response body is a binary ZIP archive (Content-Type: application/zip).
Delete a skill
DELETE {endpoint}/skills/{name}?api-version=v1
Authorization: Bearer {token}
Accept: application/json
Foundry-Features: Skills=V1Preview
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
# Create Foundry project client
endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
with (
DefaultAzureCredential() as credential,
AIProjectClient(
endpoint=endpoint, credential=credential, allow_preview=True
) as project,
):
# Delete skill
deleted = project.beta.skills.delete(name="greeting")
print(f"Deleted skill: {deleted}")
#pragma warning disable AAIP001
// See the FeaturePolicy class definition and client setup in the Create a skill section above.
skillsClient.DeleteSkill("greeting");
Console.WriteLine("Skill deleted.");
const result = await project.beta.skills.delete("greeting");
console.log(`Deleted: ${result.name} (${result.deleted})`);
azd ai skill delete greeting -p $PE --force
Returns HTTP 200 on success:
{
"id": "skill_abc123",
"name": "greeting",
"deleted": true
}
List skill versions
GET {endpoint}/skills/{name}/versions?api-version=v1
Authorization: Bearer {token}
Accept: application/json
Foundry-Features: Skills=V1Preview
versions = list(project.beta.skills.list_versions("greeting"))
for v in versions:
print(f" {v.name} version: {v.version}")
#pragma warning disable AAIP001
List<AgentsSkillVersion> versions = [.. skillsClient.GetSkillVersions("greeting")];
foreach (var v in versions)
Console.WriteLine($" {v.Name} version: {v.Version}");
const versions = project.beta.skills.listVersions("greeting");
for await (const v of versions) {
console.log(` ${v.name} version: ${v.version}`);
}
Example response:
{
"data": [
{
"id": "skillver_abc123",
"skill_id": "skill_abc123",
"name": "greeting",
"version": "v1",
"description": "Generate a personalized greeting for the user.",
"created_at": 1741305600
}
],
"has_more": false
}
Get a skill version
GET {endpoint}/skills/{name}/versions/{version}?api-version=v1
Authorization: Bearer {token}
Accept: application/json
Foundry-Features: Skills=V1Preview
v = project.beta.skills.get_version(name="greeting", version="v1")
print(f"{v.name} version: {v.version}, description: {v.description}")
#pragma warning disable AAIP001
AgentsSkillVersion v = skillsClient.GetSkillVersion("greeting", "v1");
Console.WriteLine($"{v.Name} version: {v.Version}, description: {v.Description}");
const v = await project.beta.skills.getVersion("greeting", "v1");
console.log(`${v.name} version: ${v.version}`);
Delete a skill version
DELETE {endpoint}/skills/{name}/versions/{version}?api-version=v1
Authorization: Bearer {token}
Accept: application/json
Foundry-Features: Skills=V1Preview
result = project.beta.skills.delete_version("greeting", "v1")
print(f"Deleted version: {result.version} ({result.deleted})")
#pragma warning disable AAIP001
skillsClient.DeleteSkillVersion("greeting", "v1");
Console.WriteLine("Skill version deleted.");
const result = await project.beta.skills.deleteVersion("greeting", "v1");
console.log(`Deleted version: ${result.version} (${result.deleted})`);
Returns HTTP 200 on success:
{
"id": "skillver_abc123",
"name": "greeting",
"deleted": true,
"version": "v1"
}
Update default version
Change which version the skill resolves to by default. Toolboxes and agents that reference the skill without pinning a version use the default_version.
POST {endpoint}/skills/{name}?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json
Accept: application/json
Foundry-Features: Skills=V1Preview
{
"default_version": "v2"
}
result = project.beta.skills.update("greeting", default_version="v2")
print(f"New default version: {result.default_version}")
#pragma warning disable AAIP001
AgentsSkill updated = skillsClient.UpdateSkillDefaultVersion("greeting", "v2");
Console.WriteLine($"New default version: {updated.DefaultVersion}");
const result = await project.beta.skills.update("greeting", "v2");
console.log(`New default version: ${result.default_version}`);
azd ai skill update greeting --set-default-version v2 -p $PE --no-prompt -o json
--set-default-version is a metadata-only repoint — no upload, no new version. Use it to roll back (or forward) without touching skill content.
Use skills in a hosted agent
In direct injection mode, you download skills from the Foundry Skills API into your agent project directory. The agent reads the SKILL.md files at startup and injects their content as extra system instructions for each session. This mode works without a toolbox and is appropriate when you want to bundle specific skill versions directly with your agent code.
For the alternative mode — where skills and tools share a single discoverable endpoint that any MCP client can reach — see Attach skills to a toolbox (preview).
The following walkthrough uses a GitHub Copilot SDK sample that reads SKILL.md files from a local skills/ directory. Use the Download skill content operation to pull skills from Foundry into this directory.
Note
This sample requires a GitHub fine-grained personal access token (PAT) with Copilot requests: Read-only permission. Create one at github.com/settings/personal-access-tokens/new. Classic tokens (ghp_) aren't supported. Use a fine-grained PAT (github_pat_).
Step 1: Initialize the agent project
Scaffold the project from the sample manifest:
azd ai agent init -m https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/bring-your-own/invocations/github-copilot/agent.manifest.yaml
Set the required GitHub token:
azd env set GITHUB_TOKEN="github_pat_..."
The scaffolded project includes main.py, configuration files, and a sample joke skill:
+-- main.py ? agent code that loads skills via CopilotClient
+-- agent.yaml
+-- agent.manifest.yaml
+-- requirements.txt
+-- skills/
+-- joke/
+-- SKILL.md ? bundled sample skill
In main.py, the skill_directories parameter tells the Copilot SDK where to find skill files. Any SKILL.md in a subdirectory of skills/ is loaded as extra instructions when a session starts.
Step 2: Populate skills from Foundry
Use the Download skill content operation to pull the greeting skill from Foundry. Extract the SKILL.md from the downloaded ZIP and save it to skills/greeting/SKILL.md:
mkdir skills/greeting
If you haven't stored the greeting skill in Foundry yet, copy the skill content from Author a skill directly into skills/greeting/SKILL.md.
The project now includes both skills:
+-- main.py
+-- agent.yaml
+-- agent.manifest.yaml
+-- requirements.txt
+-- skills/
+-- greeting/
— +-- SKILL.md ? your greeting skill
+-- joke/
+-- SKILL.md
Step 3: Run and test locally
Start the agent:
azd ai agent run
In a separate terminal, test the greeting skill:
azd ai agent invoke --local '{"input": "Hi, my name is Alex!"}'
Tip
On PowerShell, escape the inner quotes: azd ai agent invoke --local '{\"input\": \"Hi, my name is Alex!\"}'
Step 4: Deploy and test remotely
Create Azure resources and deploy the agent:
azd provision
azd deploy
Test the deployed agent on Foundry:
azd ai agent invoke '{"input": "Hi, my name is Alex!"}'