Copilot Studio Deep Agents

This repository contains a Microsoft Copilot Studio agent that adds a Deep Agent style planning layer using a custom write_todos tool.

Main project folder:

• DeepAgent

What this demonstrates:

• Upfront planning for complex user requests
• Structured task tracking during execution
• Plan updates as new information appears
• Optional plan review with the user before full execution

Copilot Studio Deep Agent - Full Details

Copilot Studio Deep Agent is a planning-first implementation pattern for complex tasks in Microsoft Copilot Studio.

It is inspired by the Deep Agents concept from LangChain and is designed for scenarios where default step-by-step orchestration is not enough.

The key idea is simple:

• Generate an explicit task plan up front
• Track progress while executing
• Update the plan as new information appears
• Optionally review or adjust the plan with the user before execution

Why this exists

A standard Copilot Studio agent behaves like a ReAct agent:

• It reasons and acts iteratively
• It verifies outputs at each step
• It chooses the next action based on current context

That is often good enough, but for larger requests you may need stronger upfront planning and visible progress tracking.

This project adds that missing planning layer by introducing a custom planning tool named write_todos.

Core behavior in this project

The main agent instructions enforce a planning workflow:

• Always start with write_todos to produce the plan
• Update progress after each execution step by calling write_todos again
• Continue until all todo items are marked as completed

This behavior is configured in agent.mcs.yml.

Custom planning tool: write_todos

The custom topic write_todos.mcs.yml acts as a structured planning tool.

It accepts and returns a todo table where each item has:

• content: description of the task step
• status: pending, in_progress, or completed

The tool guidance encourages:

• Breaking complex requests into clear, discrete steps
• Marking one active step as in_progress during execution
• Updating status immediately after each completed step
• Revising tasks as needed when new information appears
• Avoiding this tool for trivial requests

Good fit scenarios

Use this pattern when you need:

• Multi-step execution with clear progress visibility
• Plan validation with the user before action
• Adaptive replanning during long or complex tasks

Avoid it for very simple requests where a single direct response is enough.

Notes

• This pattern can overlap with capabilities in newer reasoning models.
• The difference here is explicit, user-visible planning and plan updates via a custom tool.

Acknowledgment

This implementation idea was inspired by the LangChain Deep Agents concept, adapted for Microsoft Copilot Studio.