Humans Have Roles. Agents Have Functions.

For most of the history of software development, organisations have been structured around human roles. We created job titles that mapped neatly to stages of delivery: analyst, architect, developer, tester, operations. Work flowed from one role to the next like a relay race, each group responsible for a different part of execution.

This structure made perfect sense in a world where execution required humans at every step. If writing code, testing systems, deploying infrastructure, and running environments all required specialist knowledge and manual effort, then organisations naturally formed around those execution activities. Roles were really just containers for execution responsibilities.

But once execution starts to become automated, orchestrated, and increasingly handled by agents, the foundation that those roles were built on begins to change.

The question is no longer just how we build software.
The question becomes: what do humans do when machines increasingly handle execution?

Roles and Functions Are Not the Same Thing

One way to understand this shift is to separate two ideas that have historically been blended together: roles and functions.

Humans have roles.
Agents perform functions.

A role is broad, contextual, and organisational. A role exists inside a system of responsibility. It carries accountability, decision-making authority, domain knowledge, judgement, and ownership. A role is not just a list of tasks; it is a position in a system of responsibility.

A function, on the other hand, is something much narrower. A function is an activity that can be executed: generate code, run tests, deploy a service, monitor performance, refactor a module, generate documentation.

Agents do not need job titles, career paths, or departments. They do not need to be developers, testers, or operations engineers. They simply perform functions when execution is required.

This distinction sounds small, but it leads to a very different way of thinking about organisations and systems.

The Trap: Recreating Human Organisations with Agents

When people imagine the future of AI in software development, they often keep the organisation exactly the same and just insert agents into the existing structure.

The conversation becomes something like this:

• The Business Analyst becomes the Intent Analyst
• The Architect becomes the Intent Architect
• The Developer becomes the Prompt Engineer
• The Tester becomes the Validation Engineer

But this is really just the old world with new labels. The structure of the organisation hasn’t changed; we have simply automated parts of the delivery pipeline.

If we continue to structure organisations around analysis, design, build, test, and run, then we are still fundamentally organising around execution. We are just executing faster.

The more interesting question is not how AI fits into our current roles, but whether those roles were really just a product of a world where execution was manual and expensive.

Multi-Agent Systems Are Not Organisations

This becomes even clearer when we think about multi-agent systems.

When people first design agent-based systems, they often mirror human organisations. They create agents called Architect Agent, Developer Agent, Tester Agent, Operations Agent, and Project Manager Agent. The system starts to look like a miniature digital organisation chart.

But this is usually the wrong abstraction.

Agents do not need roles, job titles, departments, or reporting lines. Those structures existed because humans needed coordination, communication, and management. Agents do not have those constraints in the same way.

A more natural way to design a multi-agent system is around functions rather than roles. Instead of a Developer Agent, you might have agents that generate code, generate tests, run tests, deploy services, monitor performance, analyse logs, optimise queries, refactor code, or update documentation. These are not roles; they are functions within an execution system.

So a human organisation might look like this:

• Architect
  Developer
  Tester
  Operations
  Project Manager

But an agent system might look more like this:

• Generate Code
• Generate Tests
• Run Tests
• Deploy Service
• Monitor System
• Analyse Metrics
• Optimise Performance
• Refactor Code
• Update Documentation

The human organisation is structured around responsibility and decision-making. The agent system is structured around functions and execution.

This is another way to see the same idea:

Humans organise around roles.
Agent systems organise around functions.

Roles Were Built for a World of Manual Execution

Historically, organisations were structured around the work that needed to be done manually. If coding was manual, we needed developers. If testing was manual, we needed testers. If deployment was manual, we needed operations engineers. If coordination was difficult, we needed project managers.

Roles emerged because execution required human effort and specialisation.

But if execution increasingly becomes automated, then the organisation should probably not be structured primarily around execution activities anymore.

Instead of asking:

• Who writes the code?
• Who runs the tests?
• Who deploys the system?

We start asking different questions:

• Who decides what should exist?
• Who decides what matters?
• Who decides what constraints apply?
• Who decides whether outcomes are acceptable?
• Who changes direction when things don’t work?

These are not execution questions.
These are responsibility, direction, and intent questions.

Humans Move Up the Stack

If agents and automated systems increasingly handle execution, then humans do not disappear from the system. They move up a level.

Humans spend less time telling the system exactly how to do things, and more time deciding what should be done and why.

Human work becomes:

• Setting direction
• Defining goals
• Describing desired outcomes
• Defining constraints and policies
• Reviewing results
• Making trade-offs
• Providing domain knowledge
• Deciding priorities
• Changing direction
• Governing behaviour

In other words, humans move away from execution and towards intent, governance, and direction.

Roles do not disappear, but their purpose changes. Roles are no longer primarily containers for execution work; they become containers for responsibility, decision-making, and intent.

Humans Have Roles. Agents Have Functions.

This leads to a simple way to think about the future organisation and future systems.

Humans will continue to have roles because organisations still need responsibility, accountability, decision-making, domain knowledge, ethics, judgement, and direction.

Agents, on the other hand, will perform functions. They will generate, test, deploy, monitor, optimise, refactor, document, and operate systems.

So instead of trying to map agents onto human job titles, it is more useful to think like this:

Humans have roles.
Agents have functions.

Humans are responsible for intent and direction.
Agents are responsible for execution and enactment.

And perhaps the simplest way to summarise the whole model is this:

Govern intent. Delegate execution.

What This Means for Organisations

Once you start to see this clearly, an interesting implication appears. If humans are primarily responsible for intent and direction, and agents are primarily responsible for execution and functions, then organisations may slowly stop being structured around delivery pipelines and execution activities.

Instead, organisations may increasingly be structured around defining, governing, and evolving intent while automated systems enact that intent.

That idea takes us beyond software development and into something bigger: how organisations operate when execution is largely handled by machines.

And that is where this series is heading next.

Next Article ->