This piece explains how LLM agents could evolve into an independent programming model rather than a mere OOP metaphor. Agent-Oriented Programming (AOP), which has existed since 1993, has become far more practical thanks to LLMs, and the agent programming of the future may take a form that combines OOP, the Actor Model, BDI, ECS, and LLM reasoning. The key point is that whereas objects were passively invoked, agents are autonomous beings that act on their own while holding goals and memories.

1. Agent Programming Beyond the OOP Metaphor

The piece does not treat the view of class → SOUL.md/AGENT.md → instantiate → object as a metaphor that forcibly shoehorns traditional object-oriented programming (OOP) onto AI. On the contrary, it considers this idea quite natural and one that could develop into a new programming model going forward.

In fact, this view is not entirely new. In 1993, Yoav Shoham already published a paper titled Agent-Oriented Programming (AOP), describing it as a specialized form of OOP. Where an ordinary object has state, an agent has more "mental" states like the following:

• beliefs: information it believes; its perception of the world
• decisions: decisions it has made
• capabilities: what it is able to do
• obligations: duties it must carry out

It also treats communication between agents itself as a basic element of programming. In other words, instead of building the world solely out of object fields and methods, the approach aims to build a world of beings, each with its own thoughts and goals, exchanging messages.

However, as elegant as the idea was, it was not easy to implement in practice. The starting point of the piece is that with the arrival of LLMs, a concept from roughly 30 years ago has become a far more realistic model. 🤖

2. Mapping OOP Elements to LLM Agents

The piece explains that the main concepts of OOP map quite naturally onto the world of LLM agents.

For example, even if alice and bob are created from the same Agent Class, as each experiences different events and accumulates different memories, they become different beings over time. This closely resembles how objects created from the same class each have different instance state.

In other words, even when starting from the same blueprint, differences in memory and experience create an agent's individuality.

3. Agents as a Stronger Abstraction Than Objects

But the piece does not stop at equating agents with simple objects. It sees agents as a stronger abstraction than objects.

Traditional objects are fundamentally passive. They act only when a method is called from outside. Agents, by contrast, have their own execution loop: they can observe their surroundings, assess their goals, and decide their next action on their own.

It summarizes this as follows:

Agent = object + autonomy + goals + memory + reasoning + event loop

For this reason, agent-oriented programming is closer to a structure that blends the following elements than to pure OOP:

• OOP: identity, state, encapsulation
• Actor Model: message passing and independent units of execution
• BDI model: Belief, Desire, Intention
• LLM: flexible, natural-language-based reasoning and action selection

In particular, existing agent languages such as AgentSpeak and Jason already used the following flow:

belief → desire → intention → plan → action

An agent forms beliefs about the world through observation and communication, selects some of the things it desires as actual intentions, and then acts by executing plans. Today's LLM agents can also carry out a similar process in a more flexible form.

4. What LLMs Changed: "Describing" Mental States Instead of "Coding" Them

The biggest reason AOP was hard in the past was the question of how to program an agent's mental states and behavioral rules. Developers had to write beliefs, goals, plans, rules, and so on rigorously, one by one, in a formal language.

The concept was powerful, but actual development was complex and cumbersome.

In the LLM era, the situation is different. Simply writing an agent's role, personality, values, goals, and principles of behavior in Markdown or natural-language documents can serve, to some degree, as a behavioral specification. For example, a document like SOUL.md can play a role close to code that defines the agent's identity and behavioral standards.

The piece expresses this difference very sharply:

In old AOP, you had to program an agent's mental states;
in the LLM era, you just describe an agent's mental states.

In other words, instructions written in natural language become not mere documents but something close to an executable behavioral specification. This is the key change by which LLMs have greatly lowered the barriers of traditional agent programming.

5. A Structure Especially Well Suited to Simulations and Games

This model is especially powerful in games and simulations. OOP worked well in games because a game world looks like a collection of actual entities: players, NPCs, monsters, items, buildings.

Likewise, in agent simulations, the world can be defined as a collection of many autonomous beings. For example, if you simulate a startup market, you can make founders, investors, customers, competitors, employees, and so on each a separate agent.

