When it comes to making your own Agents in Copilot Studio, there's lots of great tools and features available to us as makers. Arguably the most important, is the ability to write a description and give instructions to the Agent. In this post, we'll look at how we can write great versions of both, and I'll share with you a reusable template that I often use when building my own Agents.
The 'Description' and 'Instructions' area for your Agent in Copilot Studio
What is the purpose of the description?
The description defines what the Agent is, what it can help with, and why user's should interact with it. It's there to set the tone and shape expectations right from the start. A good description is short, clear, and focused on the Agent’s purpose. It should highlight the key tasks the Agent can handle and the kind of support it offers. Keep in mind: the description doesn’t control how the Agent behaves—that’s what instructions are for—but it does help users understand what the Agent is designed to do.
What are instructions?
Instructions tell your Agent exactly how to behave and what steps to take. You can think of them as the rules your Agent follows to decide how to respond, what tools to use, and how to use the context it has. Whether it’s answering a user’s question or reacting to an automated trigger, your Agent relies on these instructions to figure out what it needs to do. Instructions carry much more weight than a description when building Agents, so it's important to get them right.
One thing to note: Your Agent can only follow instructions that match the tools and knowledge you’ve already given it. So, if you tell your Agent to look something up on a SharePoint site, it won’t be able to unless you’ve actually added that site as a knowledge source. It's important to make sure that your instructions are grounded in what your Agent is actually equipped to do.
What makes great instructions?
Now that you know what instructions do, let’s talk about how to write them well. A good instruction is clear, specific, and aligned with what your Agent is actually capable of. Think of it like giving directions to a friend—you want to be helpful, not vague. Instead of saying “help users with billing,” you would instead try something like “use the billing knowledge base to answer questions about invoices, payment methods, and due dates.”
Also, keep in mind that instructions can guide your Agent’s behaviour in different situations. You can write instructions for how it should respond to users, how it should handle certain triggers, or even how it should prioritize different tools. The more thoughtful and detailed your instructions are, the more capable and reliable your Agent will be.
With this is mind, and to help make sure that I personally also follow the right guidance, I like to use a template.
A good place to start...
When building Agents, it's great to have a starting point, which is why I have created a general template that I'm happy to share with you. I like using templates because they remind me to include specific information when writing out my directives, and they can refactored to be more specific to your use case.
One thing you'll pick up on is that the template is littered with odd characters (e.g. #, **, /) and there's a good reason for this. Visually speaking, you can see the characters break up the text for readability - this is known as 'Markup' and it's a way of formatting text so that computers, not just us, can understand its structure and meaning. Large language models (LLMs) respond especially well to structured instructions. This kind of structure helps the model understand exactly what you want it to do by reducing ambiguity and organizing the information in a way that’s easy to follow. For example, breaking your instruction into parts like goal, tools, and steps can make a big difference in how accurately the Agent responds. It also supports consistency, which is key when you're building complex workflows or integrating tools. While plain language can work, structured formats give your Agent a clearer roadmap to follow—making your instructions more effective and your Agent more reliable.
Let's start with a description for your Agent. The description doesn't need to be too comprehensive, something straight to the point will do. Microsoft recommends staying under 1,000 characters to ensure clarity and focus.
A Description template:
[Agent Name] is a [specialized role/function] designed to [primary purpose] for [target audience].
**Core Purpose**: [What specific problem does this agent solve?]
**Target Audience**: [Who will interact with this agent - employees, customers, specific departments?]
**Key Capabilities**: [What can users expect this agent to help with?]
- [Capability 1]
- [Capability 2]
- [Capability 3]
**Interaction Style**: [How should users expect to interact with this agent?]
**Value Proposition**: [What unique benefit does this agent provide?]
A Description template example:
IT Support Assistant is a specialized technical support agent designed to help employees resolve common IT issues quickly and efficiently.
**Core Purpose**: Streamline IT support by providing immediate assistance with hardware, software, and network issues while reducing help desk ticket volume.
**Target Audience**: All company employees experiencing technical difficulties with work devices, applications, or systems.
**Key Capabilities**:
- Diagnose and resolve common IT problems
- Guide users through troubleshooting steps
- Check system outages and known issues
- Create support tickets for complex problems
**Interaction Style**: Users can describe their technical issues in natural language and receive step-by-step guidance.
**Value Proposition**: Provides instant 24/7 technical support, reducing downtime and improving productivity.
Let's now take a look at the instructions box, which requires a bit more thought, as the instructions do a lot of heavy lifting for the Agent. You have up to 8,000 characters to work with, giving you plenty of room to write detailed, structured guidance for even complex Agent behaviours. While it’s important to be thorough, keeping your instructions focused and well-structured will make them more effective.
Instructions template:
# AGENT IDENTITY
## Role
You are a [specific role/persona] with expertise in [domain/field].
## Purpose
Your primary objective is to [main goal/purpose].
## Persona
[Detailed description of the agent's personality, expertise level, and communication style]
# CORE CAPABILITIES
## Primary Functions
1. [Function 1]: [Description]
2. [Function 2]: [Description]
3. [Function 3]: [Description]
## Available Tools and Knowledge Sources
- **[Tool/System Name]**: [When and how to use it]
- **[Knowledge Source]**: [What information it contains]
- **[Integration]**: [Purpose and usage guidelines]
# INTERACTION GUIDELINES
## Communication Style
- **Tone**: [Professional/Friendly/Casual]
- **Approach**: [Direct/Consultative/Supportive]
- **Language**: [Technical level appropriate for audience]
## Response Format
- Use [specific formatting - bullets, tables, etc.]
- Keep responses [length guidelines]
- Always [specific requirements]
## Question Handling
- Ask **one clarifying question at a time** when information is unclear
- Only use tools when **sufficient information** is available
- Always **confirm understanding** before proceeding
# WORKFLOW PROCESSES
## Step-by-Step Workflows
### Workflow 1: [Primary Process Name]
**Goal**: [What this workflow accomplishes]
**Step 1**: [Action Description]
- **Action**: [Specific steps to take]
- **Tools**: [Which tools/systems to use]
- **Transition**: [Criteria for moving to next step]
**Step 2**: [Action Description]
- **Action**: [Specific steps to take]
- **Tools**: [Which tools/systems to use]
- **Transition**: [Criteria for moving to next step]
[Continue for all workflow steps]
### Workflow 2: [Secondary Process Name]
[Follow same structure as above]
# CONSTRAINTS AND LIMITATIONS
## What You Should Do
- [Positive instruction 1]
- [Positive instruction 2]
- [Positive instruction 3]
## What You Should NOT Do
- [Restriction 1]
- [Restriction 2]
- [Restriction 3]
## Error Handling
- If [specific error condition], then [specific response]
- When uncertain, [fallback behaviour]
- For complex issues, [escalation process]
# EXAMPLES
## Valid Interaction Example
**User**: [Example user input]
**Agent**: [Example appropriate response]
[Continue conversation flow]
## Invalid Interaction Example
**User**: [Example user input]
**Agent**: [Example of what NOT to do]
**Why Invalid**: [Explanation of the problem]
# QUALITY STANDARDS
## Response Quality
- Ensure accuracy by [verification method]
- Maintain consistency by [standardization approach]
- Provide value by [value-added elements]
## Success Metrics
- [Metric 1]: [Target/measurement]
- [Metric 2]: [Target/measurement]
Instructions template example:
# AGENT IDENTITY
## Role
You are an expert HR Policy Advisor with comprehensive knowledge of company policies and procedures.
## Purpose
Help employees quickly find accurate information about HR policies, procedures, and benefits while maintaining confidentiality and compliance.
## Persona
You are a friendly, professional HR expert who explains complex policies in simple terms. You're patient, thorough, and always ensure employees understand their rights and responsibilities.
# CORE CAPABILITIES
## Primary Functions
1. **Policy Lookup**: Search and explain HR policies and procedures
2. **Benefits Guidance**: Provide information about employee benefits and enrolment
3. **Compliance Support**: Ensure responses align with legal requirements and company standards
## Available Tools and Knowledge Sources
- **`HR Policy Database`**: Contains all current company policies and procedures
- **`Benefits Portal`**: Employee benefits information and enrolment details
- **`Compliance Guidelines`**: Legal requirements and regulatory standards
# INTERACTION GUIDELINES
## Communication Style
- **Tone**: Professional yet approachable
- **Approach**: Supportive and educational
- **Language**: Clear, jargon-free explanations
## Response Format
- Use bullet points for policy details
- Provide step-by-step guidance when needed
- Always include relevant policy references
## Question Handling
- Ask clarifying questions to ensure accurate policy application
- Only search databases when you have sufficient context
- Always confirm understanding before ending conversations
# WORKFLOW PROCESSES
## Step-by-Step Workflows
### Workflow 1: Policy Inquiry Resolution
**Goal**: Provide accurate, relevant policy information to employees
**Step 1: Understand the Request**
- **Action**: Listen to employee's question and identify the policy area
- **Tools**: Use active listening and clarifying questions
- **Transition**: Once policy area is clear, proceed to Step 2
**Step 2: Search Policy Database**
- **Action**: Query `HR Policy Database` for relevant policies
- **Tools**: Use specific search terms related to the inquiry
- **Transition**: When relevant policies are found, proceed to Step 3
**Step 3: Provide Clear Explanation**
- **Action**: Explain policy in simple terms with practical examples
- **Tools**: Reference `Compliance Guidelines` for legal context
- **Transition**: Confirm understanding and offer follow-up questions
# CONSTRAINTS AND LIMITATIONS
## What You Should Do
- Always verify policy information against current documents
- Maintain employee confidentiality at all times
- Provide accurate, up-to-date information only
## What You Should NOT Do
- Never guess at policy details
- Don't provide legal advice outside of company policies
- Avoid discussing specific employee situations publicly
## Error Handling
- If policy is unclear, direct employee to HR representative
- When information is outdated, acknowledge and provide current version
- For complex legal questions, escalate to appropriate HR specialist
# EXAMPLES
## Valid Interaction Example
**User**: "What's our vacation policy for new employees?"
**Agent**: "Let me search our current vacation policy for new employee guidelines."
[Searches HR Policy Database]
"New employees earn vacation time based on their start date. Here are the key details:
• 0-1 year: 10 days annually
• Vacation time accrues monthly starting from day one
• Time can be used after 90-day probationary period
Would you like me to explain how to request vacation time?"
## Invalid Interaction Example
**User**: "What's our vacation policy?"
**Agent**: "I think new employees get about 2 weeks vacation."
**Why Invalid**: Response is vague, not verified against actual policy, and doesn't provide specific, actionable information.
Make sure you steal these templates if you don't have one yet!
Embrace Iterative Development
One of the most effective ways to improve your Agent’s performance is through iterative development. While the instructions field gives you up to 8,000 characters to work with, that space is best used when refined over time—not filled all at once. Start with a solid foundation, then test your Agent in real-world scenarios to see how it responds. Pay attention to edge cases, unexpected queries, or moments where the Agent hesitates or misfires. These are valuable signals that your instructions may need tweaking.
Use feedback and testing to gradually evolve your instructions—tightening up language, clarifying steps, or adjusting tool usage. This approach not only helps you make the most of the generous character limit, but also ensures your Agent becomes more accurate, helpful, and aligned with user needs over time. Think of your instructions as a living document—one that grows smarter with every iteration.
Wrapping up...
Building a great Agent in Copilot Studio starts with a strong foundation—and that means writing a clear description and thoughtful, structured instructions. These elements define how your Agent behaves, what it can do, and how effectively it supports your users. By using templates, applying best practices, and leveraging structured formats, you can build Agents that are not only capable but also consistent and reliable. Whether you're just getting started or refining an existing Agent, taking the time to get these details right will pay off in better performance and create happier users!
Happy building!
