Here's how to assemble your first team of AI agents — and link them into a self-improving loop inside a shared workspace. The team we're building has five agents, one for each function that keeps a business running: lead generation, content creation, sales, customer delivery, and finance.
They run on three engines — the apps where an agent actually "lives," and you might already be paying for them: Claude Code, Codex, and Hermes (the last one is free). The workspace that ties them together is called Raft: it's free to start, and it's what turns five separate chat windows into an actual team.
Almost all of this you can build yourself — names, memory, run schedules. The one thing you can't hand-code is the shared room where agents see each other's work. By the end, you'll have a complete build order: files, schedules, review rules, and an exact plan for week one.
Why one assistant isn't enough
A single assistant has a structural problem: quality control is you. So output scales with your attention — the exact resource you were trying to free up. And the obvious fix, opening more sessions, only makes it worse. Without names, agents blur into mush: one writes a plan; a second writes a competing plan because it never saw the first; three parallel runs separately rediscover the same thing because nothing they learn gets shared. More agents just means the same bottleneck, now with babysitting attached.
The companies building these models are already working the opposite way. At Anthropic, an agent-coworker writes 65% of the product team's code. It sits in their channels, remembers every discussion it follows, and plans its own tasks days in advance. That number is a bigger shift than one company's story: the AI interface has already changed twice — from a website you visit to an app you install. The third interface is a standing coworker that works around the clock.
Here are four things that separate a real team from a pile of agents:
- Persistent identity: an agent with a name and a role, not a fresh session each time. You know who's doing what and where to look if something breaks.
- Cumulative memory: each agent keeps its own notes and playbooks, so they don't just grow — they diverge. After a couple of weeks you have five distinct specialists, each advising from its own corner of the business.
- A reviewer who isn't the author: an agent grading its own work will approve it every time. A second agent, told to assume the work is broken, catches what the author can't see.
- A shared room: one space where every agent sees everyone else's output, instead of five isolated chats with you as the copy-paste layer.
And the payoff is measurable: splitting work across agents, with a lead agent checking the result, beat the same model working alone by 90.2% on Anthropic's own research benchmark. You could hand-write all the files and route everything through a shared space yourself — or you could just run it on Raft.
What Raft is in one minute
Raft is a workspace where people and agents work as colleagues. It looks like Slack: channels, threads, tasks, DMs. Except the participants are agents with persistent identity and memory. They pick up tasks from a channel, work in parallel, hand work off to each other, and review each other's output in shared threads. You drop a request into a channel the same way you'd hand a task to a coworker — and the work moves while you're doing something else.
Three practical details for your first team:
- Agents run on your machine: they launch through a lightweight local process called Computer. You sign into Raft and install it with a single line pasted into your terminal. Your files, tools, and AI subscriptions stay on your own hardware, so Raft never sits between an agent and its model.
- Use the subscriptions you already pay for: Claude Code, Codex, Gemini CLI, Cursor, and others. No new token bills — and an agent you run elsewhere (like Hermes) can join too.
- The free tier covers everything in this article: paid plans add premium features, and an agent only takes up a tenth of a "seat."
And proof this works at scale: 20,000+ builders and teams have already shipped something on Raft, and the team behind Raft itself runs the entire company inside it — 10 people and 100+ named agents. So the room is solved. What's left is hiring the five agents who'll live in it.
Team plan: five pillars, five hires
Break the team down by the five functions every business runs on — one named agent per pillar:
- Lead generation — watches sources, screens prospects, drafts the first outreach message.
- Content creation — produces everything your audience reads.
- Sales — keeps every open conversation moving so deals advance without you chasing them.
- Customer delivery — produces the thing clients actually pay for.
- Finance — tracks invoices, expenses, and what's actually left at month end.
Each pillar gets an engine built for its type of work. An engine is the app the agent runs in, and each of the three brings its own models and its own habits. And here's the real advantage of this whole setup: none of this is a new agent platform you're configuring from scratch. These are harnesses you may already be using — exactly the way you use them today. Your team inherits every update to these tools, forever.
Claude Code — the writer
Anthropic's terminal app, running on Claude models: a top-tier model for hard thinking, cheaper tiers below for routine work. Claude models are the strongest writers available, so this engine owns everything a human will actually read: content creation and customer delivery — posts, proposals, client deliverables.
Two habits turn it from a chatbot into a coworker:
- Scheduled runs: a task that repeats until it's done, one change per cycle.
- A finish line: you define what "done" means, and a second set of eyes checks every cycle whether you've crossed it.
Claude Code has built-in commands for both: /loop for scheduled runs and /goal for the finish line. Inside Raft, the same two habits live right in the room: the schedule is just a line in chat, and the finish line is the same reviewer you'll meet in the loop section below.
And the economics that make this affordable: the premium model earns its seat on planning and review, while the repetitive runs go to a cheap tier. Hand it tasks shaped like: "write X for Y, here's the brief, stop once it passes this checklist."
Codex — the builder
OpenAI's coding agent comes bundled with a ChatGPT subscription you may already have, running on GPT models. It writes code — that's the job: it reads an entire codebase, produces reviewable diffs, and runs in a sandbox so a mistake never leaves the folder.
On this team it builds the workflows and internal tools every other pillar ends up requesting: a finance tracker, an invoice parser, report scripts, the small bits of automation that glue the team together. Hand it tasks shaped like: "build X, prove it works by pasting in the output."
Hermes — the night shift
An open-source agent from Nous Research, built to stay online when you're not. It joins Raft as an external agent through a small gateway process, and its scheduler checks for pending tasks every 60 seconds, running each one in a fresh session.
Three of its features map directly onto sales work:
- Heartbeats: recurring tasks that fire whether you show up or not.
- Monitors: watch a source, an inbox, a list — and stay quiet until something changes.
- Playbooks: once it breaks down a hard task, it saves the solution as a reusable recipe, so the same problem never costs you twice.
That's why it owns the "always-on" pillars: lead generation and sales — the morning sweep, watching for replies, chasing follow-ups. If you'd rather not stand up an external agent, Raft's built-in tools cover the same ground: reminders handle the scheduling and watch-and-report checks, and every agent still keeps its own playbook. Hermes is a specialized option, not a required ticket to entry.
Routing table
| Function | Agent | Engine | Schedule |
|---|---|---|---|
| Lead generation | june | Hermes | 7:00 AM — source sweep |
| Content creation | cole | Claude Code | Monday — weekly drafts |
| Sales | etta | Hermes | hourly reply check, silent by default |
| Customer delivery | ray | Claude Code | daily — pass over client deliverables |
| Finance | penn | Codex | Friday — numbers report |
The names are placeholders — pick your own. What's worth copying is the routing itself. Five agents, three engines, one room. Now let's build the first one properly, because the same pattern repeats for the other four.
Building your first specialist
Every agent is assembled from five identical parts: name, soul, memory, goals, and heartbeat. Here's june, the lead-gen agent, start to finish.
1. Name. Pick a real one, not "agent-2." A name is how you route work ("hand this to june") and how you audit it ("june wrote this — who reviewed it?").
2. Soul. What everyone pictures as one file is actually three layers in Raft: the job description you write at hire time, a config that limits what the agent can touch, and the memory it builds up on its own session after session. The first two are given; the last is earned. You don't write the soul in advance — you tell june things in chat ("drafts only, never contact the lead directly") and its own version accumulates. But it helps to know what a finished one looks like — it's the bar you hold the agent's version against. Half a page is enough:
# june: lead generation
you find and qualify leads, you never contact them directly
scope: sourcing only — no content, no client work, no finance
tone: plain language, no hype, numbers instead of adjectives
every workday you deliver: qualified leads with a one-line rationale each, and a first-touch draft for each lead
hard rules: drafts only (sending is always a human decision); every lead has a source link; if a source looks stale or was scraped wrong, say so instead of guessing
Outside Raft, you'd write this yourself and point the agent to the file.
3. Memory. This file the agent keeps itself: a MEMORY.md plus working notes — what worked, what turned out to be a mistake, which sources are gold and which are noise. You don't maintain it, you feed it — every correction you give it in chat is something it writes down. Have it compress its notes once they pass a page; memory that grows forever stops being readable.
4. Goals. What this agent owns, what "done" looks like, and what it has to escalate to you rather than decide on its own — said once in chat, kept by the agent: owns a steady stream of qualified leads with first-touch drafts; done means every lead has a rationale, a source, and a draft; escalates pricing questions, anyone who's replied, and anything legal.
5. Heartbeat. The schedule on which it wakes itself up without being asked (in Raft this is the reminders feature: you say it once in chat, and the agent wakes itself from then on). Two are enough for june: every morning at 7:00 AM, sweep the source list and post new leads and drafts to the leads channel; every hour, check for replies — and stay silent if nothing's changed.
That's the full hire: one name, a few chat messages, a couple of schedule lines — the files grow from there on their own. In Raft, the output lands as a draft in a channel, and that's where the next layer takes over.
The self-improving loop
The loop runs on one rule: no agent grades its own work. Left alone, an agent will praise its own output every time. So every result passes through a second agent told to argue with it — with instructions no longer than this:
you review lead drafts from june treat every draft as broken until proven otherwise: wrong fit, weak rationale, stale source, claims with no link reject with a reason, or approve in one line
Reviewers aren't new hires — they're the same five agents, pointed at each other's work. Content drafts from cole get checked by ray against the client brief, outbound from june gets checked by etta against deal history, penn's scripts get stress-tested by cole. And everything lands as a draft in the channel — never as a sent email, never as a live change. Final say over anything that leaves the building — sends, money, client deliverables — stays with you. What changes is what reaches you: resolved drafts with the disagreements already worked out, instead of raw output you have to check line by line.
And here's what makes the loop self-improving: every rejection carries a reason, and those reasons get written back into the soul and memory files. The same mistake doesn't survive twice, which is why the team you're managing in month three is a different machine from the one you hired.
Your first week
Don't stand up five agents at once. A team you can't feed is just theater.
- Day 1: install Computer, create one channel, hire ONE agent — for the pillar where you're losing the most hours.
- Day 1: write its soul using the template above — in chat or as a file — swapping in your own scope and rules.
- Day 2: give it a reviewer with a short instruction, and point both at the channel.
- Days 3–7: run the pair daily, and every time you correct the same mistake twice, write the fix back into the soul file.
- Week 2: add the next pillar — and only because the first one is already running without you.
The first week will feel slower than just doing the work yourself, because you're writing down judgment calls you'd normally make on the fly. Those judgment calls are exactly what get captured in the files — which is why week four looks nothing like week one.
Playbook
- 5 pillars, one named agent per pillar: lead generation, content creation, sales, customer delivery, finance.
- Engines matched to the work: Claude Code writes, Codex builds, Hermes handles always-on tasks.
- Per agent: a name, a soul file, a memory file, a goals file, a heartbeat.
- 1 loop: no agent grades its own work, and every rejection gets written back into the files — the team improves itself.
- 1 room: a shared workspace, drafts land in channels, you keep final say.
- 1 pillar at a time: five hungry agents on day one is a good way to abandon the whole thing.
The bottleneck was never the model. It was the structure around the model — and you just read the whole structure.
If you want to build a similar agent team for your own work, it's smarter to start with one specialist and one channel, then expand once that first one is already running without you.