The difference between doing a task and building an agent
You already use AI to do tasks. This course shows you what changes when you stop doing the task yourself and instead build something that does it for you, over and over, without you in the loop. We'll end by walking through one real agent for your monthly owner reporting.
In Cowork, the way you package an agent is called a Skill. Same idea. That's just the name for it here. The rest of this course will use the word agent because that's the word you've probably heard everywhere else, but every time you see it, you can read it as "the Skill we'll build in Module 06."
What you'll walk away with
- A plain-English mental model for the task-vs-agent distinction (no jargon)
- A checklist for deciding when a workflow is worth turning into an agent
- The four parts every agent is made of
- Two worked blueprints (monthly owner reports, rent comps) you can map onto your own work
You open the chat, paste this month's PDF, and ask for a summary. You get an answer. Next month, you do the whole thing again, fresh.
You set up the instructions once. From then on you just drop the PDF in and the same dashboard comes out, identical every time, no re-explaining.
Roughly a 20-minute read. Your progress is tracked on the left. Use the buttons at the bottom of each section to move through.
Task vs. agent, in one screen
Same goal, two completely different things. Toggle between them and watch what moves.
You hand AI one specific job and you're part of every run. You decide what to do, you provide the input, you copy the output where it needs to go, you check it. The AI is a very capable assistant that forgets the moment you close the chat.
Think of it like: asking a sharp temp to "summarize this PDF for me." Great answer. But they don't know your properties, your format, or what you asked for last month, and you have to explain it all again next time.
You write down the goal, the steps, the tools, and the standards once. That package becomes a thing that can be triggered again and again. It knows how to recognize the job, gather what it needs, do the multi-step work, and deliver the result in your format, with you only checking the output.
Think of it like: training an employee and writing the SOP. The training is upfront work. After that, you say "new package is in" and the finished report appears, same shape every month.
The real dividing line
It isn't "how smart is the AI." Both use the same model. The line is who holds the process. In a task, the process lives in your head and you re-run it manually. In an agent, the process is written down and lives in the tool, so it runs without you steering each step.
It's a spectrum, not a switch
"Task" and "agent" are the two ends of a line, and most useful things sit somewhere along it. Here's the progression, using something you do every month.
| Stage | What it looks like | Who's driving |
|---|---|---|
| TaskPure task | You paste the owner PDF and type "pull NOI vs budget and occupancy." You read the reply and retype the numbers into your tracker. | You, every step |
| TaskReusable prompt | You save a long, detailed instruction block and paste it each month so the format is consistent. Better, but you still run it and still babysit. | You, with a script |
| AgentSkill / agent | The instructions, the parsing logic, the output template, and the quality checks are packaged. You drop the PDF; the standardized Excel dashboard comes out. | The agent; you approve |
| AgentAutonomous agent | It watches a folder or inbox, notices the new package arrived, builds the dashboard, flags red items, and emails you the summary. You only get pinged on exceptions. | The agent; you set policy |
The kitchen version
A task is asking a chef to cook you one dinner. An agent is the recipe card plus the trained line cook: written down once, executed consistently, every service, without you in the kitchen.
Why operators care
Your edge in multifamily is doing the same operational work consistently across a portfolio. Tasks don't scale; you re-do them per property, per month. Agents turn a repeatable process into infrastructure.
Is this workflow worth turning into an agent?
Answer for a real workflow you're considering, say, your monthly owner reports. The more "yes" answers, the stronger the case.
The litmus test
Build an agent when a process is repeatable (you do it on a cadence), structured (the steps are roughly the same each time), and standardized (there's a "right format" for the output). Owner reporting, rent comps, budget builds, and delinquency tracking all score high. Negotiating with a specific vendor, or deciding whether to refinance, score low: keep those as tasks where your judgment leads.
The four parts every agent is made of
Strip away the buzzwords and any agent is just these four things written down. Tap each to expand.
How the parts work together
A trigger tells the agent this is my job ("a new owner package was uploaded"). The instructions tell it the steps and standards. The tools let it actually act: read the PDF, run a script, write an Excel file. The output defines what it leaves behind and in what format. Get those four right and the model handles the messy middle.
These same four parts show up in Section 8: Anatomy of a Skill as the actual SKILL.md structure. This module is the concept. Section 8 is the file you write.
Building your "Monthly Owner Report" agent
Let's turn the most repetitive thing you do (turning a monthly owner package into a clean dashboard) into an agent. Here's the same job as a task, then as an agent, then the conceptual blueprint.
- Open the two PDFs, scroll for NOI, budget, occupancy, delinquency
- Retype figures into your spreadsheet by hand
- Re-format it to look like last month's
- Eyeball for red flags from memory
- Repeat per property, ~45–90 min each
- Drop the PDFs in
- Agent auto-detects property, entity, and period
- Pulls every line item by its account label, not by where it sits on the page
- Builds the identical Excel dashboard with color-coded flags
- ~2 min, same format for every property
The blueprint: your four parts, filled in
This is the conceptual spec behind the owner-dashboard Skill you'll see in Section 8. Notice it's all written instructions, not programming.
The build, step by step
Building your "Rent Comp Survey" agent
Same four parts, a very different shape of work. Owner reports read a PDF you already have; comps go out to the web, gather live data, and assemble it. This is where agents really earn their keep: the tedious part isn't the math, it's the clicking.
- Open each competitor's listing, one browser tab at a time
- Copy floor plans, rent ranges, sq ft, availability by hand
- Hunt for concession banners ("1 month free")
- Paste it all into a grid and rebuild your premium-to-market math
- Redo the whole sweep next month, hope you hit the same comps
- Say "run my comps" (or hand it your comp list)
- Agent browses each property, falls back to the property site if pricing is hidden
- Standardizes floor plans (Studio/1BR/2BR/3BR) and captures concessions and availability
- Builds the two-tab Excel: raw survey + market summary matrix with your premium/discount
- Same comps, same format, every month
What's different from the owner-report agent
The owner agent's tools were "read a file, run a script." This agent's defining tool is a browser: it navigates the live web, which means it also needs rules for the messy reality out there. A listing says "Call for Pricing." A property's gated behind a login. A name matches two communities. A big part of this blueprint is the edge-case handling that a person does on instinct but an agent needs spelled out.
The blueprint: your four parts, filled in
The build, step by step
Lock it in
Four quick checks. Pick an answer to see why it's right.