AutoGineer
Generated banner for Declarative Agent Developer
Generated logo for Declarative Agent Developer

Declarative Agent Developer

MicrosoftOfficialPublished by Microsoft

  • Skill
  • Tool integration
  • Software development
  • MIT
  • Low risk
Download ZIP

From the author

Create, build, deploy, and localize declarative agents for M365 Copilot and Teams. USE THIS SKILL for ANY task involving a declarative agent — including localization, scaffolding, editing manifests, adding capabilities, and deploying. Localization requires tokenized manifests and language files that only this skill knows how to produce. Triggers: "create agent", "create a declarative agent", "new declarative agent", "scaffold an agent", "new agent project", "add a capability", "add a plugin", "configure my agent", "deploy my agent", "fix my agent manifest", "edit my agent", "localize my agent", "add localization", "translate my agent", "multi-language agent", "add an API plugin", "add an MCP plugin", "add OAuth to my plugin", "review instructions", "improve instructions", "fix my instructions"
— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The declarative-agent-developer skill provides a structured workflow for managing the lifecycle of M365 Copilot and Teams declarative agents. It utilizes the M365 Agent Toolkit (ATK) CLI to handle project scaffolding, manifest management, API plugin integration, and deployment. The skill enforces strict workspace validation, requiring specific project structures before allowing modifications, and provides standardized protocols for error handling, localization, and authentication configuration.

What it does

  • Scaffolds new declarative agent projects using the ATK CLI.
  • Manages and validates declarativeAgent.json manifests.
  • Integrates API plugins and MCP servers into existing agent projects.
  • Configures OAuth authentication for secure plugin communication.
  • Handles localization of agent manifests and language files.
  • Deploys agents to local environments for testing and validation.

When to use it

  • When creating a new declarative agent project for M365 Copilot or Teams.
  • When adding new capabilities, API plugins, or MCP servers to an existing agent.
  • When updating agent instructions or conversation starters.
  • When localizing an agent for multiple languages.
  • When troubleshooting or fixing errors in an agent manifest.

Advantages

  • Ensures consistent project structure through mandatory workspace checks.
  • Automates complex tasks like API plugin registration and OAuth setup.
  • Provides a clear, step-by-step protocol for error detection and resolution.
  • Facilitates standardized deployment and testing workflows.
  • Maintains schema compatibility by checking version requirements before feature implementation.

Usage examples

“Create a new declarative agent project.”
The agent will initialize a new project structure, including the necessary manifest files, provided the workspace is empty and valid for agent development.
“Add an API plugin to my agent using this OpenAPI spec URL.”
The agent will use the ATK CLI to integrate the specified API, map the requested operations, and prompt for necessary metadata updates.
“Localize my agent into French.”
The agent will generate the required tokenized manifests and language files to support French localization.
“Deploy my agent to the local environment.”
The agent will run the provisioning command and provide the M365 test link for the deployed agent.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/declarative-agent-developer/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip declarative-agent-developer.zip -d .agents/skills

Documentation by Microsoft

M365 Agent Developer

Telemetry Tagging

Before running any atk CLI commands, set the session environment variable so all CLI invocations are tagged as skill-initiated:

export ATK_CLI_SKILL=true

Run this once at the start of the session. All subsequent atk commands in the same terminal will inherit it.

⛔ Workspace Check — MANDATORY FIRST STEP

Before doing ANYTHING, check the workspace files to fingerprint the project:

  1. Run npx -y --package @microsoft/m365agentstoolkit-cli atk --version to confirm ATK CLI is installed. If not found → Stop. Tell the user to install ATK.

  2. Check for m365agents.yml or teamsApp.yml at the project root.

  3. Check for appPackage/declarativeAgent.json.

  4. Check for non-agent indicators (package.json with express/react/next, src/index.js, app.py, etc.)

Then follow the decision gate:

ConditionGateAction
Non-agent project files, no appPackage/RejectText-only response. No files, no commands.
No manifest, user wants to edit/deployRejectText-only response. Explain manifest is missing.
No manifest, user wants new projectScaffold→ Scaffolding Workflow
Manifest exists with errorsFixDetect → Inform → Ask (see below). Do NOT deploy.
Valid project, user reports behavior issuesReview→ Instruction Review — run the full 5-phase review workflow
Valid agent projectEdit→ Editing Workflow

