The Evolution of AI Agents: From Neural Networks and AOP to COAT
AI agents are moving into a new stage.
For a long time, progress in AI has been described in terms of bigger models, longer context windows, better tools, and more capable workflows. These are important, but they do not fully describe what is changing.
As agents become more complex, they need more than intelligence inside a model. They need a way to organize attention, priorities, constraints, goals, risks, memory, and behavior across time.
This is where COAT begins.
COAT means Concern-Oriented Agent Thinking.
It is our attempt to describe a new layer in agent architecture: a concern-level neural software layer.
1. Neural Networks Came From Biology
Neural networks did not begin in computer science.
They began in living systems.
Simple organisms can respond directly to their environment. But as bodies became more complex, direct response was no longer enough. A complex body has muscles, organs, senses, internal states, and many competing needs.
A body needs to move, eat, avoid danger, learn, rest, reproduce, and adapt.
No single cell can coordinate all of this.
So evolution produced the nervous system.
The nervous system separates neural control from biological effectors. Neurons are not ordinary execution cells. They connect, activate, inhibit, coordinate, and learn across the whole body.
In this sense, the nervous system is not just a biological structure. It is a solution to complexity.
It allows a living body to decide what matters now.
2. AOP Came From Software
Software followed a similar path.
Early programs could be organized with procedures and functions. As systems grew, object-oriented programming became the dominant way to manage complexity.
Objects helped us group data and behavior.
But large software systems created another problem.
Some concerns do not belong to one object.
Logging, security, permissions, transactions, caching, monitoring, validation, error handling, and performance control often cut across many objects at once.
These concerns became scattered and tangled throughout code.
AOP emerged to address this problem.
Aspect-Oriented Programming separated cross-cutting concerns from object structures and expressed them as Aspects.
That was the deeper meaning of AOP:
AOP separated Aspects from objects.
It gave software a way to describe where a concern should attach, when it should activate, what behavior it should introduce, and how it should be woven into execution.
3. LLMs Are Powerful, But Agents Need More
Large language models brought neural computation to language, knowledge, reasoning, and generation.
They are powerful because they place intelligence in parameter space.
But an agent is more than a model producing tokens.
An agent uses tools.
It keeps memory.
It follows goals.
It responds to users.
It handles risks.
It respects constraints.
It plans.
It verifies.
It acts over time.
These are not isolated capabilities.
They cut across the whole agent.
A safety concern may affect reasoning, tool use, memory, and final response.
A user preference may affect planning, formatting, and future behavior.
A factuality concern may affect search, citation, verification, and memory writing.
A long-term goal may influence many decisions across many turns.
These concerns cannot simply be placed inside one prompt, one tool, or one skill.
They need their own runtime structure.
4. COAT: Concern-Oriented Agent Thinking
COAT separates concerns from prompts, skills, tools, memory, and workflows.
In COAT, the basic unit is not the prompt.
It is the Concern.
A Concern is something the agent needs to attend to, activate, inject, verify, remember, and evolve.
A COAT runtime organizes these concerns into a living structure:
Concern
→ Activation
→ Advice
→ Weaving
→ Behavior modulation
→ Verification
→ Update
This creates a Deep Concern Network.
In this network:
Concern Nodes act like cognitive neurons.
Concern Relations act like synapses.
Pointcut Matching acts like activation.
Advice acts like neural signal.
Weaving acts like propagation.
Concern Update acts like learning.
Concern Resolver acts like inhibition.
Meta Concerns act like higher-order regulation.
COAT is not a prompt manager.
It is not a skill manager.
COAT is a concern-level nervous system for AI agents.
5. One Evolutionary Pattern
There is a shared pattern across biology, software, and AI agents.
In biology:
Cell → Neuron → Nervous System
In software:
Procedure → Object → Aspect
In AI agents:
Prompt → Skill / Tool / Memory → Concern / COAT
When a system becomes complex enough, local execution units are no longer sufficient.
The system needs a new modulation layer.
In living systems, that layer is the nervous system.
In software systems, that layer is AOP.
In AI agents, that layer is COAT.
6. Why COAT Matters
COAT is not simply AOP applied to agents.
It is closer to reintroducing the core principle of the nervous system into agent software.
ANNs place neurality in weight space.
COAT places neurality in concern space.
ANNs give us parameter-level neural computation.
COAT gives agents concern-level neural cognition.
This matters because future agents will not only need to answer questions. They will need to maintain goals, manage risks, respect boundaries, coordinate tools, preserve memory, and evolve over time.
That requires a structure beyond prompts.
It requires concerns as first-class runtime units.
7. The Core Thesis
Neural networks emerged because biological bodies became complex.
AOP emerged because software systems became complex.
COAT emerges because LLM-powered agents are becoming complex.
COAT is to AI agents what the nervous system is to biological bodies, and what AOP is to complex software systems.
From cells to neurons.
From objects to aspects.
From prompts to concerns.
This is the beginning of COAT.
— MOSS AI