Instead of a central system directly writing all the business rules and outcomes, letting each agent interact based on its own goals, memories, and constraints can give rise to unexpected behavior. This is called emergent behavior. 🌱

The attention drawn by the 2023 Generative Agents research from Stanford and Google is connected to this direction. When LLM agents were given memory, reflection, and planning abilities and allowed to interact in a small village, phenomena emerged such as party invitations spreading and social behaviors following naturally.

In other words, LLM agents can add more natural conversation, situational interpretation, and action-selection abilities to existing agent-based simulations.

6. Distinguishing the Roles of SOUL.md and AGENT.md

The piece points out that a simple mapping of class == SOUL.md can miss an important distinction.

A more appropriate structure is as follows:

• SOUL.md: the agent's identity, values, behavioral tendencies, and basic priorities
• AGENT.md: a document closer to the agent's entire class definition
• Instance state: actual memory, current goals, experiences, environment information, context

That is, SOUL.md describes "what kind of being" the agent is. AGENT.md, on the other hand, becomes a larger definition that covers which tools the agent uses, what inputs it receives, under what constraints it runs, and how it behaves.

Even agents created from the same AGENT.md can display entirely different personalities and behaviors if they have different SOUL.md files, initial contexts, or memories.

7. From Method Calls to Intents and Messages

An agent's "methods" also differ from methods in traditional OOP.

In typical OOP, the caller decides what gets executed. For example, if you call a send_email() method on an object, the object performs the requested action.

An agent, however, even when it receives a request or message from outside, can judge for itself whether to carry out that request as is. Taking into account its own goals, rules, current situation, permissions, risk level, and so on, it can refuse the action or choose a different one.

Therefore, the central abstraction of programming may shift as follows:

From method invocation
to Intent · Message · Event

This is a very big change. Rather than commanding an agent to "execute this action immediately," external systems pass messages along the lines of "there is this request," "this happened," or "please consider this goal." The final decision about what to do then remains inside the agent.

8. Not a Revival of OOP but an Evolution into Active Objects

Rather than simply calling this phenomenon "the revival of OOP," the piece says it is more interesting to see it as OOP taking a step forward in its evolution into the Active Object model.

The core view of traditional OOP was:

Model the world as objects.

By contrast, agent-oriented programming in the LLM era can be expressed as:

Model the world as actors with autonomy.

The important difference here is that whereas an object is just a unit bundling data and functionality, an agent is an actor with agency that sets goals, makes judgments based on memory, reacts to events, and negotiates or cooperates with other beings.

9. Agent Design Heading Toward Composition Rather Than Inheritance

The history of game development also offers hints for agent design. Early games made heavy use of inheritance-based structures, but over time, complex inheritance hierarchies became difficult to manage.

So many game systems moved toward composing components, as in ECS (Entity Component System). That is, instead of designing "this character is a subclass of the warrior class," you attach as many components as needed: movement, attack, inventory, dialogue, AI control, and so on.

Agents, likewise, are more likely to be designed through capability composition than through huge inheritance structures.

For example, a single agent could be composed by combining the following:

• Customer-support skills
• A web search tool
• A code execution tool
• Email access permissions
• Safety policies
• A long-term memory system
• Scheduling capabilities
• Specific domain knowledge
• The personality and values of a specific role

Ultimately, the agent programming of the future may develop as a combination of the following elements:

Object identity from OOP
Composability from ECS
Message passing from the Actor Model
Goals and intentions from BDI
Flexible, fuzzy reasoning from LLMs

10. The Moment new Becomes Special Again

The piece closes with an intriguing observation that the meaning of the new operator may change.

In traditional programming, new Object() is usually an operation that creates an object instance in memory. But in the world of autonomous agents, new Agent() may not be merely creating a single data structure.

It comes closer to bringing into the world a new autonomous being that can remember, judge, set goals, respond to messages, and act on its own.

new may become not simply an operation that allocates memory,
but an operation that brings a new autonomous entity into the world.

Therefore, the initially proposed view of "Class → SOUL.md/AGENT.md → instantiate → Objects" goes beyond a mere metaphor and becomes a useful starting point for designing future agent systems. If OOP modeled the world with objects, agent-oriented programming is now heading toward modeling a society of beings that remember, judge, and act.