A year or two ago, the dominant vision of agentic AI looked remarkably like an organisation chart.

There would be a research agent, a planning agent, a writing agent, a finance agent, a customer service agent and perhaps a supervisor agent sitting above them all.

A request would arrive, an orchestrator would determine which specialist should handle it, and agents might hand work backwards and forwards until the task was complete.

It was an intuitive architecture. After all, that is how human organisations work.

Increasingly, however, AI systems are evolving towards something both simpler and, arguably, more powerful:

One capable agent that acquires the skills, tools and procedural knowledge it needs on demand.

This is more than a change in terminology. It may represent an important correction in how we think about agentic systems.

The original multi-agent idea

Early agent architectures were heavily influenced by the idea of specialization.

Instead of expecting one language model to do everything, we created narrowly configured agents.

A customer service system might contain:

• a returns agent
• a warranty agent
• a product information agent
• a troubleshooting agent
• an order-status agent

Each could have its own prompt, tools, knowledge sources and rules. A supervisor or triage agent would decide which one should receive a particular request.

The pattern remains very much alive. OpenAI's Agents SDK, for example, supports both handoffs between agents and a manager pattern where one agent calls specialist agents as tools.

But something important has changed underneath the architecture.

The models themselves have become much more capable. At the same time, the mechanisms available for dynamically extending those models have become much better.

Enter the skill

The emerging concept of an Agent Skill is deceptively simple.

Instead of creating another autonomous agent, we package the instructions, resources, scripts and procedures required to perform a particular type of work.

The main agent discovers and loads that skill when the task requires it.

Anthropic describes Agent Skills as organised collections of instructions, scripts and resources that give a general-purpose agent specialised capabilities. It has explicitly positioned this approach as an alternative to creating fragmented custom agents for every use case.

OpenAI similarly describes Skills as reusable workflows containing instructions and supporting resources that ChatGPT can apply when appropriate.

Microsoft's Agent Framework describes skills as portable packages of domain expertise that can be loaded using "progressive disclosure", giving an agent the context it needs only when it needs it.

We have adopted the same principle in Zeaware Avalon, where skills provide reusable capabilities that can be made available to Avalon agents alongside tools, knowledge and other agent configuration.

Across quite different platforms, the architectural direction is remarkably similar.

That looks like a small difference. Architecturally, it isn't.

A skill is not just a smaller agent

At first glance, the distinction between a specialist agent and a skill can seem semantic.

A "contract review agent" and a "contract review skill" might contain almost identical instructions. But they have very different operating models.

An agent normally has some combination of identity, instructions, context, reasoning state, tools and an execution loop.

A skill is closer to a capability.

When performing this type of task, follow this procedure, use these resources, run these scripts and produce the result in this format.

The original agent remains responsible for the overall task.

That means we don't necessarily need to create a new reasoning entity simply because some specialist knowledge is required.

It is analogous to the difference between hiring another employee and teaching an existing employee a new procedure.

This distinction has influenced how we think about Avalon agents as well. A capability such as generating a particular document, interrogating a particular system or following an organisation-specific process does not automatically justify another agent. In many cases, it is better represented as a skill available to the existing agent.

Why this architecture is becoming practical now

Models are becoming better generalists

The first reason is simply model capability.

Modern models are increasingly good enough to operate across very different domains while maintaining a coherent understanding of the user's broader objective.

The value of specialization therefore increasingly comes from giving the model the correct context, procedures and tools, rather than requiring an entirely different model instance.

Context can be loaded dynamically

A general agent does not need every instruction for every possible task permanently occupying its context.

Skills can be discovered and loaded when required.

This progressive-disclosure model is important because otherwise a "universal agent" eventually acquires an enormous system prompt containing hundreds of unrelated procedures.

Skills allow specialization without that prompt explosion.

This is an important characteristic of the skill approaches now appearing across Anthropic, Microsoft and platforms such as Zeaware Avalon. An agent can have access to a much broader catalogue of capabilities than it needs to load for any individual task.

Tools are becoming discoverable

The same change is happening with tools.

Rather than exposing hundreds of APIs simultaneously, agent platforms are introducing mechanisms for discovering relevant tools and capabilities at runtime.

The emerging architecture therefore starts to look less like an organisation chart and more like an operating system:

The intelligence remains relatively general. Capabilities are loaded as required.

This may actually be more agentic

There is an interesting irony here.

Reducing the number of agents might initially sound like moving away from agentic AI.

I think the opposite is true.

We may simply have confused agentic with multi-agent.

An agent that can:

Understand the objective → Plan the work → Discover relevant skills → Select appropriate tools → Execute actions → Observe results → Correct mistakes → Continue until complete.