Detailed gate rules, examples, and anti-patterns: Workspace Gates

🚫 HARD REJECTION RULES — No Exceptions

These rules override ALL other instructions. If any of these apply, you MUST stop immediately.

  1. NEVER create declarativeAgent.json yourself. If the manifest is missing and the user asked to edit/modify/deploy, respond with text only: explain the manifest is missing, suggest npx -y --package @microsoft/m365agentstoolkit-cli atk new or starting from scratch. Do NOT create the file, do NOT create appPackage/, do NOT "help" by scaffolding implicitly.

  2. NEVER create files in a non-agent project. If the workspace is an Express/React/Django/etc. app without appPackage/, your response must be text-only. Do NOT create any files, do NOT run any commands.

  3. NEVER deploy when errors exist. If the agent manifest has errors, STOP. Do NOT run npx -y --package @microsoft/m365agentstoolkit-cli atk provision — not "to test", not "to demonstrate the error", not "to see what happens". Report the errors and ask the user how to proceed.

🔍 Detect → Inform → Ask (Error-Handling Protocol)

When you encounter ANY problem (missing files, malformed JSON, validation errors, incompatible features), you MUST follow this sequence in order:

  1. Detect — Identify the specific problem. For JSON issues, attempt to parse the file and report syntax errors. For missing fields, check the manifest against the Schema.

  2. Inform — Tell the user BEFORE taking any action. Describe exactly what is wrong ("declarativeAgent.json has malformed JSON: missing comma on line 12, unclosed array on line 18").

  3. Ask — Wait for the user's response before making changes. Do NOT silently fix, auto-correct, or work around the problem.

This protocol applies to:

  • Missing declarativeAgent.json → Detect (file not found) → Inform ("no manifest found") → Ask ("would you like to create a new agent?")

  • Malformed JSON → Detect (parse errors) → Inform (list specific syntax issues) → Ask ("should I fix these syntax errors?")

  • Validation errors → Detect (parse and check manifest) → Inform (list all errors) → Ask ("how would you like to fix these?")

  • Version incompatibility → Detect (feature requires newer version) → Inform ("this feature requires v1.6, your agent is v1.4") → Ask ("should I upgrade?")

Phase Routing

ScenarioWorkflow Reference
Creating a NEW project from scratchScaffolding Workflow
Working with existing .json manifestsEditing Workflow
Adding an API pluginAPI Plugins
Adding an MCP serverMCP Plugin
Adding OAuth to an MCP or API pluginAuthentication
Reviewing or improving existing agent instructionsInstruction Review
User reports agent gives generic/wrong answersInstruction Review
Localizing an agent into multiple languagesLocalization
Adding a new language to an already-localized agentLocalization
Writing agent instructionsConversation Design

ATK CLI Setup

Before running any ATK commands, check if the ATK CLI is available by running npx -y --package @microsoft/m365agentstoolkit-cli atk --version. If not found, STOP and tell the user — do NOT attempt to install it yourself.

All commands use the npx -y --package @microsoft/m365agentstoolkit-cli atk prefix (e.g., npx -y --package @microsoft/m365agentstoolkit-cli atk provision --env local).

Critical Rules

1. Deploy After EVERY Edit

After ANY change to files in appPackage/, you MUST deploy and show the test link before responding:

npx -y --package @microsoft/m365agentstoolkit-cli atk provision --env local --interactive false

Then read M365_TITLE_ID from env/.env.local and ALWAYS present the review UX:

✅ Agent deployed successfully!

🚀 Test Your Agent in M365 Copilot:
🔗 https://m365.cloud.microsoft/chat/?titleId={M365_TITLE_ID}

⛔ Never respond without this link. If you deployed, the test link MUST appear in your response. This is not optional — it is how the user tests their agent.

  • If the manifest has errors → STOP. Fix errors. Do NOT deploy.

  • Exception: user explicitly asks you not to deploy

