The new Microsoft Copilot Studio and Skills: Turning AI Agents into Practical Digital Assistants

Microsoft Copilot Studio has introduced a redesigned experience for creating AI agents. The new interface is cleaner, more structured, and focused on describing what an agent should achieve instead of manually defining every possible conversation path.

The most exciting addition is the support for Skills. Skills allow an agent to do much more than answer questions: they can provide reusable instructions, process information, generate files, create charts, and even execute scripts.

A new approach to building agents

In the new Copilot Studio experience, the most important configuration options are collected in a central Build area. Here, makers can define:

• the name, description, icon, and visual appearance of the agent,
• instructions that determine how the agent should behave,
• the AI model used by the agent,
• knowledge sources such as SharePoint content or uploaded files,
• tools, connectors, and MCP servers,
• reusable Skills,
• connected specialist agents, and
• memory for retaining relevant user information between conversations.

For example, a human resources agent could be instructed to answer questions in a friendly and professional way, use the company handbook stored in SharePoint, and ask for missing information before preparing a leave request.

What is a Skill?

A Skill is a reusable capability that teaches an agent how to complete a particular type of task. It normally contains a name, a description, and a set of instructions. Additional files such as scripts, templates, and reference documents can also be included.

A helpful way to think about Skills is to compare them with specialist employees. One specialist may analyze a document, another may create a chart, and a third may generate an Excel workbook. The agent acts as the coordinator and selects the appropriate specialist for the user’s request.

Unlike general agent instructions, which describe the agent’s overall behavior, a Skill should ideally focus on one well-defined capability. This makes Skills easier to understand, test, maintain, and reuse in other agents.

Skills can execute scripts

One of the most powerful capabilities is that a Skill can include and execute scripts. This opens up many possibilities that go far beyond generating a text response.

Depending on the compilers and runtimes available in the agent’s isolated container environment, Skills can execute different kinds of code, including:

• Python for data analysis, calculations, document processing, charts, and file generation,
• JavaScript and Node.js for transforming data, validating information, processing JSON, or using Node-based packages,
• Go for compact utilities and efficient data-processing tasks,
• Bash and Shell scripts for file operations, automation steps, and command-line processing, and
• additional programming languages when the required compiler or runtime is installed and available in the isolated container.

The script execution takes place in an isolated environment. This provides a controlled workspace in which the agent can process files, execute commands, run tests, and generate results without running code directly on the user’s computer.

The exact runtimes, libraries, package-installation options, network access, and resource limits can depend on the current Copilot Studio environment, tenant configuration, and Microsoft service capabilities. These dependencies should therefore be verified before designing a business-critical solution.

Practical examples for script-based Skills

A Python Skill could analyze the answers from an employee survey and create a chart showing the most common topics. A second Skill could take the same results and generate an Excel workbook for the management team.

A JavaScript Skill could read JSON data returned by a business application, verify that all required fields are present, and convert the information into a format that another system understands.

A Bash Skill could inspect a collection of files, identify incorrect filenames, and prepare a report containing the affected documents. A Go-based utility could process a larger data file and return a compact summary to the agent.

Skills can also use existing libraries when their installation is supported. For example, a Python package could help create a chart, while a Node.js package could generate or validate a structured document.

From text analysis to charts and Excel files

The video demonstrates the concept using a simple word-statistics scenario. Although the example is deliberately uncomplicated, it clearly illustrates how several Skills can work together.

1. The first Skill receives a text and runs a Python script to count the words.
2. It returns a structured table containing the word statistics.
3. A second Skill uses these results to generate a downloadable bar chart.
4. A third Skill converts the same statistics into an Excel workbook.

The chart and Excel Skills can run in parallel once the initial analysis is complete. This demonstrates how an agent can coordinate several reusable capabilities and produce different results from the same source data.

In a real business scenario, the same principle could be used to analyze support requests. One Skill could categorize the messages, another could prepare a management chart, and a third could create an Excel report for further review.

Why smaller Skills are usually better

It might be tempting to create one large Skill that analyzes data, generates a chart, creates an Excel file, and sends the result. However, smaller Skills are generally more flexible.

If word counting and chart generation are separate capabilities, the agent can create only the table when no chart is required. The chart Skill can also be reused with data from a completely different source.

A useful rule is: one Skill should solve one clearly defined task particularly well. More complex processes can then be assembled by combining several Skills.

How a Skill package is structured

A Skill can be created directly in Copilot Studio or prepared in a development environment and uploaded as a ZIP package. The central file is named SKILL.md. It contains the Skill’s name, description, and instructions.

Optional resources can be added to subfolders, including:

• Python or JavaScript files,
• Shell scripts,
• document templates,
• reference information, and
• sample data used by the Skill.

The description is especially important because it helps the orchestration runtime decide when the Skill should be activated. A vague description can cause the agent to select the wrong capability or overlook the Skill entirely.

Skills, tools, knowledge, and connected agents

The available components have different purposes:

• Knowledge provides information the agent can read and use when answering questions.
• Tools connect the agent to external services, APIs, connectors, or MCP servers.
• Skills provide reusable instructions, logic, scripts, and supporting resources for a particular task.
• Connected agents delegate work to independently created and published specialist agents.

For example, a purchasing agent could use SharePoint as its knowledge source, a connector to retrieve supplier information, a Skill to evaluate quotations, and a connected compliance agent to check purchasing rules.

Testing and evaluating an agent

The new experience provides separate areas for building, previewing, evaluating, and monitoring agents. The Preview area can be used to test individual requests and inspect which Skills the agent activates.

For more systematic testing, questions and expected answers can be prepared as a test set. This helps determine whether the agent behaves consistently before it is made available to users.

Once published, monitoring becomes important. It can show how the agent is used, which tasks it performs, and where further improvements may be required.

Github repository:  My-AI-Examples
Copilot-Releases: What's new in Copilot Studio