5.2 · Creating a simple agent in Copilot Studio

Level 5 · Agents & Copilot Studio

5.2Creating a simple agent in Copilot Studio

Goal: Create a first no-code agent in Copilot Studio from instructions and knowledge.
Estimated time: 25 min · self-paced reading · If you only have 5 min: read “The essentials in 30s” + the diagram.

The essentials in 30 seconds

  • Studio = no-code workshop: you describe the agent in natural language, give it sources, test it — with no coding.
  • 90% of quality: precise instructions (role, tone, scope) + clean, up-to-date knowledge.
  • Test before sharing: the test pane catches failures — a published agent speaks on behalf of the organization.

Running case — Hicham creates his leave agent in Algiers

Hicham, an administrative assistant in Algiers, takes action: in Copilot Studio, he describes in one sentence an agent that answers questions about leave based on the internal guide. He writes precise instructions — clear tone, scope limited to leave, handoff to the HR department outside the scope — then tests it with real questions before showing it to anyone. Sequel to case 5.1 — Hicham moves from the light-bulb moment to the workshop.

Sequel to case 5.1 — Hicham describes, feeds and tests before publishing.

1. Copilot Studio, the no-code workshop

Copilot Studio is the workshop where you create agents with no coding, in natural language. You describe the agent you want, give it sources, test it — all in one interface, without a line of programming. Hicham has never coded: he simply writes what he wants, as he would say it to a colleague.

Creation often starts with a simple conversational description: 'Create an agent that answers questions about leave based on these documents.' Studio suggests a first version, which you then refine.

2. Instructions + knowledge = a useful agent

Two ingredients make a simple agent. The instructions: its role, its tone, what it must and must not do ('You are the department assistant, you only answer about leave, otherwise you hand off to a human'). And the knowledge: the documents or sources it relies on. Hicham locks the scope: his agent only talks about leave.

The golden rule: precise instructions and clean knowledge. A vague agent on messy sources answers badly. 90% of an agent's quality comes down to these two settings.

3. Test before sharing

Studio offers a built-in test pane: you talk to the agent before publishing it. A non-negotiable step — you spot wrong, out-of-scope or badly toned answers, and you fix the instructions accordingly. Hicham asks ten real questions, including out-of-scope traps, and fixes the agent until it properly hands off to the HR department.

Guardrail: never share an untested agent. A published agent speaks on behalf of the organization to dozens of people; a wrong answer spreads at scale. Testing is the minimum safety net.

Common misinterpretation: 'Creating an agent means writing a good description and publishing.' No. The description only gets things started; the useful agent is born from iteration — tightened instructions, curated sources, ten test questions including out-of-scope ones. Publishing the first version without testing means sending an untrained colleague to speak on behalf of the department. The right reflex: describe, feed, test, fix, retest — and only then share.
Creating a simple agent Describe, feed, test, publish Instructions Role,tone, scopeKnowledge Documents,clean sourcesTest Built-in pane,then publish
Describe, feed, test, publish
Text version of the diagram (SEO / screen readers / translation): 1) Instructions: Hicham writes the role of his leave agent in Algiers — clear tone, limited scope, handoff to the HR department when off-topic. 2) Knowledge: he connects the internal leave guide, clean and up to date. 3) Testing: ten real questions in the test pane, fixes, retest — and only then publication. Lesson: 90% of quality comes down to these two settings; testing is non-negotiable.

🔎 Concrete example — Hicham's leave agent in a few minutes

Describe, frame, test: the complete no-code move.

In Copilot Studio:
1. 'Create an agent that answers questions about leave based on [leave-guide.pdf].'
2. Instructions: 'Clear tone, only answer about leave, otherwise hand off to the HR department.'
3. Test 10 questions in the pane, fix, then publish.

Reading: a working no-code agent, with no code written.

Lesson: the 10 test questions stop a wrong answer from going out to the whole team.

Section vocabulary

Copilot Studio
The no-code workshop where you create agents in natural language, with no programming.

Simple example: Hicham describes his leave agent there in one sentence.

What it is not: a programming language reserved for developers.

Reflex: can I describe it as I would to a colleague?

Conversational description
The opening sentence that tells Studio which agent to create and on which sources.

