# Advanced Instruction Strategies for AI Employees Great AI Employee instructions are the difference between an AI that frustrates and one that delights. This guide covers advanced techniques to get the most out of your Agents, Managers, and Assistants — moving beyond basic templates into strategies that handle edge cases, improve consistency, and scale reliably. If you're new to instruction design, start with our [Instruction Design for Scoped Autonomy](/blog/instruction-design-scoped-autonomy) guide first. This article builds on those foundations. --- ## 1. Input Types: Know What You're Asking For Every instruction to an AI Employee falls into one of four input types. Understanding these helps you frame requests more effectively. ### Question Input Ask your Agent to answer queries directly. ``` What's the best time to schedule a follow-up with a prospect who hasn't responded in 5 days? ``` ### Task Input Direct your Agent to perform specific actions. ``` Provide a simple list of the 5 most urgent support tickets from today. ``` ### Entity Input Have your Agent classify or operate on specific subjects. ``` Classify these customer inquiries as: billing, technical, or general: 1. "My payment didn't go through" 2. "How do I reset my password?" 3. "What are your office hours?" ``` ### Completion Input Provide partial content for your Agent to extend. This works well when you want consistency in format. ``` Subject: Re: Invoice #1234 Hi Sarah, Thank you for reaching out about your invoice. I've reviewed the details and... ``` **Pro tip**: When using completion input, include examples of the desired output format to guide accuracy. --- ## 2. Zero-Shot vs. Few-Shot Prompting This is one of the most powerful techniques for improving AI Employee performance. ### Zero-Shot: No Examples The Agent relies entirely on its general knowledge and your instructions. ```markdown ## Role You are a customer support agent for TechCorp. ## Task Respond to customer emails professionally and helpfully. ``` **When to use**: Simple, common tasks where the desired behavior is obvious. ### Few-Shot: Include Examples Provide examples demonstrating the exact pattern you want. ```markdown ## Role You are a customer support agent for TechCorp. ## Task Respond to customer emails. Follow the format in these examples: ### Example 1 **Customer**: My order hasn't arrived yet. **Response**: Hi! I'm sorry to hear your order is delayed. Let me look into this for you. Could you please share your order number so I can track it? ### Example 2 **Customer**: How do I return a product? **Response**: Happy to help with your return! You can initiate a return within 30 days of purchase at returns.techcorp.com. Would you like me to walk you through the process? ### Example 3 **Customer**: Is this product compatible with Mac? **Response**: Great question! Yes, our product is fully compatible with Mac OS 10.14 and above. Is there anything else you'd like to know about compatibility? ``` ### Few-Shot Best Practices **Always include examples for important tasks.** We recommend few-shot prompting as the default for any Agent handling external communications. **Use 2-5 examples.** Too few won't establish the pattern; too many can cause overfitting to specific phrasings. **Show what's correct, not what's wrong.** Positive examples are more effective than negative ones. ❌ **Don't do this:** ``` Don't end responses with questions. Don't use overly formal language. Don't include disclaimers. ``` ✅ **Do this instead:** ``` ### Example of ideal response: "Thanks for reaching out! I've updated your account settings. You're all set!" ``` **Maintain consistent formatting.** Every example should follow identical structure—same labels, same spacing, same delimiters. --- ## 3. Structured Formatting with Prefixes Prefixes help your Agent distinguish between different parts of the instruction and produce parseable output. ### Input Prefixes Mark different semantic sections of your input. ```markdown **Context:** Customer has been waiting 10 days for a refund. **Sentiment:** Frustrated **History:** Third contact about this issue **Request:** Check refund status and provide update ``` ### Output Prefixes Signal the expected response format. ```markdown Respond in this format: **Summary:** [one-line summary of the issue] **Action Taken:** [what you did] **Next Steps:** [what the customer should expect] **Timeline:** [when they'll see resolution] ``` ### Example Prefixes for Few-Shot Label each part of your examples consistently. ```markdown ### Example **Input:** Customer asks about shipping times **Classification:** logistics **Priority:** low **Response:** "Standard shipping takes 3-5 business days..." ### Example **Input:** Customer reports security concern **Classification:** security **Priority:** high **Response:** "I'm escalating this immediately to our security team..." ``` --- ## 4. Adding Context Effectively Context grounds your Agent's responses in specific, accurate information rather than general knowledge. ### Bad: Generic Instructions ```markdown Help customers troubleshoot their router issues. ``` ### Good: Specific Context ```markdown Help customers troubleshoot router issues using this reference: ## Router Status Indicators - **Solid Green**: Normal operation - **Blinking Green**: Data transfer in progress - **Solid Amber**: Connecting to network - **Blinking Amber**: Firmware updating (do not unplug) - **Red**: Error state - requires restart - **No Light**: Power issue - check cable and outlet ## Troubleshooting Steps 1. If red light: Unplug for 30 seconds, then reconnect 2. If no light: Check power cable, try different outlet 3. If blinking amber for >10 minutes: Contact support 4. If solid amber for >5 minutes: Restart router Respond using only the information above. ``` **Key principle**: The constraint "Respond using only the information above" keeps your Agent grounded in your context rather than improvising. --- ## 5. Prompt Decomposition: Breaking Down Complex Tasks Complex tasks often fail when given as single instructions. Break them down for better results. ### Strategy 1: Separate Instructions Instead of one complex prompt, create multiple focused Agents. ❌ **One overloaded Agent:** ``` Handle all customer inquiries: answer questions, process returns, escalate complaints, update account information, and generate reports. ``` ✅ **Specialized Agents:** - **Support Agent**: Answers questions, troubleshoots issues - **Returns Agent**: Processes returns and exchanges - **Escalation Agent**: Handles complaints requiring human review ### Strategy 2: Chain Prompts For multi-step tasks, create sequential prompts where one output becomes the next input. ```markdown ## Step 1: Classification Agent Classify this customer email into: billing, technical, general, or escalation. ## Step 2: Response Agent (receives classification) Given this [classification] email, draft an appropriate response following our [classification] guidelines. ## Step 3: Quality Agent (receives draft) Review this draft response. Check for: accuracy, tone, completeness. Suggest improvements or approve for sending. ``` ### Strategy 3: Aggregate Responses Perform different operations in parallel, then combine. ```markdown ## Parallel Analysis - **Agent 1**: Extract key facts from the email - **Agent 2**: Analyze customer sentiment - **Agent 3**: Check customer history ## Aggregation Combine insights from all three analyses into a comprehensive response strategy. ``` **Use your Manager** to orchestrate these patterns by analyzing which decomposition strategies work best for your use cases. --- ## 6. Specifying Response Format Explicit format instructions dramatically improve consistency. ### Length Constraints ```markdown Summarize in one sentence. Keep responses under 100 words. Provide a brief answer (2-3 sentences maximum). ``` ### Structure Constraints ```markdown Return as a bulleted list. Format as a table with columns: Issue | Status | Next Step. Provide a JSON response with fields: summary, action, timeline. ``` ### Starting the Response You can guide format by beginning the response yourself. ```markdown Respond in JSON format starting with: { "status": ``` This technique "primes" the Agent to continue in the expected format. --- ## 7. Iterative Refinement Strategies Prompt engineering is iterative. When results aren't right, try these approaches: ### Technique 1: Rephrase the Request Different wording can yield different results. **Original**: "Categorize this email." **Rephrased**: "Which department should handle this email: Sales, Support, or Billing?" ### Technique 2: Switch to Analogous Tasks If direct instructions fail, reformulate as an equivalent task. **Original** (struggling): ``` Classify the sentiment of this message as positive, negative, or neutral. ``` **Reformulated** (often works better): ``` If you had to choose, which best describes this message? A) The customer is happy B) The customer is unhappy C) The customer has no strong feelings Choose one letter. ``` ### Technique 3: Change Content Order Experiment with arrangement. Sometimes placing examples before instructions works better than after. **Try these orders:** 1. Instructions → Examples → Input 2. Examples → Instructions → Input 3. Input → Examples → Instructions (for analysis tasks) ### Use Assistants for Refinement Before making changes, consult your Assistants: - **Black Hat**: What could go wrong with this instruction? - **Yellow Hat**: What's working well that we should preserve? - **Green Hat**: What creative alternatives could we try? --- ## 8. Structured Instruction Templates Use consistent structure across all your AI Employees. Here's an advanced template: ```markdown You are a [specific role] for [company/product]. Your purpose is to [primary outcome]. - Never [forbidden action 1] - Never [forbidden action 2] - Always [required behavior] - When uncertain, [fallback action] [Background information the Agent needs] [Reference materials] [Current policies] Structure all responses as: 1. [First element] 2. [Second element] 3. [Third element] ### Example 1 **Input**: [sample input] **Output**: [ideal response] ### Example 2 **Input**: [sample input] **Output**: [ideal response] [The specific request or ongoing duty] ``` ### Placement Matters **Put critical instructions first.** Role definitions, behavioral constraints, and output format requirements should appear at the beginning. **Put the specific task last.** After providing all context and examples, end with what you're actually asking for. **Use transition phrases for long contexts.** "Based on the information above..." or "Given these guidelines..." helps the Agent understand what's reference material vs. what's the actual request. --- ## 9. Agentic Workflow Design When your Agents operate autonomously, consider these dimensions: ### Reasoning Dimensions **Logical Decomposition**: How thoroughly should your Agent analyze prerequisites? ```markdown Before responding, identify: 1. What information do I need? 2. What do I already have? 3. What's missing? 4. What assumptions am I making? ``` **Problem Diagnosis**: How deep should root cause analysis go? ```markdown When troubleshooting, consider not just obvious causes but also less probable explanations that could explain the symptoms. ``` ### Execution Dimensions **Adaptability**: Should your Agent stick to plans or pivot when needed? ```markdown If your initial approach isn't working after 2 attempts, try an alternative strategy rather than repeating the same steps. ``` **Persistence**: How aggressively should your Agent retry? ```markdown Retry failed operations up to 3 times with 30-second delays. After 3 failures, escalate to human review rather than continuing. ``` **Risk Assessment**: Distinguish safe from risky actions. ```markdown Safe actions (can do freely): Read data, generate reports, draft responses Risky actions (require confirmation): Send external emails, modify records, process payments ``` ### Interaction Dimensions **Ambiguity Handling**: When to ask vs. assume? ```markdown If a request is ambiguous: - For low-stakes tasks: Make a reasonable assumption and proceed - For high-stakes tasks: Ask one clarifying question before proceeding ``` **Verbosity**: Should your Agent explain its reasoning? ```markdown For customer-facing responses: Be concise, focus on the answer For internal analysis: Show your reasoning and cite sources ``` --- ## 10. Quality Assurance Instructions Build self-checking into your Agent's workflow: ### Explicit Planning ```markdown Before responding: 1. Parse the request into sub-tasks 2. Identify what information you need 3. Plan your approach 4. Then execute ``` ### Self-Critique ```markdown Before sending your response: 1. Re-read the original request 2. Check that your response addresses all parts 3. Verify you haven't violated any constraints 4. Confirm the tone matches guidelines ``` ### Use Managers for Pattern Analysis Your Manager can identify: - Which instruction changes improved response quality - Common failure patterns across Agent interactions - Opportunities to add examples or clarify constraints --- ## Quick Reference: Instruction Quality Checklist - [ ] Clear role and primary outcome defined - [ ] 2-5 few-shot examples for important tasks - [ ] Explicit format requirements (structure, length, style) - [ ] Specific context rather than generic guidelines - [ ] Constraints stated as what TO do, not just what NOT to do - [ ] Complex tasks decomposed into steps or specialized Agents - [ ] Critical instructions placed at beginning - [ ] Specific task placed at end - [ ] Self-checking instructions for high-stakes tasks - [ ] Ambiguity handling rules defined --- ## Putting It All Together Here's a production-ready example combining these techniques: ```markdown You are a Customer Success Agent for CloudSync, a file synchronization service. Your purpose is to help customers resolve sync issues quickly and accurately. - Never share internal system URLs or credentials - Never make promises about specific resolution times - Always verify the customer's account status before troubleshooting - When uncertain, escalate to Tier 2 support rather than guessing ## Common Sync Issues - "Files not syncing": Usually permissions or storage quota - "Sync stuck": Often network or firewall issue - "Duplicate files": Version conflict, needs manual resolution - "Slow sync": Large files or poor connection ## Status Codes - SYNC_OK: Normal operation - SYNC_PAUSED: User-initiated pause - SYNC_ERROR_401: Authentication expired - SYNC_ERROR_507: Storage quota exceeded Structure responses as: 1. **Acknowledgment**: Thank them, confirm you understand the issue 2. **Diagnosis**: What you've identified 3. **Solution**: Step-by-step resolution 4. **Verification**: How they'll know it's fixed 5. **Follow-up**: Offer additional help ### Example 1 **Customer**: My files haven't synced in two days **Response**: Thanks for reaching out! I understand your files haven't been syncing for two days—let's get this resolved. **What I found**: Your account shows SYNC_ERROR_507, which means your storage quota is full. **Solution**: 1. Go to Settings > Storage in the CloudSync app 2. Click "Manage Storage" to see what's using space 3. Delete or move files you no longer need to sync 4. Once under quota, sync will resume automatically **You'll know it's working** when you see the green checkmark icon return. Is there anything else I can help you with today? ### Example 2 **Customer**: Sync is incredibly slow **Response**: I hear you—slow sync is frustrating. Let me help figure out what's happening. **What I found**: You're syncing several large video files (2GB+), which takes longer than typical documents. **Solution**: 1. For immediate relief, you can pause sync on large files: right-click > "Don't sync this file" 2. For better ongoing performance, consider syncing large files overnight 3. Check your network: try connecting via ethernet instead of WiFi for large uploads **You'll know it's improved** when the progress bar moves steadily rather than stalling. Would you like me to walk you through any of these steps? Respond to customer support emails about sync issues. Use the context and examples above to provide accurate, helpful responses. If the issue doesn't match known patterns, gather more information with one clarifying question. ``` --- ## Further Reading - [Instruction Design for Scoped Autonomy](/blog/instruction-design-scoped-autonomy) — Foundational template and principles - [Agent-Responsive Design](/blog/agent-responsive-design) — Designing for agent-legible content - [What is the Agentic Web?](/agentic-web) — Understanding the broader context - [Agentic Web FAQ](/agentic-web/faq) — Common questions answered - Anthropic: [Prompt engineering overview](https://docs.anthropic.com/en/docs/prompt-engineering/overview) - Anthropic: [Prompt engineering for business performance](https://www.anthropic.com/news/prompt-engineering-for-business-performance) - Microsoft Learn: [Develop AI agents on Azure](https://learn.microsoft.com/en-us/training/paths/develop-ai-agents-on-azure/)