Skip to content

Agentic AI

Agent Role Design: How to Give Each AI Agent One Clear Job.

JK
9 min read
TL;DR
  • An agent role is a short written job description: purpose, inputs, outputs, tools, and a "stop and ask" rule.

  • Give each agent one job. Start with one agent, and add more only when you have a reason.

  • Split thinking from doing. Let planning agents run freely. Check anything that changes files, sends messages or spends money.

  • Name a real person for approvals, not "the user".

  • Test each role on real cases before you trust it.

Agent role design means writing down four things for each : what it is for, what it may touch, what it hands on and when it must stop. Do that in your own standard and your team can run the work without you in the room.

Think of hiring. You would never hire someone and say "help out". You give them a job, tools, a boss and limits. An AI agent needs the same.

We build these systems for founders running $1M+ consulting and education businesses. Here is the method, step by step.

What agent role design means

First, what is an agent? OpenAI's guide says an agent has three core parts: a model (the AI brain), tools (apps and functions it can use to act), and instructions (the rules for how it behaves).

A chatbot talks. An agent also acts. TechTarget describes agents as systems that complete tasks and connect to software. That means a badly briefed agent can do more damage than a chatbot.

The role is the job description around those three parts. It answers one question: what is this agent responsible for?

A good role is:

  • Narrow. One clear job, not five.
  • Written down. Not held in your head.
  • Reusable. You can copy it, fix it and hand it to a new team member.

That last point matters most. If the rules live only in your head, you are the bottleneck. If they live on a page, anyone can run them.

Why roles matter more than the tool

Most teams buy a tool first. Then they ask it to "do marketing". It does a bit of everything, and none of it to your standard.

Harvard Business School research makes a related point. HBS argues that companies miss AI's value because they have not reorganised work around it. It says that treating agents like employees helps. That means defined roles, clear boundaries, clear accountability and regular reviews.

That is role design in one line. You are not installing software. You are building a team where some members are AI.

The five-line role spec

You do not need a long document. Dan McCreary, an engineer who writes about supervising agents, suggests five lines per agent. Short enough that it actually gets written.

  1. Purpose. What is this agent for? One sentence.
  2. Inputs. What does it receive, and from where?
  3. Outputs. What does it hand back, and in what shape?
  4. Tools. What may it use? Nothing else.
  5. Stop and ask. When must it pause and call a human?

Here is a worked example for a consulting business.

Role: Client Onboarding Agent

  • Purpose: Prepare a new client's welcome pack in our house style.
  • Inputs: The signed proposal and the intake form.
  • Outputs: A draft welcome email, a kickoff agenda and a task list.
  • Tools: Read access to the proposal folder. Write access to the drafts folder only.
  • Stop and ask: If the proposal has custom terms, or the client's name is missing. Ask the delivery lead.

A new hire could read that in a minute. So can the agent.

Pick the right job for an agent

Not every task suits an agent. Start with work that is repeated, has clear steps and has a clear "done".

Anthropic's 2026 State of AI Agents Report is a survey from late 2025. It found that 60% of respondents rank data analysis and report generation among the most impactful uses. Internal process automation came next at 48%.

For a coaching or education business, good first roles look like this:

  • Turning a call recording into notes and action items.
  • Drafting lesson summaries from your own material.
  • Sorting support questions and answering the routine ones.
  • Checking a client deliverable against your quality checklist.

Poor first roles lean on your gut feel, with no written rules behind them. Those can wait. Write the rules first.

Get your judgment out of your head

This is the hard part, and most guides skip it. An agent can only copy a decision that is written down.

Ask yourself:

  • When a client asks X, what do I say, and why?
  • What do I never allow?
  • What does a good result look like to me?
  • What makes me say "no, redo it"?

Your answers are your intellectual property (IP, the know-how that makes your business yours). Roles built on your IP sound like you. Roles built on generic prompts sound like everyone else.

Where these roles live

We write each role as a plain file that Claude Code reads. A set of roles that share your standards becomes one , a team of AI employees that carry your judgment. Our post on custom AI delivery systems with Claude Code shows how that looks in practice.

Planner or doer: split thinking from acting

Two kinds of role come up again and again.

A planning agent reads, explores and breaks a job into steps. Its output is a plan. A plan is cheap, and you can throw it away.

An execution agent does the work. It edits files, sends drafts and spends money. Its output changes things.

McCreary's point is that these deserve different levels of freedom. Let the planner run loose. Keep the doer inside tight limits, and check what it produces.

Think of a kitchen. The head chef plans the menu. The cook follows the recipe. You do not let a new cook rewrite the recipe mid-service.

Want to see where agents physically run? This piece on AI agent hosting covers the server side, including why risky actions belong in a contained space.

One agent or many?

Start with one. OpenAI's general advice is to get the most from a single agent first. More agents add more places for things to go wrong.

