How I Built a Team of AI Agents with Claude Code

A multi-agent system for software development with human governance, cost control, and strategic decision-making

→ Full code and repository on GitHub: https://github.com/rheorix/agentic-company

Introduction

This weekend I asked myself how to truly leverage AI to make the entire software development process (SDLC – Software Development Life Cycle) more efficient.

I wasn’t interested in using Claude Code to write code faster or improve the quality of individual lines.
I wanted something more radical:

What would happen if a development team were made entirely of specialized AI agents?

A Product Manager that doesn’t physically exist
A Developer that doesn’t exist
A QA Engineer that doesn’t exist
A Cost Controller that doesn’t exist

And you, at the center of the system, no longer as an executor, but as a strategic decision maker.

You don’t micro-manage the work.
You don’t write every line of code.

You define direction, set constraints, evaluate decision quality, and govern the budget of the entire system.

The goal is not to automate development.
It’s to build an organization of AI agents with specialized roles, where work is distributed but decision-making responsibility remains human.

→ Full code and repository on GitHub: https://github.com/rheorix/agentic-company

What Is a Multi-Agent Architecture

In the context of software development, a multi-agent architecture distributes work across specialized models instead of relying on a single general-purpose LLM.

In the Orchestrator → Subagents pattern:

each agent has a clear and limited responsibility
each agent operates with an isolated context window
a central system (the Orchestrator) coordinates the workflow

The result is a system that is more:

stable
predictable
controllable

In summary

Architecture: Orchestrator → Subagents
Roles: PM, Developer, QA, Cost Controller
Stack: Java 21, Spring Boot 3.x, Maven, JUnit 5 + Mockito
Output: complete REST application
Average cost per feature: < $1

Why a Single Agent Is Not Enough

The real limitation is not the model’s capability, but context management.

An LLM can excel at application logic, API design, or writing tests.
But when it has to keep everything together, the phenomenon of attention dilution emerges.

Attention dilution

This occurs when, as the amount of information in the context increases, the model struggles to assign the right weight to the most relevant details.

It’s the same reason work is divided in human teams:

not due to individual incapacity, but to improve overall quality.

The Solution: Separate Contexts

The principle is simple: each agent only sees what it needs.

PM → requirements and goals
Developer → technical specifications
QA → produced code

No unnecessary context.
No useless overlap.

This approach increases precision and reduces ambiguity.

The Orchestrator → Subagents Pattern

The workflow is linear and controlled:

Orchestrator
   ↓
PM → specification
   ↓ (human approval)
Developer → code
   ↓ (human approval)
QA → tests + report
   ↓ (human approval)
Cost Controller → cost report

This is not a chaotic network of agents communicating freely.
It is a structured pipeline with explicit control points.

Setup: Getting Started

Prerequisites

Java 21
Maven
npm install -g @anthropic-ai/claude-code
claude login

Project structure

agentic-company/
├── CLAUDE.md
├── .claude/agents/
├── shared/
└── output/

.claude/agents/ → agent behavior
shared/ → shared state
output/ → generated code

CLAUDE.md: The Team’s Operating System

This file defines the system’s constitutional rules:

technology stack
communication rules
mandatory approval gates

Fundamental rules

No code without approved specifications
No commit without human validation
Every phase stops for approval

Agent Roles

Product Manager → transforms informal requests into specifications (shared/spec.md)
Developer → implements only what is defined (output/src/)
QA Engineer → writes tests and reports (shared/qa_report.md)
Cost Controller → monitors tokens and costs (shared/cost_report.md)

Shared state lives in the filesystem:

shared/project_state.json
shared/decisions_log.md

→ The filesystem becomes the coordination layer

First Run

claude

Initial prompt:

Build a Spring Boot REST API for a TODO list using the full agent workflow with approval gates.

The workflow always remains the same:

specification → approval → implementation → approval → testing → validation

Parallelism (When It Makes Sense)

Parallelism works only on independent tasks.

Example:

Developer implements endpoints
QA writes corresponding tests

Practical rule: maximum 2–3 agents in parallel

Cost Optimization

Role	Model
Product Manager	Sonnet
Developer	Sonnet
QA Engineer	Haiku
Cost Controller	Haiku

This distribution enables significant cost reduction without sacrificing quality.

Common Mistakes to Avoid

Excessive autonomy (without approval gates)
Vague specifications
Too much parallelism
Ignoring the decision log

What Really Changes

This experiment is not just about automating development.

It’s about governing technical work through AI agents.

The human role shifts across three axes:

Strategic vision
System governance
Cost and impact control

You are no longer an executor.
You are the system’s decision control point.

Conclusion

This experiment started as a technical curiosity.

But the most important result is organizational:

we are learning to build work systems where execution can be delegated, but responsibility cannot.

We are moving from productivity tools to true production systems governed by human decision-makers.

Separating roles, limiting context, and introducing control points is no longer just software engineering:

it is becoming a mature form of AI-driven operational governance.

And, at least for now, the real value does not lie in system autonomy, but in the quality of human decisions.