Dataverse Business Skills: Teaching Your Agent How Your Business Actually Works

The Problem Nobody Talks About

You’ve connected your agent to Dataverse. It can query records, read tables, and return data.

And yet — it still get’s it wrong.

Not because the data is wrong. Not because the agent is broken. But because the agent has no idea how your business operates.

It doesn’t know that a lead in your CRM isn’t “qualified” until the budget and authority fields are confirmed. It doesn’t know that a discount above 15% requires senior sales manager approval. It doesn’t know that when a vendor is onboarded, three separate Dataverse tables need to be updated in a specific sequence.

That institutional knowledge lives in people’s heads — in the minds of your best consultants, your senior sales reps, your experienced support agents. And until now, there was no way to give that knowledge to an AI agent.

That changes with Dataverse Business Skills — now in public preview.


What Are Dataverse Business Skills?

Business Skills are natural-language process instructions, stored centrally in Dataverse, that AI agents discover and follow at runtime.

Think of them as the SOPs your best employee would write down — except instead of sitting in a SharePoint folder nobody reads, they’re directly consumed by every agent connected to your Dataverse environment via MCP.

Each skill describes:

  • What the process is (the description agents use to decide when to invoke it)
  • How to execute it (step-by-step instructions written in Markdown)
  • Supporting materials (policy documents, SOPs, templates, forms — attached as resources)

The key insight: write once, use everywhere. A Business Skill defined in your environment is available to any MCP-compatible agent — Copilot Studio, GitHub Copilot in VS Code, Azure AI Foundry, Claude Desktop, Claude Code. Update the skill once and every agent picks up the change immediately. No republishing. No individual agent patching.


How to Create Your First Business Skill

Prerequisites Before You Start

Before you touch the Business Skills UI, make sure:

  1. Your environment is a Managed Environment — this is non-negotiable
  2. Dataverse MCP server is configured and enabled for the environment
  3. Dataverse Intelligence is enabled in the Power Platform Admin Center

If you skip any of these, the Business Skills page simply won’t appear.

Step-by-Step: Creating a Skill from the UI

1. Navigate to the Business Skills page

Go to make.powerapps.com, select More from the left navigation, then Business Skills (preview). Pin it to the nav bar — you’ll be visiting it frequently.

2. Create a new skill

Select New Business Skill. You’ll need:

  • Name — a unique, descriptive name. A prefix from your preferred solution is auto-generated.
  • Description — this is critical. Agents read this description to decide whether to invoke the skill. Write it like you’re answering the question: “When should an agent use this skill?”
  • Instructions — the actual step-by-step process, written in Markdown.

3. Add supporting resources

After saving, attach supporting files in the Resources section — policy documents, calculation sheets, SOP templates. Limit is 20 MB per file. Note: in Copilot Studio, only text-based files are supported, and only the first 20 KB is read.

4. Control visibility and sharing

By default, skills are Individual — only you and people you explicitly share with can see them. When a skill is ready for production, change visibility to Organization so all users with basic Dataverse privileges can benefit from it. Share with specific users or teams as Viewer (read-only) or Co-owner (can edit).

5. Manage the skill lifecycle

  • Active (default) — agents can discover and use it
  • Deactivated — skill exists but agents cannot invoke it. Use this while drafting or reviewing
  • Deleted — permanent, cannot be undone. Any agent referencing it loses that capability

Creating a Skill via the Dataverse MCP Server

You can also create and update skills conversationally through any MCP-connected agent:

Ask your agent: "Create a new business skill for qualifying a CRM lead.
The process should check budget, authority, need, and timeline
before marking the lead as Sales Qualified."

The MCP tools that support this:

ToolWhat it does
upsert_skillCreates or updates a skill
delete_skillPermanently removes a skill
searchFinds skills by keyword
describeGets full details of a skill

ALM: Moving Skills Across Environments

Skills are solution-aware. Add them to your Power Platform solutions and promote them through Dev → Test → Prod via your existing ALM pipeline. No special handling needed — they travel with the solution like any other component.


