Field Notes #006 — I’ve shown you what my AI setup does. This one is about how it actually thinks — and why most people are running it at a fraction of what it can do. — Dakota

For about a year, I used AI like a vending machine.

Type a request. Get an answer. Type the next request. Get the next answer. Close the tab. It was useful — but every single thing it did, I had to ask for, one step at a time. I was standing at the machine feeding it quarters all day.

I thought I was good at AI. I was just a really fast button-pusher.

Babysitting vs. delegating

Here’s the thing that finally cracked it open for me.

The difference between a chatbot and an agent is the difference between babysitting and delegating.

Say I tell you: “Book me a flight to Denver next Thursday.” That’s delegating. You go figure out the airline, the times, the price, the seat, and you come back with it done. I gave you the goal. You handled the steps.

Now say I tell you: “Open this tab. Type Denver. Click the third result. Pick the 9am. Now enter my card number.” That’s babysitting. I did all the thinking. You were just my hands.

Most people are babysitting their AI. I was too. I’d open a chat and walk it through every step like it couldn’t be trusted to figure anything out — because that’s how a chatbot works. It waits for you. It does the one thing. It stops.

An agent doesn’t wait. You hand it a goal and it works out the steps itself.

That’s the whole shift. And once I saw it, I couldn’t unsee it.

An agent is only four things

This is the part nobody puts in the headline, because “build an AI agent” sounds like something you need a computer science degree for. You don’t. I don’t have one. I still can’t really code.

An agent (just a word for an AI you’ve handed a job instead of a task) is made of four pieces. That’s it. Once you can name the four pieces, you can build one.

1. A role. Not “an AI that does stuff.” One specific job. You’re my research assistant. You’re my first-draft writer. You’re the person who reads my inbox every morning and tells me what actually matters. The narrower the role, the better it performs. A guy who does one thing all day beats a guy who does everything badly.

2. Instructions. This is how it does the job — your process, written down. Not “research this topic,” but: find five solid sources, summarize each in three sentences, flag anywhere they contradict each other, and end with three things I should actually do about it. Instructions are the difference between a new hire who guesses and one who already knows how you like it.

3. Tools. What can it actually touch? Can it search the web? Read your files? See your calendar? Send an email? The tools decide whether your agent can only talk about work or can actually do it. An assistant who can’t pick up the phone or open a document isn’t much of an assistant.

4. Memory. Does it remember what it did yesterday? Does it know your preferences without you re-explaining them every time? Memory is the line between a one-time tool and something that actually gets to know how you work.

Role. Instructions. Tools. Memory. Write those four things down and you have an agent. I’m not simplifying it for the blog — that genuinely is the whole anatomy.

You don’t build this by coding. You build it in Cowork.

I assumed building one of these meant writing software. It doesn’t. The easiest place to start is Cowork — a mode in the Claude desktop app where the AI can actually work with your files and folders instead of just talking in a chat box. No code. Nothing to install your way through.

(I’ll be straight with you: I mostly live in the terminal version of this, because I’m in deep at this point. But if you’ve never built an agent, don’t start there. Start in Cowork. It’s the front door, and it’s wide open.)

Here’s the entire process, and it’s almost dumb how simple it is:

Open Claude. Click the Cowork tab. Start a new session.
Tell it the role: “You’re my research assistant.”
Paste in the instructions — the how, the quality bar, and the format you want your answer back in.
Give it access to a folder on your computer so it has somewhere to save its work. (If you’ve connected things like Gmail or Drive, it can pull from those too.)
Hand it a real task and watch it go. It plans the steps, does the work, and drops a finished file in your folder.
The first result will be 80% right. Tell it what’s off — “too long, keep each section under 100 words,” “add a one-line summary up top.” It adjusts. Now it’s tuned to you.

That’s it. That’s building an agent. If you can write a clear set of instructions for a new hire, you can do this. The skill isn’t Python. It’s clarity.

One agent is a tool. A team is a different thing.

This is where it stopped being a party trick for me.

One agent saves you time on one task. A team of agents runs a whole process — because the output of one becomes the input of the next. They hand off to each other.

Simplest example: turning a raw idea into a finished piece of writing.

Agent one researches the topic and hands back a brief.
Agent two reads that brief and turns it into an outline.
Agent three writes the full draft from the outline.
Agent four edits the draft to something you’d actually publish.

Four roles. Each does its single job well and passes the baton. You go from “topic” to “done” without writing any of it yourself — you’re just the editor-in-chief making the call at the end.

Two things take a team like that from neat to genuinely yours:

A shared context file. One short note — who your audience is, your tone, the words you never want used — that every agent reads before it starts. Write it once, and the whole team sounds like you instead of like a robot.
A schedule. In Cowork you can set an agent to run on a timer. Every Monday at 7am, go pull what’s trending in my world and hand me three outlines. You wake up to work already in motion.

And it’s not just writing. Any time your business has a thing that goes “every time X happens, I do steps 1 through 12” — that’s a team of agents waiting to exist. A message comes in → one agent reads it → one drafts a reply → one checks it against your rules → one files it. The work that used to eat your morning becomes something you review with a coffee.

The hard part was never the AI

I’ll tell you the real bottleneck, because it surprised me.

It’s not the AI. The AI is shockingly good now. It’s not the tools, and it’s definitely not your ability to code.

The hard part is that almost nobody has ever written down how their own work actually gets done. We carry it around in our heads. Step one, then this, then if that happens do this other thing — it all lives as instinct. And you can’t hand instinct to an agent.

The reason most operators don’t have a team of agents is the same reason most don’t have a real CRM set up: nobody ever sat down for one afternoon and wrote out how the business actually runs. Once you do that — once it’s on paper in plain English — building the agent is the easy part.

So the work isn’t learning AI. The work is finally being honest about your own process.

What I’d do if I were starting today

Pick the one task that eats the most of your week. Just one.

Open Cowork. Write down, like you’re training someone on their first day: here’s your job, here’s exactly how I want it done, here’s the folder you can use, here’s what to remember about me. Hand it over. Run it. It’ll be 80% right and 20% off — that’s normal. Tell it what to fix. Run it again. Now it’s yours.

Do that for one task this week. Not a team. One agent. Get the rep.

For a year I thought I was using AI. I was just doing all the thinking and letting it type. The day I started writing down the job instead of the task is the day it actually went to work for me.

Not a smarter tool. A team.

If you’ve built one of these — or you’re trying to and you hit the wall I described — I’d genuinely like to hear where you got stuck. Come find me on @xovionai.