Simple example: Hicham writes: create a leave agent based on the internal guide.

What it is not: a twenty-page technical specification.

Reflex: does my sentence fit on one clear line?

Instructions
The agent's written role, tone and scope: what it does and does not do.

Simple example: Hicham locks it down: leave only, otherwise handoff to the HR department.

What it is not: a vague intention never written down.

Reflex: is the out-of-scope case planned for in writing?

Knowledge
The documents and sources the agent relies on to answer.

Simple example: Hicham connects the up-to-date leave guide.

What it is not: messy or outdated sources.

Reflex: are my sources clean and up to date?

Test pane
The built-in space for talking to the agent before publishing it.

Simple example: Hicham asks ten questions there, including out-of-scope traps.

What it is not: publishing directly with no checking.

Reflex: did I test the out-of-scope case?

In practice — Building and testing a first agent

  1. In Copilot Studio, describe in one sentence the agent you want and give it one or two clean sources.
  2. Write precise instructions: role, tone, scope (what it does and does not do).
  3. Open the test pane and ask 10 realistic questions, including out-of-scope ones.
  4. Fix the instructions based on the failures, retest, then publish only when it is reliable.
A simple, no-code, tested and framed agent — ready to serve a team with no risk of going off the rails.

Ready-to-say script — asking for a testing slot

'I created a first leave agent in Copilot Studio for the department in Algiers: framed instructions, the internal guide as the only source, handoff to the HR department outside the scope. Before sharing it, I am testing it with ten real questions — I will show you the answers on Thursday, and we will only publish if it is reliable.'

To say to your manager to get testing time before any publication.

Copy-paste template — instructions for an answering agent

AGENT INSTRUCTIONS — template to adapt
YOU ARE: the ___ assistant of the ___ department (Algiers).
TONE: clear, courteous, concise.
YOU ANSWER: only about ___ (e.g. leave), based on the documents provided.
YOU DO NOT: ___ (e.g. payroll, disciplinary matters, sensitive individual cases).
OUT OF SCOPE: 'This is beyond my scope: please contact ___'.
UNCERTAINTY: if the source says nothing, say so and hand off to a human.

Solo / small budget

Hicham alone: one agent, one source, ten test questions — the first useful agent fits in one afternoon.

Small business / small team

Instructions reviewed by two: the colleague plays the trap questions while Hicham fixes the agent.

SME in Algiers

Hicham tests in Algiers with five colleagues from the department before opening the agent to other teams.

Team getting started

Pair up: one writes the instructions, the other tests blind and notes every out-of-scope slip.

✓ Best practices

  • Invest in the instructions (role, tone, scope): that is where most of the quality comes from.
  • Give clean, up-to-date knowledge: an agent is never better than its sources.
  • Test out-of-scope questions: a good agent knows how to say 'I am handing off to a human'.

✗ Common pitfalls

  • Publishing an agent without going through the test pane: a wrong answer will go out at scale.
  • Giving vague instructions: the agent answers beside the point or steps out of its role.
  • Feeding the agent messy or outdated sources: garbage in, garbage out.

Key takeaways

  • Copilot Studio creates agents with no coding, in natural language.
  • Two ingredients: precise instructions (role, tone, scope) and clean knowledge.
  • The built-in test pane lets you talk to the agent before publication.
  • Never share an untested agent: a wrong answer spreads at scale.

48h challenge — apply tomorrow

Write your agent's instructions (template above) and test 10 questions including 3 out-of-scope ones: does it hand off cleanly to a human?

Section exit checklist
  • I can describe no-code creation in one sentence.
  • My instructions lock down role, tone and scope.
  • My tested agent hands off to a human when off-topic.
Self-rating 1-5: do my instructions stand up to the traps?did I fix and retest before publishing?

Frequently asked questions

Do you need to know how to code to create an agent?

No: Copilot Studio is no-code. You describe the agent in natural language, give it sources and instructions, test it — with no programming.

How long does a first useful agent take?

A few minutes for a first version, then some iteration on the instructions and testing. Most of the time goes into scoping and checking the answers.

Check your understanding

Which step is non-negotiable before sharing an agent?

Additional resources (optional, to go further)

Level 5 examFresh, harder questions to test what you've learned