Meet the fleet · Agent 01
A teammate that lives in your team chat, keeps everyone's tasks in one place, and never lets a promise quietly slip.
What it feels like to have this agent on your team. No setup, no jargon. Start here.
A followable, step-by-step build, on our stack or yours.
The clever machinery that makes it cheaper and smarter. Optional.
The wider fleet, plus deep notes on cost, caching, observability, sync, and the source docs.
Wherever we name a tool we use, you will see a 🔁 Swap box with alternatives. We are showing you what worked for us, not prescribing it. Use whatever your team already lives in.
Picture a normal Tuesday. You do not open a project tool. The agent comes to you, right inside the chat app your team already uses.
Behind the friendly nudges is a single running list. Every item has an owner, a status, and a link back to the exact message it came from, so nothing is a mystery later. See it as a simple list or flip it to a Kanban board, and filter it down to just your own items.
No new app to learn. You already know all three.
The emoji plays two roles, and neither one is set in stone. First, it is a trigger: reacting to a message with the agent's emoji tells it to handle that one right now, instead of waiting for its next scheduled read. Second, it is a signature: the agent leads its posts with the emoji so everyone can tell at a glance that a message came from the agent, not a person. We happened to pick 🤖. Pick any emoji your team will remember. The point is the two jobs it does, not the specific icon.
You can stop reading here and still get the whole value. Level 1 is the product. Everything below is for when you want to build your own copy.
Five steps. Each one names what we use, gives you alternatives, flags the one place people get stuck, and tells you how to know it worked. Read it once top to bottom before you touch anything. Plan on about half a day for a first working version.
The agent's whole personality and job description is a plain-text file. No code. You describe who it is, the channels it watches, its schedule, and its hard rules, then save it in your shared drive so every scheduled job reads the same instructions.
/agents/project-manager/.skill.md and fill in these sections:# project-manager · brain (plain text, lives in your shared drive)
identity: A warm, sharp teammate who keeps the Tracker clean.
watches: [ #your-team-channel ]
standup: 10:00am, weekdays -> post in #your-team-channel
checkin: 5:00pm, weekdays -> DM each person their open items
cleanup: Monday 9:00am -> archive done, flag stale
tracker: <link to your board>
rules:
- Never invent an owner. Only assign if the person explicitly agreed.
- Refer to every item by its # id.
- Keep nudges in DMs so channels stay quiet.
The real brain file also carries the team roster, the Tracker schema, the six workflows (standup, hourly scan, 5pm check-in, DM intake, stale-thread detection, Monday cleanup), the greeting-and-signature rule, and the hard constraints. The full fill-in-the-blank skill.md template and a setup checklist are folded into the Starter kit section below, so you are not writing it from scratch.
Create an app so the agent has its own name and face, and permission to read the channel and post. This is where most people hit the first wall, so go slowly.
App permissions and event notifications. The app needs the right access to read and post, and an events connection so a reaction can trigger it live. Get this right once and everything after it is easy. If the agent can post but never reacts to your emoji, the events connection is the thing to check.
The standup, the hourly reads, and the 5pm check-in are just scheduled jobs. Each job wakes up, reads the brain file, reads recent messages, updates the board, and posts. Point every job at the brain so it always runs the latest instructions.
The scheduled job needs secrets and environment variables to act on your behalf. Keep them in your host's secret store, not in the code or the brain file. A job that fails silently at a set time is almost always a missing or expired token.
/schedule command), on Anthropic-managed infrastructure that keeps running even when your computer is off.The agent needs one place to keep tracked items. We keep ours as a Slack List so the team never has to leave chat, but this is the most swappable choice in the whole build. Use the board your team already lives in.
| Column | Holds |
|---|---|
| Item | The task, open loop, decision, or blocker in plain words |
| Type | action · loop · decision · blocked |
| Priority | p0 (drop everything) to p3 (someday) |
| Owner | Only set if that person explicitly committed. Never guessed. |
| Status | new · in_progress · waiting · blocked · needs_clarification · done |
| Link | A jump back to the source message |
Do not roll this out to fifty people on day one. That is how good tools die from overwhelm.
When you edit the brain file, give the shared drive a minute to sync before the next run picks it up. Edits are not always instant. Jot changes in a simple change log so the team knows what moved.
This is as much behavior change as technology. The best tech is wasted if people are not trained to use it. Crawl, walk, run beats a big-bang rollout every time.
Everything you need to stand up your own, folded right in. Copy the brain template into a file in your shared drive, then work the checklist. Replace every {{PLACEHOLDER}}, and delete any workflow you do not want on day one.
skill.mdThis is the agent's whole personality and job description. Plain text, no code. It is the full version of the snippet up in Step 1.
The golden path in order, with the two real walls and a done-check per step. Paste it into your task tool and tick as you go.
Keep the fixed instructions in skill.md fixed. Do not paste live data (today's date, live counts, a fresh transcript) into it, or you break prompt caching and pay more. Changing data goes in the message body.
Optional. This is what turns a set of scheduled scripts into a system that gets cheaper and smarter over time. Skip it and your agent still works. Full source docs are linked in the Appendix.
A small dispatcher reads each job and sends easy work to a cheaper, faster model and hard work to a stronger one. It is automatic and invisible to the team. For us this quietly saved about $250 in a single month with no drop in quality.
All the agents read one shared ledger of hard-won lessons at the start of every run. When one agent learns something and it proves out, it becomes a reflex the whole fleet follows. A nightly pass compacts the lessons so the memory stays sharp instead of bloating, and lessons that stop being useful fade on their own. Some teams call this a HiveMind.
The stable part of each agent's instructions is cached, so you are not billed to reprocess it on every run and the agent responds faster. The trick is to keep the fixed instructions fixed and keep changing data (timestamps, live counts) out of them, or you break the cache. See the Appendix for how the cache behaves and the official docs.
Every change to how the agents work goes through an automated senior-engineer review before it merges. It checks the change, merges it, and can roll it back on its own if something looks wrong. It escalates to a human only when there is a real conflict to resolve.
If you install the packaged PM agent through Agentic OS instead of hand-rolling your own, the first two of these ship out of the box: every scheduled job already carries a cost tier (mechanical jobs run cheap, judgment jobs run at the default tier), and there's an optional shared-lessons-ledger hook you can turn on the moment you're running more than one agent. Nothing to build - just don't turn it off.
Where to take this next, with detailed operational notes and links to the source documentation. Everything here is optional and additive to the PM agent you just built.
The PM agent is one example. We happen to run a handful more, but the same four-level pattern lets you build any agent your team needs: an onboarding agent for new hires, a QA agent that reviews work before it ships, an inbox triager, a meeting-notes agent, a client-success agent. Start with one, earn trust, then stamp the next.
A few of ours, as inspiration:
This one. Standups, the Tracker, check-ins, open loops.
Turns transcripts and recordings into clean company docs and digests.
The front door. Routes work, watches fleet health, ships changes, holds the shared memory.
Hunts cost, caching, and reliability wins each day and queues the next improvements.
Revenue, pipeline, and pacing. Runs the what-if numbers for the CEO.
The code-review gate. Reviews, merges, and deploys every change.
Skills are small written instructions that give any Claude session a repeatable superpower, the same idea as the brain file above (see Anthropic's Agent Skills guide). A few worth reaching for, and where to get them:
Once an agent is running unattended, you want to know it actually ran and did not quietly fail. Two layers cover it.
Two levers control almost all of the spend, and both are worth setting up before you scale past one agent.
Caching stores the stable prefix of a prompt so repeated runs are cheaper and faster. What actually happens:
Because the brain is a file in a shared drive, there is a small lag between saving an edit and a job reading it. This is normal and easy to manage.
If standing up scheduled jobs and an app feels heavy, you can get most of Level 1's value with far less. Claude Code can run scheduled tasks on Anthropic-managed infrastructure and message your team directly, so a crawl version is just a few scheduled prompts.
| Term | In plain words |
|---|---|
| Skill / brain file | A plain-text document that tells the agent who it is and what to do. No code. |
| Cron / scheduled job | A task set to run at fixed times, like "10am every weekday." |
| Environment variable / secret | A password or key stored safely in your host so the agent can act on your behalf. |
| Event subscription | The wiring that lets your chat app tell the agent something just happened, so a reaction can trigger it instantly. |
| Model router | An automatic chooser that sends easy work to a cheap model and hard work to a strong one. |
| Prompt caching | Reusing the stable part of a prompt so you do not pay to re-read it every time. |
| HiveMind | One shared memory the agents read at the start of each run, so a lesson learned once helps all of them. |
| Observability | Knowing your agents actually ran and stayed healthy, through watchdogs and dashboards. |
This same four-level shape works for every agent you build. Once the PM agent has earned trust, the next agent follows the exact same build and the exact same guide layout.