When does a team of agents make sense? OpenAI gives three reasons in its guide for business leaders:

  • You want speed, by running work in parallel.
  • You need deep expertise in one area.
  • You want safeguards, such as extra permissions and checks on sensitive work.

The same guide describes two setups:

SetupHow it worksGood for
ManagerOne manager agent hands jobs to helper agentsWork with one clear owner and a set order
Peer hand-offAgents pass work to each other by specialtyWork that moves between clear specialists

The manager setup is a project lead with a small crew. The peer setup is a relay race. For most founder-led businesses, the manager setup is easier to follow and easier to watch.

The same guide says to define each agent's purpose, its scope (which data, tools and actions it can reach), who owns it and how agents coordinate. That is your five-line spec again, plus an owner.

Hand-offs: what one agent tells the next

When agents pass work along, loose notes cause loops and mistakes. McCreary says every hand-off should state the goal, the inputs and where they are, the limits, how "done" is judged, what has been done and what questions remain.

He also suggests context isolation. Give each agent only the information its role needs. A support agent does not need your pricing spreadsheet. Less to read, fewer wrong turns.

We wrote a deeper guide on this: the six-field hand-off contract.

Set the limits: permissions and stop rules

A role without limits is a risk. Two things set them.

Permissions

Give the least access that gets the job done. Read before write. One folder, not the whole drive. A test space before the live one.

Otio's safety checklists say the same: state the goal, the allowed tools, the expected result, a cost or time cap and a stop condition up front.

If your agent can reach your whole drive, one bad prompt can reach it too. Our plain guide to AI agent permissions goes step by step. For access by job title, see role-based access for AI systems.

Stop rules and human sign-off

OpenAI's guide says to plan for a human to step in when an agent passes a failure limit, such as too many retries. It also says high-risk actions need human oversight until the agent proves reliable. Its examples are cancelling orders, approving large refunds and making payments.

The business leader's guide separates two things. Guardrails are the safety limits on what an agent can do. Instructions steer how it makes decisions. You need both, and more of both as the agent's scope grows.

Here is the bit people forget. Name a real role as the approver. "Delivery lead" works. "The user" does not. If nobody owns the approval, nobody does it.

Our guide on escalation paths covers who steps in and when. The human in the loop prototype shows one way to build it.

Test the role before you trust it

A role is a guess until you test it. Do this before the agent touches real clients.

  1. Write the "done" test. What must the output contain? What must it never contain?
  2. Build a small test set. Use 10 to 20 real past cases, including ugly ones.
  3. Run each case more than once. AI answers can change from run to run, so one good result proves little.
  4. Check the stop rule. Feed it a case that should make it stop. Does it stop?
  5. Score the results. Count passes, fails and near misses. Fix the role, not just the prompt.
  6. Keep the test set. Re-run it whenever you change the role.

OpenAI's guide also advises setting up evals (repeatable tests) to set a performance baseline when you choose a model. Your test set is exactly that.

We have a longer list in our AI agent testing guide.

Common mistakes in role design

  • The all-rounder. One agent for "marketing". Split it by job.
  • No stop rule. The agent guesses when it should ask.
  • Too much access. It can reach files it never needs.
  • Vague approvals. Nobody knows who signs off.
  • No owner. Nobody reviews the agent after launch.
  • Generic rules. The agent does what any agent would do, not what you would do.

The last one costs the most. Your edge is how you decide. Write that down.

How we work on this

We build roles like these inside the AI Orchestrator OS. It is an always-on AI operating system made from your own method. Each role is an AI employee with a job, tools and limits, built with Claude Code. Your coaches and consultants share it.

The AI Orchestrator OS is $30,000, or 3 x $11,000. It includes 6 weeks of 1 on 1 setup. Want us to build it for you? Done for you is by quote.

If you want to build on your own, Platform Access is $90 a month. It is free for 12 months with the OS.

For the bigger picture, read how to build your first agent system in 90 days. If Claude Code is new to you, start with Claude Code for non-technical founders.

Our view on role design

Most founders ask which tool to buy. We think that is the wrong first question.

The better question is: what do you know that your team does not? Your judgment is the product. Tools only carry it.

So we start with your thinking. We pull your rules, your standards and your "no, redo it" moments onto a page. Then we turn each one into a role.

This is why we build a network of agents instead of a single automation. One automation fixes one task. A network can copy how you decide across content, delivery and support.

The result we aim for is simple. Your team delivers to your standard, and you step back from the daily calls.

James Killick

Your next step

Pick one repeated task you do each week. Write its five-line role today. Then, if you want a working system built around your IP, book a call.

Sources

FAQ

Frequently asked questions.

JK

James Killick

Founder

The AI Orchestrator. 10+ years building digital products and 200+ apps shipped, now helping $1M+ educators and consultants turn their IP into AI-powered delivery systems.

James Killick founded and runs The AI Orchestrators.

Ready to find out where your biggest AI opportunity is?

Take the assessment. It takes about 5 minutes. You'll get a clear picture of how ready your business is.