Writing Great Skill Instructions — The Architect’s Guide

This is where most implementations fail. The technical setup is straightforward. Writing instructions that produce consistent, accurate agent behaviour is the hard part.

Here’s what I’ve learned.

✅ DO: Write the Description as a Trigger Condition

The description is not a summary for humans — it’s a trigger condition for agents. Write it to answer: “In what situation should this skill be followed?”

Bad description:

This skill is about lead qualification.

Good description:

Follow this skill when a user asks to qualify, score, or evaluate a CRM lead, or when determining whether a lead should be moved to the Sales Qualified stage in the pipeline.

The more precise the description, the more reliably the agent invokes the skill at the right moment.


✅ DO: Use Numbered Steps, Not Paragraphs

Agents parse structured instructions better than flowing prose. Use numbered steps for sequential processes.

Bad instructions:

The agent should first check the budget field and if it’s confirmed then look at the authority field to see if the contact has decision-making power and after that check the need and timeline before qualifying.

Good instructions:

markdown

## Lead Qualification Process
1. Check the `budgetconfirmed` field on the Lead record.
- If FALSE or NULL, ask the user to confirm the prospect's budget range before proceeding.
- If TRUE, proceed to step 2.
2. Check the `decisionmaker` field.
- If FALSE, record the name of the actual decision-maker in the `decisionmakername` field and proceed.
- If TRUE, proceed to step 3.
3. Verify that `needidentified` is TRUE.
- If FALSE, document the identified need in the `needdescription` field before proceeding.
4. Check `purchasetimeframe` is not NULL.
- Valid values: "Immediate", "1-3 months", "3-6 months", "6-12 months".
- If NULL, ask the user for the expected timeframe.
5. If all four criteria are confirmed, update `leadqualificationcode` to "Sales Qualified" and set `qualifiedon` to today's date.

✅ DO: Reference Exact Field Names

When your skill involves Dataverse tables, always reference the actual schema name of fields — not the display label. This eliminates ambiguity and prevents the agent from guessing.

Use the Dataverse Plugin or PAC CLI to confirm field schema names before writing skills that touch specific tables.


✅ DO: Define Business Rules Explicitly

Don’t assume the agent knows your business rules. State them.

markdown

## Discount Approval Rules
- Discounts up to 10%: Sales Rep can approve independently.
- Discounts 11–15%: Requires Sales Manager approval. Set `approvalrequired` = TRUE and `approvalthreshold` = "Manager".
- Discounts above 15%: Requires VP Sales approval. Set `approvalrequired` = TRUE and `approvalthreshold` = "VP". Do not proceed until `approvalstatus` = "Approved".

✅ DO: Use Resources for Complex Reference Material

Attach your actual SOP documents, policy PDFs, or calculation templates as skill resources. This offloads complex reference content from the instruction text and keeps the instructions clean and navigable.

Remember: Copilot Studio only reads the first 20 KB of a text resource. If your SOP is longer, put the most critical rules at the top of the document.


✅ DO: Deactivate Skills During Drafting

Never leave a half-written skill in Active state. Agents will attempt to follow incomplete instructions and produce inconsistent, unreliable results. Deactivate the skill until it’s reviewed and approved.

Build a review workflow: draft → deactivate → peer review → activate for testing → promote to Org visibility.


❌ DON’T: Write One Giant Skill for Everything

This is the most common mistake I see. Architects try to cram an entire business process — lead qualification, opportunity management, contract creation — into a single skill.

One skill. One process. Keep each skill focused on a single, well-defined task. If a process has more than 10 steps, consider whether it should be decomposed into multiple skills.


❌ DON’T: Use Vague Language

Agents cannot resolve ambiguity the way humans can. Avoid:

  • “Check the relevant fields” → name the fields explicitly
  • “Follow normal approval procedures” → state the procedures in full
  • “Update as appropriate” → specify exactly what to update and to what value

Every instruction that requires interpretation is an instruction that will be interpreted differently each time.


