Skip to main content

Agents Aren't Employees: Why We Retired Our AI Org Chart

Earlier this year we ran our company on a crew of AI agents with names. Aime was the integrator. Rex did research, Sage did sales and marketing, Atlas did delivery, and Verity checked everyone's work. Each had a seat on an accountability chart, a scorecard, quarterly goals and a written role. We even had a hiring process for new agents.

We retired all of it in May. We retired the thing that replaced it in July. Here's why designing agents as if they were people doesn't work, and what we do instead.

What the crew looked like

We modeled the crew on EOS, the Entrepreneurial Operating System a lot of small companies use to run their teams: seats, accountability, scorecards, quarterly "rocks", weekly meetings, and the question of whether each person "gets it, wants it, and has the capacity to do it". We applied all of that to agents.

In practice that meant:

  • An integrator agent whose instructions ran to about 17,000 characters. She dispatched the others, reviewed their output and emailed a human when a decision was needed.
  • One agent per function, each with its own working folder, notes and session logs.
  • Rituals: an hourly operations script, scorecards per seat, an issues list, quarterly goals.
  • A hiring process: adding a capability meant designing a new seat for it.

It made a great story. It's easy to explain to a buyer, and it feels like a team. That's the trap.

Why it didn't work

The person became the unit, not the capability

Research lived inside Rex. If another agent needed research done, it went through Rex, or it went through the integrator, who dispatched Rex. Every reusable capability became a person with a job title, and getting work done meant routing to the right person. The same handoffs that slow down human teams, we rebuilt on purpose.

A research capability doesn't need an owner. It needs to be callable by whatever needs it.

The metaphor took up the room

A large share of each agent's instructions described who it was: its seat, its responsibilities, its rituals, how it related to the others. None of that helps a model do the task in front of it. Instructions are the scarcest resource an agent has, and we were spending them on identity.

Work was filed by who did it, not what it was for

Each agent had its own folder. A client engagement ended up spread across four agents' working directories, and understanding where a piece of work stood meant reading several agents' notes. Organizing by person is natural for people. For agents it's just a filing system that fights you.

People metaphors bring people problems

Agents with roles start behaving like a meeting: handoffs, status updates, one agent waiting on another, an integrator as the bottleneck. Peer agents passing work between themselves did worse for us than one coordinator handing self-contained tasks to workers that each start clean and report back.

Our second mistake: the perfect replacement

In May we replaced the crew with what looked like the obvious fix. Keep the capabilities, drop the personas. Write each capability as a versioned procedure: research, outreach, client deliverables, evaluation, long-running loops. Package each as a reusable skill with examples and a grading rubric. Keep one thin orchestrator agent to run them. Track every procedure on a scorecard.

It was well researched and fully built: five procedures, the skills, the orchestrator, the scorecard schema.

In two months, not one procedure ran. The scorecard's run list stayed empty for all five. Every later change to those files was a mechanical rename, never a revision based on using them. We deleted it in July.

The lesson was the same one, one level up. The design was done top-down, in one sitting, before it had met a single real task. The one piece that survived both resets was a small tool for setting up long-running autonomous loops, and it survived because it grew out of work we were actually doing at the time.

What we do now

The current setup is almost boring:

  • An agent is a job, not a person: a model, a prompt and a set of tools. It's named for what it does: sales prioritiser, technical analyst, daily agent report.
  • Capabilities are tools and files. Any agent that has the tool can use it, and everything works on a shared file workspace instead of per-agent folders.
  • Delegation is a tool call. A coordinator hands a sub-agent a self-contained task and gets back a short report (status, evidence, blockers). There are no standing relationships and no handoff rituals.
  • Procedures get written after the work, not before. When we've done something enough times to know how it goes, it becomes a skill. Not the other way round.
  • One daily report reviews every agent: failures, tool errors, loops, slow runs. We judge agents by what they did, not by a scorecard they "own".

We still use the word crew. For a business, it's a good word for the set of agents that take on its recurring work: follow-ups, customer questions, research, reporting. The difference is what you design. You design the jobs, the tools and the checks, not the people.

Where names still help

Names aren't the problem. A customer-facing chat agent with a name and a consistent voice is good product design: shoppers talk to it like a person, and that's fine. The problem starts when the name becomes the architecture: when you design seats instead of jobs, relationships instead of tool calls, and rituals instead of checks.

A quick test

If you're building agents for your business, these are signs you're designing people instead of jobs:

  • The prompt has a personality or backstory section longer than its task section.
  • A capability only exists inside one agent, and others have to ask that agent for it.
  • Agents report to each other in recurring meetings or status updates.
  • Output is filed under the agent that made it, not the work it belongs to.
  • Adding a capability means "hiring" a new agent instead of adding a tool.

And the healthier shape:

  • Each agent has one job and the tools for it.
  • Capabilities are tools any agent can call.
  • A coordinator hands out self-contained tasks and checks the reports.
  • Every run is recorded, and failures show up where someone already looks.
  • Procedures are written down only once you've actually done the work a few times.

Agents are a strange new kind of worker. Treating them like employees made a great story and a bad system.

Need help with your project or have questions?

We specialize in AI automation, custom integrations, and intelligent workflows tailored to your business needs.

Whether you need help deploying, building, implementing, or creating a solution - or just want expert guidance on your project - we're here to help.

Contact us today to discuss your project.