All Episodes

May 20, 2025 12 mins

Create fine-tuned, task-specific models that write like you by teaching models using expert knowledge, tone, and structure - with reference information directly attached to the models themselves using Microsoft 365 Copilot Tuning.

Fine-tuning adds new skills to foundational models, simulating experience in the tasks you teach the model to do. This complements Retrieval Augmented Generation, which in real-time uses search to find related information, then add that to your prompts for context.

Fine-tuning helps ensure that responses meet your quality expectations for specific repeatable tasks, without needing to be prompting expert. It's great for drafting complex legal agreements, writing technical documentation, authoring medical papers, and more - using detailed, often lengthy precedent files along with what you teach the model.

Using Copilot Studio, anyone can create and deploy these fine-tuned models to use with agents without data science or coding expertise. There, you can teach models using data labeling, ground them in your organization’s content - while keeping the information in-place and maintaining data security and access policies. The information contained in the task-specific models that you create stay private to your team and organization. Task-specific models and related information are only accessible to the people and departments you specify - and information is not merged into shared large language models or used for model training.

Jeremy Chapman, Director on the Microsoft 365 product team, shows how this simple, zero-code approach helps the agents you build write and reason like your experts—delivering high-quality, detailed responses.

 ► QUICK LINKS:

00:00 - Fine-tune Copilot

01:21 - Tailor Copilot for specialized tasks

05:12 - How it works

05:57 - Create a task-specific model

07:43 - Data labeling

08:59 - Build agents that

Mark as Played
Transcript

Episode Transcript

Available transcripts are automatically generated. Complete accuracy is not guaranteed.
(00:03):
You can now teach or fine-tune
your Microsoft 365 Copilot experience
by creating your owntask-specific fine-tune models
that channel your expertise and experience
to carry out specialized jobs and tasks
accurately and on your behalf.
In fact, from Copilot Studio,
anyone can use this zero-code approach

(00:25):
to teaching Copilot's underlying model
the skills from your organization
to produce more usable,high-quality responses
that can be as detailedas they need to be,
even hundreds of pageslong to get the job done.
And the model remainsexclusive to your organization
and only the people anddepartments you specify.

(00:46):
If you compare this to the traditional way
of doing this until now,
this level of customizationwould require data science,
machine learning, and coding skills.
So this process is a lot simpler.
And unlike existing approacheswhere, as a data scientist,
you may be copying data into locations
that may not be aware of your protections
and access controls, this isenterprise-grade by design.

(01:11):
You just focus on the outcomethat you want to achieve.
And because your data stays in place,
your existing data accessand protection policies
are respected by default.
Let me show you thepower of this in action
by comparing the results of an agent
that's calling a fine-tuned,task-specific model of Copilot
versus one that's justcalling the original

(01:31):
underlying Copilot model.
So both agents are configured
to author loan agreement documents.
On the left is our agentusing the task-specific model,
on the right is our SharePoint-based agent
using a general model.
Now, both agents are focused
on the same exact underlying knowledge.

(01:52):
It's all in a SharePoint location,
as you can see here withthis precedent file set.
And both user prompts are identical
with example reference files
and the client term sheetscontaining new information.
In fact, this is a precedentfile that I'll use.
It's a long and detailed document
with 14 pages and more than 5,000 words.

(02:15):
The term sheet is quite a bitshorter as you can see here,
but it's still long anddetailed with information
about the loan amounts, all the details,
and if I scroll all theway down to the bottom,
you'll see signatoryinformation for both parties.
So let's go back to ourside-by-side view and run them.
So, I'll start with the generalmodel agent on the right.

(02:39):
And it starts to generate its response.
And I'll let this one respond for a moment
until it completes.
There we go.
And now I'll move overto the agent on the left.
It immediately informs methat it'll receive an email
once it's finished.
Now, this is going to bea longer-form document,
so we'll fast forward in time