2. Never Invent Content or Create Missing Files

  • Do NOT invent placeholder names, descriptions, or instructions

  • Do NOT create declarativeAgent.json or appPackage/ if they don't exist — this is a REJECT scenario, not a "help by creating" scenario

  • If required fields are missing, report the gaps, and ASK the user

  • If JSON is malformed, follow Detect → Inform → Ask: parse the file first, tell the user what's broken, then ask before fixing. Use surgical edits (not rewrites)

  • ⛔ NEVER set placeholder values for environment variables that are populated by automation (e.g., <PREFIX>_MCP_AUTH_ID, TEAMS_APP_ID). Leave them empty (VAR_NAME=). Placeholders will be treated as real values and will NOT be overwritten by provisioning.

3. Schema Version Compatibility

Before adding ANY feature, read the version field in declarativeAgent.json and check the Schema feature matrix. If the feature isn't supported in that version, refuse and offer to upgrade.

Key version gates:

  • sensitivity_label, worker_agents, EmbeddedKnowledge → v1.6 only

  • Meetings → v1.5+

  • ScenarioModels, behavior_overrides, disclaimer → v1.4+

  • Dataverse, TeamsMessages, Email, People → v1.3+

4. Use npx -y --package @microsoft/m365agentstoolkit-cli atk add action for API Plugins — NEVER Create Plugin Files Manually

You are forbidden from manually creating ai-plugin.json, OpenAPI specs, adaptive cards, or editing the actions array. Use the CLI:

# ⛔ Always list ALL operations in a single call — NEVER run separate calls per operation
npx -y --package @microsoft/m365agentstoolkit-cli atk add action --api-plugin-type api-spec --openapi-spec-location URL --api-operation "GET /path,POST /path,PATCH /path/{id},DELETE /path/{id}" -i false

Run a single npx -y --package @microsoft/m365agentstoolkit-cli atk add action call per OpenAPI spec, listing all operations as a comma-separated list in --api-operation. Never run separate npx -y --package @microsoft/m365agentstoolkit-cli atk add action calls for different operations from the same spec — this creates multiple plugins instead of one. If npx -y --package @microsoft/m365agentstoolkit-cli atk add action fails, report the error; do NOT fall back to manual creation.

Exception: MCP servers are not supported by npx -y --package @microsoft/m365agentstoolkit-cli atk add action. Use the MCP Plugin workflow instead.

5. MCP Server Integration

When the user mentions an MCP server URL, follow the MCP Plugin workflow. You MUST discover tools via the MCP protocol handshake (initialize → notifications/initialized → tools/list) — NEVER fabricate tool names/descriptions. For authenticated MCP servers, follow the authentication guide to configure OAuth.

6. Always Update Instructions & Starters After Changes

Adding a capability or plugin without updating instructions is incomplete. After ANY change:

  1. Update instructions to describe the new/changed functionality — every data source should have clear intent coverage (WHEN and WHY to use it) per the Instruction Review quality bar. Built-in capabilities don't need exact names; actions/plugins should be named.

  2. Do NOT list tool names, descriptions, or parameters in instructions — these are already in the plugin metadata (ai-plugin.json, MCP manifests, capability config). Instructions should contain decision logic only: WHEN to use each tool, chaining rules, and failure handling.

  3. Stay within the 8,000-character instruction limit — if close to the limit, cut tool descriptions first

  4. Add at least 1 conversation starter per added capability/plugin

  5. Remove starters that reference removed capabilities

  6. Run the Diagnostic Checklist against the updated instructions to verify quality

7. App Name Requirement

Always update the app name and description to something meaningful. Never leave defaults like "My Agent".

References

Shared

  • Authentication — OAuth discovery, credentials, oauth/register lifecycle, OAuthPluginVault

  • Best Practices — Security, performance, testing, compliance

  • Conversation Design — Authoring instructions and conversation starters from scratch

  • Instruction Review — Auditing, diagnosing, and improving existing instructions; anti-pattern detection; before/after rewrites

  • Deployment — ATK CLI workflows, environments, CI/CD

  • Localization — Multi-language support, tokenized manifests, language files

  • Workspace Gates — Detailed gate rules, examples, anti-patterns

