Agent Types: Task, Autonomous & Prompt/Response
Not all agents are created equal. Learn the three fundamental agent types in the Microsoft ecosystem — task agents, autonomous agents, and prompt/response agents — including when to use each, how they differ in governance, and the architectural patterns behind them.
Three ways agents work
Think of three types of colleagues:
A task agent is like a meticulous assistant who follows a checklist. “When a new hire starts, send the welcome email, create their accounts, schedule their orientation, and notify their manager.” It does tasks in order, step by step.
An autonomous agent is like a proactive team member who monitors situations and acts without being asked. “I noticed inventory is running low on brake pads — I’ve already placed a reorder with the supplier based on our rules.” It works independently, often in the background.
A prompt/response agent is like a knowledgeable colleague you chat with. “What’s our return policy for electronics?” → “Electronics can be returned within 30 days with receipt…” It answers questions using its knowledge base.
The three agent types compared
| Feature | Trigger | Behaviour | Human Involvement | Governance Level |
|---|---|---|---|---|
| Task agent | User action or system event starts the workflow | Follows a defined sequence of steps — collects data, calls APIs, creates records | Human may provide input at steps; reviews output | Medium — predefined flow limits what it can do |
| Autonomous agent | Schedule, event, or condition triggers it automatically | Monitors, reasons, decides, and acts independently — no user prompt needed | Minimal — may notify humans of actions taken | High — can act without oversight, needs strict guardrails |
| Prompt/response agent | User asks a question or makes a request | Searches knowledge, reasons over context, generates a natural language response | User drives the conversation; agent responds | Low to medium — responses are advisory, user decides what to do |
Designing task agents
Task agents are workflow executors. They’re ideal for repeatable business processes with defined steps.
Design pattern:
- Trigger — user clicks a button, form is submitted, record is created
- Collect — gather required information (from user input or data sources)
- Process — execute steps (create records, call APIs, send notifications)
- Decide — branch based on conditions (approval needed? escalation required?)
- Complete — mark the task as done, notify stakeholders
Examples in business solutions:
| Process | Steps | Platform |
|---|---|---|
| Employee onboarding | Create accounts → assign licences → schedule training → notify manager | Copilot Studio with Power Automate actions |
| Purchase order approval | Validate budget → route to approver → update D365 SCM → notify supplier | Copilot Studio with D365 connectors |
| Customer complaint handling | Log case → classify severity → assign to team → track SLA → escalate if overdue | D365 Customer Service + Copilot Studio |
Scenario: Natalie designs a task agent for invoice processing
Natalie’s client (a logistics company) processes 500 supplier invoices per week. Currently, a team of 3 people manually checks each invoice against the purchase order, flags discrepancies, and routes for approval.
Task agent design:
- Trigger: New invoice arrives in email inbox
- Extract: AI reads the invoice (using document intelligence) and extracts key fields
- Match: Agent compares invoice data against the D365 purchase order
- Decide: If amounts match within 2% tolerance → auto-approve. If discrepancy > 2% → flag for human review
- Process: Create payment record in D365 Finance, update PO status
- Notify: Send confirmation to supplier, alert AP team of flagged invoices
Platform choice: Copilot Studio for the conversational interface + Power Automate for the workflow steps + D365 Finance connector for data
Designing autonomous agents
Autonomous agents are the most powerful — and the most dangerous. They act without user prompts, making governance critical.
Design pattern:
- Monitor — continuously watch for events, conditions, or scheduled triggers
- Reason — analyse the situation using AI models and business rules
- Decide — determine the appropriate action
- Act — execute the action (create records, send communications, update systems)
- Report — log what was done and notify relevant stakeholders
Critical design considerations:
| Consideration | Why It Matters | Design Decision |
|---|---|---|
| Action boundaries | What can the agent do without approval? | Define maximum authority — e.g., “can reorder up to $10,000; above that, needs human approval” |
| Rollback capability | What if the agent makes a wrong decision? | Design undo mechanisms for every automated action |
| Monitoring and alerting | How do you know what the agent is doing? | Real-time dashboard of actions taken, anomaly detection |
| Kill switch | How do you stop the agent immediately? | Admin override that pauses all autonomous actions |
| Audit trail | Who’s accountable for the agent’s actions? | Log every decision with reasoning, input data, and timestamp |
Scenario: Kai designs an autonomous supply chain agent
Kai designs an autonomous agent for Apex Industries that monitors supply chain risk:
Trigger: Runs every 4 hours, scanning supplier data, weather APIs, and D365 SCM inventory levels
Behaviour:
- Detects that a key supplier’s shipping port has been closed due to a storm
- Identifies 12 purchase orders that will be delayed
- Automatically contacts alternative suppliers from the approved vendor list
- Places expedited orders for critical components (within the $10,000 auto-approval limit)
- Escalates to procurement manager for orders above the limit
- Sends a summary to Lin (CTO) with the impact assessment
Guardrails:
- Cannot exceed $10,000 per order without human approval
- Can only order from pre-approved suppliers
- Must log every action with reasoning
- Kill switch available to procurement team in D365 SCM
Designing prompt/response agents
Prompt/response agents are conversational — they answer questions, provide recommendations, and guide users through decisions.
Design pattern:
- Receive — user sends a natural language prompt
- Understand — agent classifies intent and extracts entities
- Retrieve — search knowledge sources for relevant information
- Reason — generate a response using the model and retrieved context
- Respond — deliver a natural language answer, possibly with follow-up suggestions
Key design decisions:
- Knowledge scope — what should the agent know about? (Too broad = hallucination risk; too narrow = “I don’t know” frustration)
- Tone and persona — professional? casual? clinical? Match the audience
- Follow-up behaviour — should the agent ask clarifying questions or give its best guess?
- Escalation trigger — when should it hand off to a human?
Exam tip: choosing the right agent type
The exam frequently presents a scenario and asks which agent type to recommend:
- “Process runs on a schedule without user interaction” → Autonomous agent
- “Users need to complete a multi-step workflow” → Task agent
- “Employees need to ask questions about company policies” → Prompt/response agent
- “System should automatically reorder when inventory drops” → Autonomous agent
- “Customer submits a form and the system processes it step by step” → Task agent
- “Sales reps want AI-generated insights about their deals” → Prompt/response agent
Key differentiator: Task agents follow YOUR defined steps. Autonomous agents make THEIR OWN decisions. Prompt/response agents answer QUESTIONS.
Flashcards
Knowledge check
CareFirst Health needs an AI solution that monitors patient appointment no-shows. When a patient misses an appointment, the system should automatically reschedule within 48 hours, send a reminder, and flag chronic no-show patients for outreach by the patient experience team. Which agent type should Jordan design?
Natalie's client needs an agent that guides loan officers through a 12-step mortgage application review process, collecting documents, running credit checks, and routing for approval at each stage. Which agent type is most appropriate?
Next up: Foundry Tools & Code-First Solutions — proposing the right Foundry tools for each requirement, designing code-first generative pages, and using agent feeds in apps.