(03:01):
to see each completed response.
So, starting with the general model,
I've copied it into a Word document,
and the output is solid.
You'll see that the twoparties are correct,
the loan structure,
all the amounts are alsocorrect from the term sheet,
but it has a few tells.
It's missing a lot ofspecificity and nuance

(03:24):
that a member of our legal team
would typically includein all of the terms.
It's also very summarized
and not how our firm woulddraft an agreement like this.
When I scroll down to the bottom,
the signatories and addressesare captured correctly
and match the term sheet.
That said, though, it'sjust four pages long

(03:45):
and has around 800 words,
versus more than 5,000 wordsin our precedent document.
So it kind of follows the 80-20 rule
where a good portion of the response
could maybe work with some edits,
but it's not reflecting how myfirm thinks and how it writes
when authoring legaldocuments like this one.

(04:07):
So let's go ahead and look at the results
of a fine-tuned, task-specific agent.
So immediately, you can seethis document is verbose.
It's 14 pages long withmore than 5,300 words.
The word count doesn'talways equate to quality,
so let's look at the document itself.
Now, as I scroll down,you'll see that this agent

(04:28):
has been taught our firm-specific patterns
and the clauses that weuse in existing case files.
It is structured and worded things
just like the precedent document.
It's reasoning and writingwith more precision,
like an experiencedmember of our firm would.
And while as with any otherAI-generated document,

(04:49):
I still need to check it for accuracy,
it really captures thatextra detail and polish
to save us time and effort.
So model fine-tuning is a powerful way
to tailor state-of-the-artlarge language models
that are used behind Copilotto your specific needs.
And as you saw, it alsocan significantly improve

(05:09):
the handling of specialized tasks.
So let me explain howfine-tuning works in this case.
Unlike Retrieval Augmented Generation,
it doesn't rely on searchand orchestration processes
that run external to thelarge language model.
The additional knowledge
added as part of the fine-tuning process
is a protected container of information

(05:30):
that attaches the largelanguage models training set
to teach it effectively a new skill.
Now, it's never merged into the LLM
or used for future model training,
and is temporarily attachedto the LLM when it's needed.
Again, the skill andknowledge that it contains
is exclusive to you andthe people or groups

(05:52):
that you've shared it with,
so it can't be accessedwithout the right permissions.
Next, let me show youwhat it takes to create
and fine-tune your owntask-specific model.
I'm in Microsoft Copilot Studio,
which you can reach from your browser
by navigating tocopilotstudio.microsoft.com.
I'm on the task-specific model page

(06:14):
and I want to customize a model
to generate partner agreements.
So I'll paste in a corresponding name.
Then I'll paste in a description.
Then as the task type,
I'll select a customization recipe
that reflects what I want it to do.
And my options here include expert Q&A,

(06:35):
document generation, anddocument summarization,
with more task types coming over time.
From there, I can provideadditional instructions
to tailor the fine-tuning recipe,
like how the model shoulduse original files,
for example, to inform the structure,
formatting, company-specific clauses,
and other areas important toyour model, like we saw before.

(06:58):
Next, I can define myown knowledge sources.
Now, these can use information
from SharePoint sites and folders,
and soon, you'll beable to add information
external to Microsoft 365 usingMicrosoft Graph connectors.
In this case, I'll definea SharePoint source.
Then browse the sitesthat I have access to.

(07:19):
I'll choose this folderinside the Agreements library.
And from there, I can evendrill into specific folders
for the precise information
that I want to use to teach the model,
which I'll do here withthe Agreements folder.
For permissions, this process aligns
to the enterprise-grade controls
that you already have in your organization

(07:40):
backed by your Microsoft Entra account.
Now, the next step is to process the data
you selected for training orwhat's known as data labeling.
So here, you'll be presentedwith data labeling tasks
in small, iterative batches.
They're kind of likequestionnaires for you to complete,
where the fine-tuning processwill generate documents