❌ DON’T: Forget to Test with the Actual Agent

A skill that reads well to a human may not behave as expected when an agent executes it. After creating a skill, always test it by connecting to the Dataverse MCP server and running scenarios that should and should not trigger the skill.

Test the edges: What happens when required fields are missing? What does the agent do if a business rule condition isn’t met? Does it ask for clarification, or does it silently skip the step?


❌ DON’T: Set Org Visibility Before Peer Review

Visibility set to Organization means every MCP-connected agent in your environment can discover and execute the skill. Publish prematurely and you’ve deployed untested business logic to production agents at scale.

Gate it: Individual → tested with one agent → reviewed by process owner → Organisation.


❌ DON’T: Write Instructions for One Agent

Business Skills are designed to be agent-agnostic. Don’t write instructions that only work in Copilot Studio, or that reference specific UI elements of a particular agent client. Write process logic, not agent-specific commands.


A Real-World Example: Vendor Onboarding Skill

Here’s a concise example of a well-structured Business Skill for a vendor onboarding process in a CRM context:

Name: prefix_VendorOnboarding

Description:

Follow this skill when a user requests to onboard a new vendor, create a vendor profile, or register a supplier in the system.

Instructions:

markdown

## Vendor Onboarding Process
### Step 1: Create the Vendor Account record
- Create a new Account record with `accounttypecode` = "Vendor"
- Set `name`, `websiteurl`, `telephone1`, and `emailaddress1` from user input
- Set `statuscode` = "Pending Approval"
### Step 2: Create the Primary Contact
- Create a Contact record linked to the Account
- Capture `firstname`, `lastname`, `emailaddress1`, `jobtitle`
- Set `contacttypecode` = "Vendor Contact"
### Step 3: Create the Vendor Profile record
- Create a record in the `prefix_vendorprofile` table
- Link to the Account created in Step 1
- Set `prefix_paymentterms` from user input (default: "Net 30")
- Set `prefix_taxregistrationnumber` from user input
- Set `prefix_compliancestatus` = "Pending"
### Step 4: Notify the Procurement Team
- Set `prefix_onboardingstatus` on the Account to "Awaiting Review"
- Confirm to the user that onboarding has been initiated and the procurement team will complete the review within 5 business days.
### Business Rules
- Do not set `statuscode` to "Active" — only the procurement team can activate a vendor.
- If `prefix_taxregistrationnumber` is not provided, set `prefix_compliancestatus` = "Tax ID Required" and inform the user before proceeding.

Where Business Skills Fit in the Bigger Picture

Business Skills are not a replacement for Dataverse plugins, Power Automate flows, or business rules. They are a new layer in the architecture stack:

LayerTechnologyPurpose
Data enforcementDataverse Plugins (C#)Enforce rules at the platform level, regardless of entry point
Process automationPower Automate FlowsAutomated, trigger-based processes
Agent process guidanceBusiness SkillsTeach agents how to perform processes through MCP
Agent knowledge groundingDataverse MCP ServerConnect agents to structured business data

Use the right tool for the right job. Business Skills shine when the process is context-dependent, conversational, or requires human-in-the-loop judgment. For hard enforcement of data integrity rules, Dataverse plugins remain the right choice.


Getting Started Today

  1. Enable Dataverse Intelligence in the Power Platform Admin Center
  2. Ensure your environment is a Managed Environment with Dataverse MCP configured
  3. Navigate to Business Skills in make.powerapps.com
  4. Start with one skill for a well-understood process — your lead qualification criteria, your discount approval rules, your first-response SLA checklist
  5. Test it with a Copilot Studio agent or GitHub Copilot before promoting to Org visibility
  6. Explore the sample skills on GitHub for production-ready starting points

The shift Microsoft is making is clear: six months ago, agents could access your data. Now, they can understand your business. The wall between data access and business intelligence is coming down — and Business Skills are the mechanism that makes it possible.


Found this useful? Follow the Ecellors blog and the Ecellors Consulting LinkedIn page for weekly Power Platform architecture insights and new features.