Building Your First AI Agent Team: Roles, Memory, And Review Loops

In the X article "How to build your first team of agents", Machina lays out a practical blueprint for a small agent team: five roles, three agent engines, one shared workspace, and a review loop where no agent approves its own work.

The piece is marked as sponsored by Raft. Still, the underlying architecture is useful beyond any single product.

The core claim is simple: one assistant only scales as far as the attention of the human controlling it. Opening more parallel chats does not solve that. Without a shared workspace, roles, memory, and review, teams get distributed confusion with better language.

From Assistant To Work Organization

A single AI assistant is a tool. An agent team is a work organization.

The difference is not model size. It is structure:

• Persistent identity: every agent has a name and a job.
• Compounding memory: corrections, sources, rules, and playbooks survive across sessions.
• Separate review: another agent checks outputs against failure assumptions.
• A shared room: work lands in channels or threads instead of isolated sessions.
• Human approval: anything that affects the outside world remains a human decision.

That is the real shift. Agents stop being treated as individual tools and start looking like specialized teammates with bounded mandates.

The Five Roles

The article proposes five roles mapped to common business functions:

• Lead acquisition: watches sources, finds qualified prospects, and drafts first-touch messages.
• Content creation: produces posts, newsletters, offers, and written material.
• Sales pipeline: keeps open conversations moving and watches for follow-ups.
• Service delivery: supports client work, reports, concepts, and deliverables.
• Finance: tracks invoices, costs, and monthly numbers.

These roles are useful because they are not cut by tool category. They follow the operating system of a small business: create demand, build trust, sell, deliver, understand the numbers.

Three Engines, One Room

Machina maps those roles to three engines:

• Claude Code for writing, concept work, and client-facing deliverables.
• Codex for internal tools, scripts, and automations.
• Hermes for always-on work such as monitoring, heartbeats, and recurring checks.

Raft is described as the shared room where humans and agents work together: channels, threads, tasks, DMs, persistent agents, and shared work trails. The architectural point is not that this exact stack is mandatory. The point is that agents should not work in disconnected windows.

Without a shared room, the human becomes the copy-paste layer. With one, work can be handed off, reviewed, and continued.

The Smallest Useful Agent

The article defines an agent through five parts:

1. Name: so work can be addressed and audited.
2. Role or soul: scope, boundaries, tone, and hard rules.
3. Memory: learned corrections, source quality, playbooks, and working notes.
4. Goals: what the agent owns, what "done" means, and when it must escalate.
5. Heartbeat: scheduled repetitions such as daily source sweeps or hourly reply checks.

This is a strong minimal model. It prevents agents from starting as magical generalists. Each agent gets a narrow mandate, a clear output shape, and a place where learning is stored.

No Self-Approval

The strongest rule in the article is this: no agent should be the final reviewer of its own work.

It sounds simple, but it is a foundational rule for responsible agent systems. An agent reviewing its own result often reuses the same perspective that created the result. A second agent with an explicit counter-role catches different failures:

• wrong fit
• weak reasoning
• stale source
• unsupported claim
• missing context
• missing approval boundary

Even more important: every rejection carries a reason. That reason can be written back into memory, soul, or playbook. The system improves not only individual outputs, but the agent's operating behavior.

The ag3nt.id Take

An agent team is not a framework feature. It is an operating model.

Teams that want to use agents productively do not need five new tools first. They need roles, data access, escalation rules, review responsibility, and a shared work surface. That is where agentic AI becomes real leverage instead of coordination overhead.

The practical start is small: one agent for one function, one reviewer, one channel, one daily run. Add the next agent only after the first loop is stable.

That is less flashy than the demo of an "autonomous company." It is also how agents become useful at work.

Source: Machina, "How to build your first team of agents"

Further reading: Leading Agentic AI: From Automation Projects To Agency Organizations