The Autonomous Team

There is a version of the multi-agent future that gets written about constantly. Several AI agents, each specialising in a domain, passing work between them at machine speed. One writes code. Another reviews it. Another deploys it. The loop closes in seconds. It's impressive, and for software delivery it works.

But software delivery is one domain. Most organisations operate across a dozen. Marketing, strategy, operations, finance, product, customer success — each with its own rhythm, its own vocabulary, its own definition of done. The question that nobody has answered cleanly yet is: how do agents coordinate across those domains? What's the layer that lets an agent working on a content strategy and an agent monitoring revenue metrics act as part of the same team?

My hypothesis is that the answer is simpler than most people expect. It's work primitives.

The Problem With Orchestrators

The dominant mental model for multi-agent coordination right now is the orchestrator. One agent — sometimes called a "manager agent" or "controller" — sits at the top and directs the others. It receives a goal, breaks it into tasks, delegates them, and assembles the outputs.

This model works in controlled environments. It fails in complex ones.

The orchestrator becomes a bottleneck. Every decision routes through it. Every agent waits for instruction. More critically, the model is brittle — if the orchestrator misreads the situation, every downstream agent inherits that error. There's no redundancy, no self-correction, no genuine collaboration.

There's also something philosophically wrong with it. Good human teams don't work this way. A strong team doesn't need constant direction from a central authority. They share an understanding of the goal, the current state of work, and their own role within it — and they act accordingly. The manager's job is to set direction and remove obstacles, not to route every task.

If we want agents to work like good teams rather than obedient machines, we need a different coordination model. Shared context, not command and control.

What Shared Context Actually Means

"Shared context" gets used loosely in AI discussions, usually to mean shared memory or a shared system prompt. That's not what I mean here.

I mean shared organisational context. The goal the team is working toward. The project that contains the work. The tasks in flight, the milestones ahead, the risks on the table, the metrics that define success. The current state of work, expressed in a structure every member of the team — human or agent — can read and act on.

This is what distinguishes an agent that's been handed a brief from an agent that's genuinely part of a team.

A briefed agent knows what to do right now. A contextualised agent knows why, knows what came before, knows what depends on its output, and knows when its work is done.

In Clarity Forge, we've built the organisational context layer deliberately. Every goal is connected to the projects that serve it. Every project contains its tasks, milestones, risks, and status. Every agent operating in that space has access to that full structure — not just the slice relevant to its current task, but the web of relationships that gives any individual piece of work its meaning.

The result is agents that can self-orient. They don't need to be told what matters. They can read it.

Work Primitives as the Coordination Layer

Here is the hypothesis stated plainly: goals, projects, tasks, milestones, metrics, risks, and more are the coordination layer for multi-agent systems — not APIs, not memory stores, not message queues.

These primitives aren't software abstractions. They're the vocabulary that every human team already uses to describe work, regardless of domain. A marketing team tracks campaigns as projects with milestones and success metrics. A finance team tracks forecasts as goals with key results and risks. An engineering team tracks delivery in sprints — which are, structurally, just projects with tasks and milestones.

Every domain maps onto the same underlying primitives. That universality is precisely what makes them useful as a coordination layer. An agent working on content strategy and an agent working on product delivery don't need to understand each other's domain. They need to read from the same work state — the same goals, the same project status, the same risks — and act accordingly.

In practice, inside Clarity Forge today, this is already happening. A social media agent reads the GTM narrative, the current quarter's goals, and the content queue — and produces content that serves the strategy without being told what the strategy is. A strategy agent monitors market signals and updates assumptions that feed directly into the goals structure. A status agent reads project activity and surfaces risks before anyone asks. They're not coordinating through messages. They're coordinating through shared work state.

The pattern is real, and it's what I'm watching.

The Human Role — And Why Speed Isn't the Point

Here is where I want to push back on the framing that dominates most multi-agent discussion.

