If you tell your AI "go through my inbox and draft replies," that's a task. An agent is when you give it a goal: "own my client communication, keep my inbox moving, and flag anything that needs me." You hand it the job and it works out the steps.
If you came from the video, that's the idea. Here's the part that doesn't fit in sixty seconds: the exact brief I'd paste in, one real agent wired up end to end, and the things that broke the first time so they don't break for you.
The four pieces it needs
An agent that actually works has four parts. Miss one and it either guesses, forgets, or sits there doing nothing.
Context
What your business does, who your clients are, what you charge, and how you sound in writing. Without it the agent invents a version of you. Don't sum it up in one line; give it the same brief you'd give a new hire on day one.
Memory
The model forgets everything between runs. Give it one place to write things down (a doc, a table, a notes field), and tell it to read that before it acts and update it after. This is the step most people skip, and it's why their agent repeats itself or contradicts what a client already agreed to.
Tools
The model is the brain; tools are the hands. Connect your email, calendar, and files so it can read a thread, check your availability, and draft a reply. If it can't touch your real accounts, it can only talk about doing the work. My MCP connectors guide covers the ones I'd hook up first.
A trigger
What starts it, and how often. Every weekday at 9am, or whenever you forward it a thread. Run it only as often as you need. Leaving an agent running all day when you need it once is how the bill gets away from you.
A real one, wired up
Abstract advice is easy to nod along to and hard to act on, so here's the client-communication agent from the top of this page with each piece actually filled in:
- Context is the real brief: "We're a boutique branding studio. Clients are early-stage founders. Projects run six to eight weeks. Here's the rate card. I write warm, short, and direct, and I never overpromise a timeline."
- Memory is one client table: name, what they've agreed to, what's still open, next step. It reads the row before replying and writes back after anything changes.
- Tools are Gmail (read and draft), Calendar (check before offering a time), and that client table (read and write).
- Trigger is weekday mornings, plus any thread I forward it during the day.
Filled in like that, "own my client communication" stops being a slogan and becomes something the agent can run.
The brief I'd paste in
This is the template I start from. Fill in the brackets, drop it into an assistant that has your tools connected, and you've set all four pieces plus the guardrails in one go.
You are my [role, e.g. client-communication assistant].
Your goal: [the responsibility, not a single task].
My business:
- What we do: [ ]
- Who my clients are: [ ]
- What I charge and my terms: [ ]
- How I sound in writing: [ ]
Memory:
- Before you act, read [where notes live].
- After anything changes, write it back there: what was agreed, dates, amounts, next step.
Tools you can use:
- Read: [email, calendar, files, CRM]
- Draft or prepare: [replies, summaries, agendas]
- Never do without my sign-off: [send, quote a price, book, spend]
When to run:
- [e.g. every weekday at 9am, and when I forward you a thread]
How to report back:
- A short list: what you handled, what is waiting on me, and anything you were unsure about.
- If a record is missing or conflicting, flag it instead of guessing.Guardrails go in the app, not the prompt
Asking nicely in a prompt is not a guardrail. A prompt can be forgotten or talked around; a permission setting can't. Drafting is safe to automate. Sending, quoting a price, booking, or spending money should be off by default in the tool's own permission controls, so the agent has to hand those decisions back to you. Run it once while you watch, fix what it gets wrong, then put it on the schedule. Here's the check I run before I let one go on its own:
[ ] I gave it real context, not a one-line description
[ ] It has a place to store memory, and I told it to check it first
[ ] Tools are connected and I confirmed it can read what it needs
[ ] Send / pay / commit actions are OFF in the app's permissions, not just the prompt
[ ] I watched one full run and corrected what it got wrong
[ ] The trigger runs as often as I need and no more
[ ] It reports back somewhere I actually lookWhat goes wrong the first time
Every one of these has happened to me, and each has the same small fix.
It makes something up about a client. That's a memory problem, not a smarts problem. It had nothing to read, so it filled the gap. Give it the notes, and tell it to say "I don't have that" when it doesn't.
It does the same thing twice, or acts on a thread you already handled. It isn't recording what it did. Have it write "done" back to memory after each action and check for that before acting again.
The bill is higher than you expected. It's running too often, or re-reading everything each time. Tighten the trigger and point it at what changed since the last run, not your whole inbox.
It sent something it shouldn't have. The block was in the prompt instead of the permissions. Move it into the app's controls so the send simply isn't available to it.
What to build it with
You don't need to code. If you're starting out, use an assistant that already connects to your email, calendar, and files, and build the whole thing in plain language with the brief above. If you want more control, or you're wiring in your own data, that's when connectors like the ones in my MCP guide earn their place. Either way, start with one job you already understand, like the invoice check in this walkthrough, and expand once you trust it.
A task is one instruction you have to repeat. A goal is a responsibility the agent manages, choosing its own steps and tools based on what it finds, inside the guardrails you set. Get the four pieces right and you're handing over the goal, not babysitting the task.