(08:01):
and request assessmentof them for clarity,
completeness, accuracy,and professionalism.
This process requiressubject matter expertise
to open these documentsand rate the quality
of the generative output for each.
I'm just going to show one question here,
but you'd repeat thisprocess for every batch.

(08:24):
And once all batches are labeled,
I can start model training.
Now, this will take some time to process,
so I'll fast forward a little in time.
Now with everything finished,
I can publish the model tomy Microsoft 365 tenant.
And it will be available toanyone we've shared it with,
like our audit team frombefore, to build new agents.

(08:46):
And the process I just showedis called supervised learning,
where the model is trained on label data.
And soon, you'll also have the option
to use reinforcement learning
to enhance the agent'sreasoning capabilities.
Now let me show you how tobuild an agent from Copilot Chat
that can leverage ournew task-specific model
for partner agreement generation.

(09:08):
So I'm going to select Create agent.
And for the purpose, Ihave a new option here
to build a task-specific agent.
Next, I can choose from theexisting task-specific models.
So I'm going to choose theone that we just created
for new partner agreements.
There we go.
And with any agent, I justneed to give it a name.

(09:30):
Now I'll paste in a description
for people on the team to know its purpose
and what it can do.
And next, I can specifyadditional instructions
as guidelines to providemore context to the agent,
as I'm doing here toensure the structure aligns
with our organizational standards.
Because this is a very specific agent
to write partner agreements,

(09:50):
I'll just specify onestarter prompt with details
for referencing a precedentsource document to start with
and a term sheet to getspecific new information from,
kind of like we saw before.
Now, the preview on the right looks good,
and I can create theagent right from here.
For sharing, permissionsalso need to align

(10:12):
with whoever my task-specificmodel was shared with,
which, as you'll remember,again, was our audit team.
In this case, for my own validation,
I'll select only you so that I can test it
before sharing it out withother auditors on my team.
So let's go ahead and test it out.
So I'm going to use the starter prompt.

(10:32):
Then I'll replace thevariable file names here.
I'll use the forward slash reference,
starting with the precedent file.
Now I'll look for the termsheet file. There it is.
From there I can submit my prompt.
This is going to take amoment for the response.
You can see the structure
with sections based onour task-specific files
used with the fine-tuning.

(10:53):
It tells me that it'llsend me a Word document
and email once it's finished again.
In fact, if I fastforward in time a little,
I'll move over to Outlook.
And this is the file the agent sent me
with links to the new agreement draft.
So I'll open it using Word in the browser.
There's my agreement.
And you'll see it follows exactly

(11:14):
how we wrote the precedent agreement.
As I scroll through the document,
I can see all the structure and phrasing
aligned with how we writethese types of agreements.
In fact, this Representationsand Warranties section
is word for word directfrom our standard terms
that our firm always incorporates.
And that's it. My agent is now backed

(11:35):
with my task-specific,fine-tuned knowledge,
and it's ready to go and I'mready to share it with my team.
So those are just a few examples
of how fine-tuning inMicrosoft 365 Copilot
can give you on-demand expertise,
and task-specific modelsrespond more accurately
using your specified voice and process

(11:55):
so that you and yourteam can get more done.
To find out more, check outaka.ms/FineTuningCopilot,
and keep watching Microsoft Mechanics
for the latest tech updates,
subscribe to our channel,
and thanks for watching.
Advertise With Us

Popular Podcasts

Stuff You Should Know
Dateline NBC

Dateline NBC

Current and classic episodes, featuring compelling true-crime mysteries, powerful documentaries and in-depth investigations. Follow now to get the latest episodes of Dateline NBC completely free, or subscribe to Dateline Premium for ad-free listening and exclusive bonus content: DatelinePremium.com

24/7 News: The Latest

24/7 News: The Latest

The latest news in 4 minutes updated every hour, every day.

Music, radio and podcasts, all free. Listen online or download the iHeart App.

Connect

© 2025 iHeartMedia, Inc.