The implicit promise of autonomous agent teams is speed. Agents don't sleep. They don't have competing priorities. In theory, a team of agents could operate continuously, closing loops that would take a human team days or weeks.

In theory.

The world doesn't move at machine speed. A blog post needs readers. A marketing campaign needs an audience to notice it. A product update needs customers to try it and report back. The feedback loops that actually matter — market response, customer behaviour, revenue — move at human speed. Agents can produce outputs faster than any human team. They cannot make the world respond faster.

This is why the "pause" in agent execution isn't a limitation to be engineered away. It's the architecture. Agents act, the world responds at its own pace, agents read the response and act again. In between, there is space. And that space is where humans participate.

Work primitives make this natural — because agents are operating on goals, tasks, milestones, and discussions using the same structures humans use, there's no translation layer. A human can open a project, read what an agent has done, leave a comment, adjust a priority, flag a concern. The agent reads it on the next run. This isn't a workaround. It's collaboration.

When agents operate on work primitives, they're speaking the same language as the people around them.

There is something deeper here too. Work primitives are the vocabulary humans already use to describe work. When agents operate on those same primitives, they're speaking the same language as the people around them. A manager can look at what an agent has done and understand it immediately — not because they've been trained on AI outputs, but because goals, tasks, and milestones are concepts they've used their whole career. The agents aren't operating in a separate system that requires interpretation. They're operating in the same system, using the same vocabulary.

In Clarity Forge, agents work in the same project management space as the humans on the team. They post updates, participate in async discussions, flag risks, and in some cases wait for human review before proceeding. A human can redirect an agent mid-stream with a comment on a task, the same way they'd redirect a colleague. The interface is identical because the underlying structure is identical.

The goal was never to remove humans from the loop. It was to make the loop seamless enough that humans participate at the level of intent and judgement, rather than direction and coordination. The agent handles the execution. The human handles the "is this still the right thing to be doing?"

What an Autonomous Team Actually Looks Like

Here is what it looks like in practice.

An autonomous team — as I mean it — is a group of agents, each with a domain and a set of tools, operating on shared organisational context without a central orchestrator directing them. Each agent reads the current state of work, determines what falls within its domain, acts, and updates the shared work state. Other agents — and humans — read those updates and respond.

What this makes possible: agents that self-prioritise based on goal urgency. Agents that flag risks because they can see the whole project, not just their task. Agents that hand work off because they can see that another agent's output is a dependency, not because anyone told them to. Agents that stop when a human changes the goal, because the goal is shared state and they read it.

What remains unsolved: coordination at decision points where two agents have conflicting reads on priority. Quality assurance — who checks the agent's work, and by what standard? And most fundamentally, the question of who sets the goals. Humans do. That's not changing. The agent team executes. The human leader sets direction, reviews outcomes, and decides what the next goal is.

The analogy I keep returning to is the difference between a manager who tells their team what to do every day, and a leader who sets clear goals and trusts the team to figure out how to reach them. The second model only works if the team genuinely understands the mission — not the tasks, the mission.

Work primitives are how agents understand the mission.

The Open Question

The foundation is right. What gets built on top of it is still being discovered.

The more interesting question — the one worth watching — is what new primitives agents surface as they operate within this structure. Ones that humans don't use, because humans don't need them. Agents might. Each new primitive they surface will tell us something about how machine intelligence organises work differently from human intelligence. That's not a threat to the model. It's the model maturing.

What we should see over time is agent teams that become more coherent as the organisational context becomes richer — not because they've been given better instructions, but because they have better shared understanding of the work. And we should see humans participating at a higher level — setting goals, reviewing outcomes, making judgement calls — rather than routing tasks.

That's the experiment. The world will move at its own pace. The agents will wait.

---

Our mission is to empower organizations by fostering cultures of clarity and transparency, engagement and collaboration. Through innovative tools, best practices and partnership with leaders, we strive to unlock the competitive advantages inherent in healthy organizations.