How to set up your first AI agent

You already know a normal AI chat: you ask a question, it answers, and the conversation ends. An AI agent goes one step further. You set it up once with a job to do, and from then on it can take in information, decide what to do, use tools, and produce a result — with much less hand-holding each time.

Every agent, however simple, is really just four parts working together:

• A brain — the AI model that reads, reasons and writes (for example ChatGPT, Claude or Gemini).
• Instructions — a short brief telling it who it is, what job to do, and the rules to follow.
• Knowledge — the reference material it should rely on (your documents, notes, a price list, an FAQ).
• Tools — the actions it is allowed to take (search the web, read a file, draft an email, call another app).

Get those four right and you have an agent. The rest of this guide is simply how to fill each one in, in order.

Before you open any tool, finish this sentence on paper: "My agent takes ___ and turns it into ___." If you cannot fill both blanks, the agent will wander. Good first jobs are narrow, repeatable, and low-risk if the agent gets it slightly wrong.

Notice what these have in common: a clear input, a clear output, and a human who checks the result. Keep those three and your first build will almost certainly work.

You do not need much. Gather these before you build so you are not hunting for things halfway through.

• An account on one AI tool. A paid plan on ChatGPT, Claude or Gemini unlocks the agent builders. Start with whichever you already use.
• The job, written down. Your "takes ___ and turns it into ___" sentence from Step 1.
• Two or three real examples. Actual inputs the agent will face — a real set of meeting notes, a few genuine customer questions.
• Any reference material. The FAQ, price list, style guide or notes the agent should rely on, as files or text you can paste.
• A definition of "good". One or two sentences on what a successful result looks like, so you can tell whether it worked.

You do not need special software. The three big AI tools each have a built-in, no-code way to save a custom assistant. They work in the same way, so pick the one you already have.

• Custom GPT (in ChatGPT) — look for Explore GPTs then Create, or My GPTs. Good all-rounder with knowledge files and optional actions.
• Project (in Claude) — a Project holds custom instructions plus your reference files, so every chat inside it already knows the job. Claude can also connect to tools through its connectors.
• Gem (in Gemini) — open the Gems manager and New Gem to save a custom assistant with its own instructions.

Want more than a single-task assistant — something that runs on a schedule or chains several apps together? That is the world of no-code agent platforms and workflow automation (tools such as Zapier, Make or n8n, many of which now have AI-agent steps). Start with a custom assistant first; move to those once you know exactly what you want automated. We come back to this in Where to go next.

Whichever builder you chose, you will do roughly the same six things. Take them in order.

1. Open the builder and start a new assistant Find Create, New Project or New Gem. You will get a blank assistant to configure.
2. Give it a name and a one-line description Name it after its job, for example Meeting Notes Tidier. The description is just for you to find it later.
3. Write its instructions This is the most important box — the standing brief the agent follows every time. We give you a ready-made template in Step 5. Paste it in and fill the blanks.
4. Add its knowledge Upload the files or paste the reference text it should rely on. Keep it to what the job actually needs; more is not better. See Step 6.
5. Turn on only the tools it needs Switch on web search, file reading or a connector only if the job requires it. Leave everything else off. See Step 6.
6. Keep it private and save Set sharing to only me for now. Save. You have built an agent — the next steps make it good.

A vague brief gives a vague agent. A good one covers six things: who it is, what it does, how it works step by step, the rules, the output format, and what to do when unsure. Copy this template into your instructions box and fill in the blanks.

You are [name], a [role] that helps [who] to [the job].

YOUR TASK
When I give you [the input], you produce [the output].

HOW TO WORK
1. [First thing you always do]
2. [Second thing]
3. [Final check before you answer]

RULES
- Use only the information I give you or that is in your knowledge files.
- If something is missing or unclear, ask me — do not guess.
- [Any rule of your own, e.g. "Always use British English".]

OUTPUT
Reply in this format:
[Describe the layout you want — headings, bullet points, length.]

WHEN UNSURE
Say what is missing and ask one clear question, rather than inventing an answer.

Two lines do most of the work here: "Use only the information I give you" keeps the agent from making things up, and "If something is unclear, ask — do not guess" turns silent mistakes into a quick question. Keep both.

Knowledge is the reference material the agent leans on. Upload the FAQ, the style guide, the price list — the documents that contain the "right answer" for its job. Then, in the instructions, tell it to rely on them (Use only the information in your knowledge files). Fewer, cleaner files beat a big pile of everything.

Tools (sometimes called actions, connectors or skills) are the things the agent is allowed to do beyond talking — search the web, read a spreadsheet, look something up in another app. Switch on only the ones the job needs.

Two habits keep tool use safe from day one:

• Least access. Give the agent the narrowest permission that still lets it do the job. It does not need your whole inbox to draft one reply.
• Human approval for anything that acts. Reading is low-risk. Sending, paying, posting or deleting is not — keep those behind your own click.

Nobody's first version is right. Improving an agent is a short loop you repeat until you trust it. Use the real examples you gathered in Step 2.

1. Run five real examples Feed in genuine inputs, not tidy made-up ones. You want to see how it behaves on the messy cases you will actually face.
2. Read the output like a sceptic Is anything invented, missing or wrong? Did it follow the format? Watch especially for confident answers that are not backed by your knowledge files.
3. Fix the instructions, not just the chat When it slips, add a line to the instructions so it never slips that way again — a new rule, or a short example of a good answer.
4. Try to break it Give it a strange, empty or out-of-scope input. A good agent asks a question or says it cannot help, rather than bluffing.
5. Repeat until boring When five real inputs in a row come back right, it is ready for real use. "Boring and correct" is the goal.

An agent you can trust is one with sensible limits. Put these in place and you can hand it real work without worrying.

• Keep a human in the loop. The agent drafts and suggests; a person approves anything that leaves the building.
• Start read-only. Let it look and draft for a week before you let it act on anything by itself.
• Know its limits. Write down what it must not do, and put those in the instructions.
• Check in regularly. Skim its outputs now and then. Tools and your own needs change; the agent should keep up.
• Mind the data. Keep confidential and personal information out of it unless you are cleared to share it.

Once your first agent is doing useful work, there are three natural directions to grow — take them one at a time.

Let it run on its own schedule

Move from "I open it when I need it" to "it runs every morning". No-code automation platforms (Zapier, Make, n8n and similar) can trigger an agent on a schedule or when something happens — a new email, a new form response — and pass the result on to another app.

Connect more tools

Give the agent safe, read-first access to the apps where your work lives — your calendar, a spreadsheet, a knowledge base. Add one connection at a time and test after each, keeping the least-access and human-approval habits from Step 6.

Grow into code when you outgrow no-code

If you hit the limits of the built-in builders, the AI providers offer developer tools — agent and assistant APIs, and a shared standard called MCP (the Model Context Protocol) for connecting tools — that let you build exactly what you want. That is a job for a developer, and a sign your idea has proven its worth.