A real AI agent built end to end inside Claude Cowork, using a real viewer's job as the working example: reviewing behavior data, drafting improvement plans, and writing a weekly report. The exact file that makes an agent work, a three-phase workflow design process, and how to schedule it to run on its own.
A plan sitting in a chat window disappears the moment the conversation ends. The difference between chatting with Claude and running a real agent is whether that plan survives as a file Claude can read and run again without being re-explained.
You open Claude, paste in a task and hit enter. Claude gives you something back, and it's surface-level, generic, not quite what you wanted. You clean it up yourself. And now you're spending more time correcting AI than AI is doing the work for you.
Here's what's happening: instead of taking the opportunity to actually use an AI agent, you're just having a conversation with AI. That's a real missed opportunity too many people are making.
This video shows what a real AI agent actually is, why it's different from chat, and how to build one inside Claude with no code or developer skills needed. Just Claude Cowork and a folder on your computer.
Credit where it's due first. A viewer named Anthony left a comment describing exactly this kind of work: behavior data, improvement plans, team meetings, all of it. He wasn't the only one asking for a real walkthrough, not just theory. This video is built directly around his situation, but it applies just as well to anyone doing similar work.
If you've tried using Claude for something you do regularly at work, a report, an email, a summary, you've probably noticed that sometimes it comes out exactly right, and sometimes it doesn't. That isn't you doing something wrong. It's a structural problem: you're often asking Claude to guess what you want, and that too often creates poor output.
Recent workplace research from McKinsey and Slack found that people actually running agents in their work are getting back about six and a half hours a week. That's what's happening for people who've moved past chat. For everyone else, it's not that AI doesn't work for them, they're just one level below where the payoff starts.
A first version of this can be as simple as a rough text file telling Claude who you are and what you need. It works immediately, and it keeps evolving: every significant change or addition to your work becomes part of it. That file is called a CLAUDE.md file, and it makes a real difference.
Most people use Claude at Level One: basic chat. You ask a question, Claude answers. Useful, but the most limited way to work with AI. Level Two is builder mode: you stop asking questions and start asking Claude to make things, writing, drafting, analyzing. Real output, but you're still managing every step yourself.
Level Three is where a real agent lives. You hand Claude a goal, a complete outcome, and it figures out how to get there. It thinks through the task, breaks it into phases, asks questions if something is unclear, executes each phase in sequence, then delivers the finished result. You're not in the loop for every decision. You set the destination, hand over the wheel, and the agent drives. You only step back if it hits a fork in the road it can't call on its own.
Claude Cowork already has what's needed built in. It just needs a folder on your computer where it can save files, read your documents, and keep everything organized. What used to require a team of developers, you can now do yourself on your desktop, and the single most important file in that workspace is the CLAUDE.md file: a simple, powerful text file Claude reads automatically every time it starts working for you.
At minimum, that file covers project context (what the workspace is for), about you (who you are, who your audience is, what tone you want), rules (the preferences you're tired of repeating), and folder structure (where instructions live, where finished work goes, where reference material sits). The fastest way to build it yourself is to open Claude and say, "Help me make my own CLAUDE.md file. Start by asking me questions." It will interview you and build it right there.
It matters to design this before touching any real data, because if you skip straight to a task, Claude has to guess the structure every single time, and guessing is exactly what creates generic output. To get an agent that actually holds up, you need one instruction that lays out every phase up front.
The actual instruction given to Claude: design a workflow with three phases. Find the patterns in the incident notes. Draft a consistent improvement plan for anyone flagged. Then turn the team's meeting notes into a weekly report. And weight patterns by severity, not just how often they happen, because one serious incident matters more than five minor ones.
Three phases, one instruction, in plain English. Claude didn't jump straight to a plan either. It asked four quick questions first, forcing more specific answers instead of vague ones: exact severity level, exact number of stages, exact pattern window, what to name the file. A few short answers, and the workflow now runs on actual numbers instead of words like "serious" or "frequent." It also found sample files already sitting in the resources folder and used the real data structure to ground the plan, before being told to run anything.
Claude then came back with a plan built around those specific rules: a pattern and severity review, a staged improvement plan for anyone flagged, and a weekly report pulling from both the review and the meeting notes. But a plan sitting in a chat window doesn't do anything by itself. It's just a good idea that disappears the moment the conversation closes. For this to actually work as an agent, it has to survive after the chat ends.
To make this reusable, that plan needs to become an actual file, one Claude can read on its own without anything being repeated. Once the structure looks right, Claude writes the actual workflow file and names it something like behavior-review-agent.md inside the workflows folder.
Opening that file shows the operating instructions for the agent, written in plain language, fully editable, reusable every time a new set of data comes in. But a saved file sitting untouched doesn't prove anything either. It only means something the moment it actually has to carry real work on its own.
This is the part that actually proves whether any of this was worth building. To find out if a saved workflow can carry itself, it needs real data and a complete step back. Since the workflow already has the rules locked in from those four answers, nothing needs to be explained again. Just: run the behavior-review-agent workflow, and point it to the incident log and the meeting notes.
No more questions this time, because the workflow already knows the rules. It goes straight to work. Here's what came back: seven students flagged, each sorted into the right tier automatically, one escalated, most at an early check-in, and one flagged for awareness only instead of treated as an ongoing problem, exactly the judgment call that was wanted.
But running it once by hand only proves it works today. It doesn't say whether you'll actually keep using it a month from now, without having to remember to. If you leave it as is, running it again is simple: open a new session, tell Claude which workflow file to use, and give it the new input, in this case a fresh set of incident notes. No rebuilding anything.
But if you're running this every week anyway, don't do it by hand. Schedule it. Tell Claude to schedule it, give it the timing, Monday morning, whatever fits, and keep the incident notes somewhere Claude can reach on its own, like Google Drive, not just sitting on a laptop. Once it's scheduled, it runs itself. No login, no remembering.
Here's the mistake that kills most agent builds: not actually reading the plan before approving it. That pause, where Claude shows its plan before running the workflow, matters. Skip past it, and the agent is left guessing its way through several steps instead of one. Two minutes of review up front saves ten minutes of cleanup. Always read the plan before approving it.
Design the workflow before touching real data. Turn the plan into a reusable file. Run it on real data to prove it holds up. Schedule it once it does. That's how an agent gets built the right way, instead of guessed at one prompt at a time.
Once an agent is running, the next real question is whether it's actually built well or just doing the bare minimum and getting away with it. That's covered on the videos hub, in "Your Cowork Agents Are Probably Underbuilt. Here's What's Missing."