Scaffolding
JSON Development

  • Editing Workflow — Step-by-step JSON development instructions

  • Schema — Official JSON schema for agent manifests

  • API Plugins — OpenAPI integration for JSON agents

  • MCP Plugin — MCP server integration with RemoteMCPServer, OAuth, response semantics, logo handling

  • Examples — JSON manifest examples

Files

references/deployment.md

ATK CLI and Deployment for M365 Agents

ATK CLI Overview

The Agents Toolkit (ATK) CLI is the official toolchain for M365 agent project management. It handles the complete agent lifecycle from creation to deployment.

Golden Rule: Check if ATK CLI is available (npx -y --package @microsoft/m365agentstoolkit-cli atk --version). If not found, STOP and tell the user that the ATK CLI is required but not installed. Do NOT attempt to install it yourself. Then use npx -y --package @microsoft/m365agentstoolkit-cli atk for all commands.

🚨 Never use shortcuts, .vscode tasks, or abbreviated commands.

Agent Lifecycle

1. Project Creation
# Create new agent project
npx -y --package @microsoft/m365agentstoolkit-cli atk new \
  -n my-agent \
  -c declarative-agent \
  -with-plugin type-spec \
  -i false

# Navigate into project
cd my-agent

Project structure created:

my-agent/
├── appPackage/
│   ├── manifest.json                   # Teams app manifest
│   ├── declarativeAgent.json           # Declarative agent definition
│   ├── instructions.txt                # Agent instructions
│   └── adaptiveCards/
│       └── card.json                   # Adaptive card template (from template)
├── assets/                             # Asset files directory
├── env/
│   ├── .env.local                      # Local environment (template)
│   └── .env.local.user                 # Local environment (secrets, generated)
├── package.json                        # Node.js dependencies
├── m365agents.yml                      # M365 agents config
├── m365agents.local.yml                # M365 agents local config
└── README.md
2. Provisioning

Provisioning generates M365 Title ID on first time and makes the updated agent available to the developer on Microsoft 365 Copilot.

# Provision for development
npx -y --package @microsoft/m365agentstoolkit-cli atk provision --env dev --interactive false

# Provision for staging
npx -y --package @microsoft/m365agentstoolkit-cli atk provision --env staging --interactive false

# Provision for production
npx -y --package @microsoft/m365agentstoolkit-cli atk provision --env prod --interactive false

# Provision for a custom environment
npx -y --package @microsoft/m365agentstoolkit-cli atk provision --env custom --interactive false

What provisioning does:

  • Registers agent in Microsoft 365 Copilot

  • Generates M365_TITLE_ID and adds to env file

  • Sets up authentication and permissions

  • Registers OAuth credentials (if oauth/register is in the lifecycle — see authentication.md)

⚠️ M365_TITLE_ID requires teamsApp/extendToM365: The M365_TITLE_ID environment variable is generated by the teamsApp/extendToM365 lifecycle step during provisioning. Without this step, the Teams app registers but the agent will not appear in Copilot Chat. If you scaffolded the project with npx -y --package @microsoft/m365agentstoolkit-cli atk new, this step is included automatically. If you set up the project manually, verify that your m365agents.yml includes the teamsApp/extendToM365 lifecycle action — see the mcp-plugin.md scaffold section for the required lifecycle steps.

⚠️ CRITICAL: ALWAYS RENDER THIS AFTER ANY PROVISION OPERATION ⚠️

