AI Agents
I Just Wanted a Script. Why Am I Running a Company?
We spent years complaining about meetings, handoffs, and layers of management. Now we’re building AI agents that do all three. A small coding task arrives, and somehow it needs a product manager, an architect, a reviewer, and someone to coordinate the other agents. The button is still broken. The org chart looks fantastic.
Imagine asking an AI to fix a button that saves a form twice.
You want it to save once. This feels like a reasonable assignment.
Before the code changes, though, a product agent turns the request into requirements. An architect agent proposes a solution. A lead agent breaks it into tasks. A developer agent gets assigned the work. A reviewer agent waits for the output.
Above them sits an orchestrator, making sure the other agents are sufficiently coordinated.
The button still saves twice. It now has a leadership team.
Somewhere between “AI can help me build this” and “let me configure the agent framework,” a small project has turned into starting a company.
And the company has some very familiar problems.
We brought the meetings
Nobody sends a calendar invite, but read the conversation.
One agent proposes an approach. Another restates it with slightly different headings. A third agrees and adds “robust error handling.” The first incorporates the feedback and produces a revised plan.
I have been in this meeting. You probably have too.
A useful discussion changes a decision. Someone spots a constraint, challenges an assumption, or brings evidence the others did not have. That can absolutely happen between agents.
But when the output of the discussion is mostly a longer version of the input, I struggle to call that progress.
We finally found participants who never need lunch, and immediately put them in an alignment session.
Apparently the model needs a promotion
The job titles are my favorite part.
Junior developer. Senior developer. Staff engineer. Principal architect. Engineering manager.
Give it another release and the agent will need a promotion packet.
In a human team, those levels are supposed to represent differences in experience, responsibility, and judgment. An experienced engineer might recognize a dangerous pattern because they spent a miserable weekend fixing it five years ago.
Writing “You are a distinguished engineer” at the top of a prompt does not supply that history.
Role instructions can help focus a model. A separate reviewer can also be useful, especially with fresh context, clear requirements, and checks it can actually run. But the title alone tells us very little about what the agent can do.
If the junior agent and the principal agent inherit the same bad assumption, the principal can repeat the mistake in more authoritative language.
We should be asking what changes between those roles. Different tools? Different evidence? Different access? A genuinely different way to test the answer?
Otherwise, we have given the same uncertainty a nicer business card.
The handoff survived the automation
Here is how the button problem can go wrong.
The original request says: “Stop the duplicate save, but keep keyboard submission working.”
The planner summarizes it as “prevent duplicate submissions.”
The next agent turns that into “disable the button while saving.”
By the time the developer receives the task, the keyboard requirement has disappeared.
The implementation may satisfy the handoff perfectly and still fail the person who asked for the work.
Anyone who has heard “that wasn’t in the ticket” knows the feeling.
Anthropic has documented this broader pattern: agent architectures copying company org charts, with context getting lost between agents and additional coordination adding latency. It is a recognizable organizational problem with a new implementation.
A handoff needs a reason to exist. Perhaps the next agent has access to a system the first cannot use. Perhaps it can investigate something independently. Perhaps a separate check catches a mistake.
“Because the next box in the diagram needs an input” is a less convincing reason.
The setup has become the project
Then there is the harness, the software around the agents that manages their tools, execution, and state.
Useful stuff lives there. Permission controls. Time limits. Recovery when a tool fails. Records that help you understand what happened.
But a weekend prototype can also acquire role definitions, routing rules, handoff formats, shared memory conventions, escalation paths, and a supervisor for the supervisor.
You sit down to make a small tool. By Sunday afternoon, you are debugging why the planning agent cannot deserialize the architect’s response.
The actual feature has become a dependency of the infrastructure project you accidentally started.
I understand the attraction. Setting up the system feels productive. There are folders, diagrams, and decisions to make. Everything suggests that serious engineering is happening.
Then somebody asks to see the working thing.
“Almost there. Just finishing the orchestration.”
That sentence deserves a little suspicion.
We even taught them to look busy
A busy agent dashboard is reassuring.
Tasks are moving. Messages are arriving. Status indicators are changing color. It feels like having a whole team working for you.
Yet it is possible for every agent to complete its assigned step while the overall result still misses the request.
The planner produced a plan. The developer followed it. The reviewer checked against it. Nobody noticed that the plan had quietly dropped the keyboard requirement.
Everyone did their job. The user still has a broken workflow.
As an engineering manager, this is the part that bothers me most. We already have enough ways to confuse activity with delivery. I would rather not encode another one.
I suspect some of the appeal is familiarity. We know what a team with managers, specialists, and status updates looks like. It feels organized. We can imagine ourselves running it.
A small system that finishes the job without all that ceremony can feel strangely under-managed.
That is our discomfort to examine before turning it into architecture.
Make the extra agent earn its place
There are good reasons to use multiple agents. Independent investigations can run in parallel. A separate context can keep one investigation from crowding out another. Different tools and permissions can justify separate workers. Anthropic explicitly identifies parallel work, verification, and permission boundaries as useful applications of subagents.
The question is whether those reasons apply to the thing in front of you.
For a small project, I would start with a clear goal, the context needed to understand it, access to the right tools, and a concrete way to check the result. Add complexity when the simpler setup shows a specific weakness. That is also the principle behind Anthropic’s guidance to begin with the simplest workable approach. Before adding another role, ask what would get worse without it. Try both versions. Compare whether they finish the actual task, how long they take, what they cost, and how much correction you still have to do.
A reviewer that catches a real defect earns its place.
A coordinator that forwards three messages and congratulates everyone deserves a closer look.
We have a chance to leave some of the worst parts of office life behind. I would hate to discover that, given machines capable of doing useful work, our first instinct was to make them wait for each other.
The Save button does not need a VP.