Playtime is Over, Hail to Akgents! Why AI Agents Should Evolve into AI Actors!

The intrinsic limitations of agent based systems

In recent months, AI Agents have emerged as the standard for developing advanced systems powered by “reasoning” AI engines like LLMs. These agent-based systems have shown significant value in addressing the limitations of monolithic AI systems, such as constraints on model size and performance stemming from insufficient high-quality training data. While experts have long recognized these challenges, they have only recently gained broader attention. As a result, we anticipate a surge of interest in agent-based approaches in the coming months.

Several frameworks have emerged to build agentic systems, including popular general-purpose ones like LangGraph and more specialized ones like MetaGPT. At B12 Consulting, we’ve already used these tools to develop solutions to real-world challenges. This hands-on experience has highlighted the advantages of agent-based approaches over traditional monolithic methods, particularly for complex applications like evolved RAG systems. However, we’ve also identified severe shortcomings shared by most existing frameworks along the way:

1. Static Agent Graphs: The architecture governing which agents can interact, how they do so, and under what conditions is typically rigid, offering little to no flexibility for runtime adjustments. This rigidity hinders the natural emergence of intelligent behavior through dynamic interactions, preventing the system from achieving intelligence that exceeds the combined capabilities of its individual components.
2. Blocking by Human Input Dependencies: Human input is often necessary for supervision (e.g., validating actions) or providing missing context, yet it operates at different time scales than most digital processes. In many frameworks (e.g., LangGraph), the need for human input tends to block the entire system, causing agents to idle while waiting.
3. Global State Bottlenecks: Many frameworks use a global state shared among all agents. While this may seem beneficial, it limits scalability due to context noise (irrelevant data cluttering the system) and concurrency issues (conflicting access to shared data).

Rethinking Multi-Agent Architecture with Inspiration from Scalable Systems

As AI specialists but also experienced software engineers, we’ve explored solutions to these challenges by drawing inspiration from established paradigms for building scalable systems. For instance, our prior work with Scala and frameworks like Akka has shown the power of immutability and reactive, message-driven architectures.

We believe the fundamental architecture of multi-agent systems should adopt principles found in highly scalable architectures, specifically the actor model.

The actor model (originating in 1973!) is a mathematical framework for concurrent computation. It defines actors as independent entities capable of [1]:

• Making local decisions.
• Creating other actors.
• Sending messages.
• Modifying their private state.

Actors communicate exclusively through messaging, ensuring loose coupling and enabling massive scalability.

Enter the “Akgent”: A Scalable AI Actor

We’ve coined the term Akgent to describe the foundational unit of a multi-agent system aligned with the actor model. An akgent is a computational entity with reasoning capabilities (often powered by LLMs) that processes messages through Aktions, i.e., internal methods triggered by message types. Akgents can:

• Send messages to other akgents.
• Create new akgents.
• Modify their internal state to adjust behavior for future messages.

In an akgent, an LLM, possibly augmented with tools (or even an entire graph of classical agents), interprets messages and decides which actions to perform based on the akgent internal state and the message content. But unlike traditional actor based architectures, this decision is probabilistic and non-deterministic.

Initial Implementation and Key Advantages

We’ve developed a prototype of this architecture in Python using tools like Langchain (to abstract LLM dependencies) and Pykka (a simple implementation of the actor model). We’re also considering scaling up using industry-standard frameworks like Akka. Relying on well established actor frameworks such as Akka also allows us to leverage advanced features such as rejection or deferral of new messages in cases of computing resource limitations, and notifications of upstream actors or systems to adjust the rate of message production.

Even in its early stages, our approach has demonstrated feasibility and several key advantages:

1. Dynamic Agent Graphs: In an akgentic system, relationships between agents are created and modified dynamically, based on the reasoning engine’s conclusions. Agents can be provisioned or decommissioned on demand, ensuring resilience and scalability.
2. Asynchronous Human Interaction: Human input is seamlessly integrated as messages to akgents, enabling asynchronous processing without halting other agents. Humans can even be modeled as intelligent akgents, enabling collaborative systems where human roles are gradually replaced by AI counterparts.
3. No Global State: Akgents communicate exclusively through message passing, avoiding global state bottlenecks. This ensures scalability, as agents can operate on distributed systems. A shared environment (modeled as an akgent itself) facilitates resource access, tool management (e.g., access to a Git repository), and agents registration (w/wo on-boarding).

Real-World Applications and Future Plans

The possibilities are nearly endless. We’ve already demonstrated the practical value of this approach by tackling real-world problems, such as agentic code migrations. Here, akgents represent team roles (e.g., analysts, developers, reviewers), and the system can dynamically scale the number of akgents of a certain role (e.g., “developers”) based on demand! This flexibility could enable unprecedented scalability.

Another example is collaborative document drafting, where human agents and akgents can take on roles of managers, writers, verifiers and domain experts and work together to bring to realization anything from business contracts to legislation drafts.

More generally, akgentic systems could allow us to build digital twins of organizations, so we can study how to make them more resilient, sustainable and scalable.

Our next step is to release our first implementation as an Open Source project with proper examples, paving the way for others to explore and contribute to the development of the approach.

Join the Conversation

If you have any questions, ideas, or feedback, we’d love to hear from you. Stay tuned for more updates as we continue refining and expanding the akgent paradigm.

[1] Carl Hewitt; Peter Bishop; Richard Steiger (1973). "A Universal Modular Actor Formalism for Artificial Intelligence"