That is extremely agentic.

In fact, it may be more agentic than a rigid workflow passing messages between five narrowly prompted agents.

Agenticity is about autonomy and goal-directed behaviour. It isn't a count of how many agents appear on an architecture diagram.

Why fewer agents can be better

There are practical advantages as well.

Every additional agent introduces another reasoning boundary. Information has to be transferred between them. Context may need to be summarised. Instructions can conflict.

Observability becomes harder. Latency and costs can increase.

Evaluation also becomes more complicated because failures may result from the originating agent, the routing decision, the receiving agent, the information passed between them or their interpretation of each other's output.

A single coordinating agent avoids many of these problems.

It maintains a continuous understanding of the user's objective while bringing specialist capabilities into that context when required.

This is one reason we increasingly see skills, tools and reusable capabilities becoming first-class concepts across platforms such as OpenAI, Anthropic, Microsoft and Zeaware Avalon, rather than assuming that every specialization requires another autonomous agent.

There is also a user-experience advantage.

People generally don't care which internal specialist is handling their request. They want the system to understand the problem and solve it.

The "one front door" agent increasingly makes sense both technically and experientially.

So are specialist agents going away?

No.

This is where the distinction becomes important.

Skills are likely to eliminate many artificial agent boundaries, not genuine ones.

There are situations where another agent represents a real architectural boundary.

Consider a complex research task. One agent may need to investigate several independent hypotheses simultaneously. Parallel subagents can substantially accelerate that work.

Or imagine an investment process where one agent develops a proposal while another independently challenges its assumptions.

Those aren't simply two collections of instructions. The independence itself has value.

There are several good reasons to introduce another agent:

• Parallelism. Independent work can happen simultaneously.
• Different context. A specialist may require a substantial working context that the parent agent doesn't need.
• Different models. Different tasks may benefit from different model capabilities, costs or performance characteristics.
• Security boundaries. Different agents may require different permissions and access to data or tools.
• Independent verification. A separate reasoning process can challenge or validate the work of another agent.
• Long-running delegation. A substantial piece of work can be delegated while the parent agent continues with something else.

Multi-agent systems may return, but differently

I don't think the current shift towards skills means the multi-agent idea was wrong.

It means we may have introduced agents at the wrong level of abstraction.

In the first generation, we often started with:

What agents should this application have?

The better starting question may now be:

What capabilities does the agent need?

Most of those capabilities become skills, tools, knowledge sources or deterministic workflows.

Only then should we ask:

Which parts genuinely require another independent agent?

That produces a much cleaner architecture.

A future enterprise agent might have fifty skills, hundreds of tools and only three or four situations where it creates or delegates to another agent.

Importantly, those subagents may not be permanent named entities at all.

They could be created dynamically to investigate a particular problem, given a tightly scoped context and objective, produce their result and disappear.

The multi-agent architecture therefore doesn't disappear. It moves up the complexity curve.

It becomes something the system invokes when independent reasoning is valuable rather than the default mechanism for representing specialization.

From agent networks to capability platforms

This has broader implications for enterprise AI architecture.

The strategic asset may not ultimately be a catalogue containing hundreds of agents.

It may be a catalogue of capabilities.

Organisations could maintain approved skills, tools, workflows, knowledge sources and policies that capable agents assemble dynamically according to the task.

One skill might describe how the organisation performs a risk assessment. Another might encode the process for preparing a customer proposal. Another could understand how to interrogate a particular data platform. Another could generate a regulatory document according to an approved template.

Rather than duplicating those capabilities across dozens of agents, they become reusable organisational building blocks.

This is particularly interesting for enterprise platforms such as Avalon. A skill can encapsulate not simply knowledge about a subject, but how the organisation expects a particular task to be performed, including procedures, tools, rules and expected outputs, while remaining reusable by agents that need that capability.

That starts to make the organisational skill library potentially as important as the agent catalogue itself.

A major change disguised as simplification

So is this a minor implementation change or a major shift?

I think it is significant.

Not because skills themselves are revolutionary. Instructions, scripts and tools have existed since the earliest agent frameworks.

The important change is where we place the abstraction boundary.

We originally modelled specialization primarily as another agent.

We are increasingly modelling specialization as a capability that an agent can acquire.

That is a fundamentally cleaner separation.

• The agent provides reasoning, context and agency.
• Skills provide expertise and procedures.
• Tools provide action.
• Workflows provide determinism.
• Other agents provide independent agency when independent agency is actually required.

That may turn out to be the more durable architecture.

And somewhat paradoxically, the future of agentic AI may therefore contain far fewer agents than we originally expected, while those agents themselves become dramatically more agentic.