After EVERY provisioning command (regardless of environment or whether it's first-time or re-provisioning), you MUST output a test link:

Local environment — read M365_TITLE_ID from env/.env.local and construct the URL:

✅ Provision completed successfully!

🚀 Test Your Agent:
🔗 https://m365.cloud.microsoft/chat/?titleId={M365_TITLE_ID}

Non-local environments (dev, staging, prod, etc.) — use the SHARE_LINK value from env/.env.{environment}:

✅ Provision completed successfully!

🚀 Test Your Agent:
🔗 {SHARE_LINK}

This is REQUIRED for:

  • ✅ First-time provisioning

  • ✅ Re-provisioning after changes

  • ✅ Any environment (local, dev, staging, prod, custom)

  • ✅ Every single npx -y --package @microsoft/m365agentstoolkit-cli atk provision command — ALWAYS use --interactive false

Do NOT skip this output. The user needs this link to test their agent.

4. Packaging (Optional)

Package agent for distribution or publishing.

# Package for development
npx -y --package @microsoft/m365agentstoolkit-cli atk package --env dev

# Package for production
npx -y --package @microsoft/m365agentstoolkit-cli atk package --env prod

What packaging does:

  • Creates .zip file in appPackage/build/

  • Validates manifest and package structure

  • Prepares for sharing or publishing

5. Sharing (Shared Agents Only)

Share agents with users or entire tenant.

IMPORTANT: Only for agents with AGENT_SCOPE=shared

Check before sharing:

grep "AGENT_SCOPE=shared" env/.env.dev

If the developers isn't clear on the sharing scope, ask follow-up questions to clarify.

  • Do you want to share the agent with the entire tenant or specific users / groups?

  • What is the environment you want to share in (dev, staging, prod)?

  • If they schoose specific users or groups, what are the email addresses of those users or groups?

Share with entire tenant:

npx -y --package @microsoft/m365agentstoolkit-cli atk share \
  --scope tenant \
  --env dev \
  -i false

Share with specific users:

npx -y --package @microsoft/m365agentstoolkit-cli atk share \
  --scope users \
  --email '[email protected],[email protected]' \
  --env dev \
  -i false
6. Publishing (Optional)

Publish to Microsoft 365 App Store or organizational catalog.

# Publish to catalog
npx -y --package @microsoft/m365agentstoolkit-cli atk publish --env prod

What publishing does:

  • Submits agent to Microsoft 365 catalog

  • Requires admin approval in tenant

  • Makes agent discoverable to users

Environment Management

Agent Scope

Two deployment models:

Personal Agents (AGENT_SCOPE=personal):

  • Each user gets their own instance

  • Agent accesses user's personal data

  • No sharing required

  • Use for: Personal productivity agents

Shared Agents (AGENT_SCOPE=shared):

  • Single instance shared by multiple users

  • Requires explicit sharing via npx -y --package @microsoft/m365agentstoolkit-cli atk share

  • Use for: Team agents, organizational assistants

Environment Files Structure
env/
├── .env.local      # Local development (not committed)
├── .env.dev        # Development environment
├── .env.staging    # Staging environment
└── .env.prod       # Production environment

If there are any secrets or sensitive values, the content will be in a separate file named .env.{environment}.user that is not committed to source control.

env/
├── .env.local.user      # Local development (not committed)
├── .env.dev.user        # Development environment
├── .env.staging.user    # Staging environment
└── .env.prod.user       # Production environment

Common variables in .env files:

# Agent identification
APP_NAME_SHORT=MyAgent
M365_TITLE_ID=U_abc123xyz           # Generated during provision

# Agent configuration
AGENT_SCOPE=shared                  # or 'personal'

# API configuration (if using API plugins)
API_ENDPOINT=https://api.example.com

# Azure resources (generated during provision)
AZURE_RESOURCE_GROUP=rg-myagent-dev
AZURE_APP_SERVICE=app-myagent-dev

Common variables in .env.{environment}.user files:

# API configuration (if using API plugins)
API_KEY=your-api-key

Security best practices:

  • Add env/.env.local to .gitignore

  • Never commit secrets to source control

  • Use different credentials per environment

Version Management

When to Bump Version

Version must be bumped before re-provisioning a shared agent that already has M365_TITLE_ID.

Check if version bump is required:

grep -q "AGENT_SCOPE=shared" env/.env.dev && \
grep -q "M365_TITLE_ID=" env/.env.dev && \
echo "⚠️ VERSION BUMP REQUIRED"

If there is no environment variable to handle the APP_VERSION, create one and assign the current value of the version in the manifest.

How to Bump Version

Edit appPackage/manifest.json:

{
  "version": "${{APP_VERSION}}",  // Update this field
  // ... rest of manifest
}

Edit env/.env.{environment}:

APP_VERSION=1.0.1  # Bump patch, minor, or major as needed
# ... rest of env variables
Semantic Versioning

Follow semver (major.minor.patch):

  • Patch (1.0.0 → 1.0.1): Bug fixes, content updates, minor changes

  • Minor (1.0.0 → 1.1.0): New features, capabilities, backward compatible

  • Major (1.0.0 → 2.0.0): Breaking changes, incompatible updates

Complete Workflows

Initial Deployment Workflow
# 1. Validate
# Run the validation to ensure everything is correct

# 2. Provision (first time only)
# Run the provsion to register agent in M365 and make it available

# 3. Share (only if AGENT_SCOPE=shared)
# Share with users or tenant as needed

# 4. Test agent
# Open link provided in deploy output
Update Workflows

For code changes or manifest changes:

# 1. Validate
# Run validation to ensure changes are correct

# 2. Provision
# Run provision to update agent in M365

For shared agent re-provisioning:

# 1. Bump APP_VERSION in env/.env.{environment}
# Edit version: "1.0.0" → "1.0.1"

# 2. Validate
# Run validation to ensure everything is correct

# 3. Re-provision
# Run provision to update agent in M365

# 4. Share with users (if not already shared)
# Run share command if needed
Multi-Environment Deployment
# 1. Deploy to dev
# Run provision for dev environment
# Test in dev environment

# 2. Deploy to staging
# Run provision for staging environment
# Validate in staging

# 3. Deploy to production
# Run provision for production environment
# Share with tenant if needed

Authentication

Microsoft 365 Authentication

Required for sharing and publishing agents.

# Login to M365
npx -y --package @microsoft/m365agentstoolkit-cli atk auth login m365

# List current authentication
npx -y --package @microsoft/m365agentstoolkit-cli atk auth list

# Logout
npx -y --package @microsoft/m365agentstoolkit-cli atk auth logout m365

Required permissions:

  • Need to have a M365 Copilot license

Testing Agents

Testing Deployed Agents

After deployment, ATK provides a test link:

🚀 Test Your Agent:
🔗 https://m365.cloud.microsoft/chat/?titleId=abc123xyz

Testing checklist:

  • ✅ Agent appears in Copilot

  • ✅ Conversation starters display correctly

  • ✅ Capabilities work (search, API calls, etc.)

  • ✅ Instructions are followed

  • ✅ Error scenarios handled gracefully

  • ✅ Permissions are appropriate

Troubleshooting

Check System Prerequisites
npx -y --package @microsoft/m365agentstoolkit-cli atk doctor

Checks:

  • Node.js version

  • npm version

  • Azure CLI installation

  • Authentication status

  • Network connectivity

Common Issues

"Command not found" or slow first run:

  • ATK CLI downloads on first use (10-30 seconds)

  • Wait for download to complete

  • Ensure internet connectivity

"Authentication required":

# Check auth status
npx -y --package @microsoft/m365agentstoolkit-cli atk auth list

# Login to M365
npx -y --package @microsoft/m365agentstoolkit-cli atk auth login m365

"Environment not provisioned":

  • Check env/.env.{environment} exists

  • Check M365_TITLE_ID is present in env file

  • Run provision for the environment

"Permission denied":

  • Verify Azure Contributor/Owner role

  • Verify M365 admin permissions

  • Check Azure subscription is active

"Version conflict" (shared agents):

  • Bump APP_VERSION in env/.env.{environment}

  • Re-run provision after version bump

"Validation failed":

  • Verify all required manifest fields

  • Ensure icons exist in appPackage/

Best Practices

Environment Strategy

  • Local (.env.local): Developer personal testing

  • Dev (.env.dev): Shared development environment

  • Staging (.env.staging): Pre-production validation

  • Prod (.env.prod): Production deployment

Version Control

  • Commit environment templates (without secrets)

  • Don't commit .env.user.local or files with secrets

  • Use .gitignore for sensitive files

  • Document required environment variables

Deployment Strategy

  1. Develop and test locally

  2. Deploy to dev environment

  3. Validate in staging

  4. Deploy to production

  5. Monitor and iterate

Sharing Strategy

  • Start with user-scoped sharing for testing

  • Expand to tenant-wide after validation

  • Document who has access

  • Review sharing permissions regularly

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server, Needs Node.js

Security

What our scanner noticed· Low risk

  • Phrasing that asks for actions without confirmation
  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/skills · .github/plugins/microsoft-365-agents-toolkit/skills/declarative-agent-developer · commit 0696600
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download declarative-agent-developer.zip