Is every layer in the ACE framework a LLM?

[RikiReal]

Hi, I'm delving into the ACE framework and have watched the introduction video, but I still have a couple of points that are unclear.

Firstly, in the ACE framework, is each layer functioning as a separate session with a Large Language Model (LLM), or does the LLM play a part across the entire framework? To illustrate, I'm wondering if there's more to each layer than just 'LLM Input' and 'Bus Output'. Could you provide some examples?

Secondly, regarding the memory capabilities of the agent model in ACE, how is consistent mission adherence ensured? For instance, how does the framework prevent an agent from deviating from its assigned mission over time?

I'm planning to read the paper for a deeper understanding, but any insights or explanations would be greatly appreciated.

[RikiReal]

Ping!
Does my question make sense or is it unclear?

I started reading the paper and I'm hoping it will make things clearer, but I would also appreciate if someone could offer additional insights.

[sulismies]

Hi RikiReal,

your question is really relevant indeed for one to get started : )
I am a beginnner and these are my first thoughts after quick look at the hello-layers demo:

Firstly, in the ACE framework, is each layer functioning as a separate session with a Large Language Model (LLM), or does the LLM play a part across the entire framework?
My short opinion: Layer sessions are separate LLM sessions that carry out specific functions, but the LLM prompts can include information from messages going up/down in the the layer stack
To me it appears that each layer from ACE\CORE_DEMOS\hello-layers\src\ace\framework\resources connects one layer up and one one layer down (layer stack) using special message templating system built using rabbitMQ which in turn is an open-source message broker software (message-oriented middleware). At the hart of each layer is an connection to LLM, in this case is openai.ChatCompletion.create(model="gpt-3.5-turbo" ). I would say that the core action of each layer is a call to LLM with the prompt in llm_messages variable. The calls are separate (one LLM does not see or control the whole stack of layers) but prompt llm_messages can contain info in a template format from the messages sent\received from layer above\below. Messages flow in the following format.
CREATE_REQUEST: Request more information,
ADD_TO_CONTEXT: Do nothing, but store these messages in memory,
TAKE_ACTION: Communicate a message to the next layer on the bus.
ADD_TO_CONTEXT seems to work as the overall memory or possibly kind of "state" of the system.

How is consistent mission adherence ensured?
My short opinion: mission adherence is not ensured.
In the paper authors state that ACE is inspired by Lawrence Kohlberg’s theory of moral development and they claim that "by making cognition the core engine, ACE frameworks foster capabilities leading to artificial general intelligence." The authors' idea is novel but the idea itself somewhat complicates answering to your fundamental question. According to my understanding authors aim at creating a framework for artificial general intelligence (AGI) based on LLMs (AI) connected through a layered messaging stack. I do not see any built in guardrails (other than those possibly built in the LLMs) or any cost function that would indicate how close the ACE is achieving its goal.

I made some test runs using the hello-layers demo. It works as advertized. My main learning points were in creating an interconnected network of virtual machines using Docker and rabbitMQ which I found quite cool. In my opinion the layered approach to AGI is quite novel and it seems to have some distant similarities to OSI model. At this stage I am not sure if it really is the way to AGI or if it is just an unnecessary complication. One might consider also just one powerful enough LLM connected to different lower level interfaces that make things happen in the real world. I may have completely missed the point, but these are my first thoughts on this one.

[thehunmonkgroup]

As one of the primary authors of the original hello-layers demo, let me add a few pieces here:

1. I'd recommend looking at the newer demo here: https://github.com/daveshap/ACE_Framework/tree/main/ACE_PRIME/HelloAF -- while it is largely similar to the original demo, it has a critical new feature pertinent to your questions: the logic for each layer is now essentially 'pluggable'. This means with the instantiation of one new class for each layer, you can easily implement your own layer logic, while still getting all of the support that the demo offers (logging, bus setup/communication, debugger, etc.)
2. I actually think the base perspective you're coming from is off, and so you're not asking the right questions ;) Namely, ACE is a conceptual framework for an autonomous cognitive entity -- the individual layers and busses can be implemented in any way that conforms to the framework. Theoretically, you could implement each layer by emailing a task to a TaskRabbit, and deliver messages on the bus by carrier pigeon. That would be an incredibly dumb way to do it, but you could :)

I'm pointing these things out because I believe what ACE really needs is people thinking creatively about how to implement the layers of intelligence and the inter-layer communication, and not be too hung up on the work that's already been done.

A layer might best have one model, or many. It might have elements of agentic behavior itself, or not. Messages on the bus may be best restricted to adjacent layers, or not. As it stands, these are unanswered questions, and I would love to see people trying novel approaches and reporting back on their successes and failures!