TLDR: The Concurrent Modular Agent (CMA) is a novel framework for autonomous LLM agents that orchestrates multiple, asynchronously operating LLM-based modules. It fosters flexible, adaptive, and fault-tolerant behavior through language-mediated interactions, a shared global state (ChromaDB), and asynchronous message passing (MQTT). Demonstrated on a Plantbot and the humanoid robot ALTER3, CMA showcases how complex cognitive phenomena, including self-awareness and adaptive behavior, can emerge from the organized interaction of distributed, simpler processes, aligning with Minsky’s Society of Mind theory.
A groundbreaking new framework called the Concurrent Modular Agent (CMA) is set to transform how we build autonomous AI systems. Unlike most current AI, which operates in a largely synchronous and isolated manner, CMA introduces a system where multiple Large Language Model (LLM)-based modules work completely independently and at their own pace, yet still manage to create a cohesive and robust intelligent agent.
This innovative approach tackles long-standing challenges in AI architecture by allowing complex intentions and behaviors to emerge from natural language interactions between these autonomous processes. Imagine an animal that can simultaneously monitor its surroundings for danger, eat, and plan its next move – CMA aims to replicate this kind of flexible, adaptive, and context-dependent behavior in AI. It achieves this through a combination of concurrently executing modules that offload reasoning to an LLM, inter-module communication, and a single shared global state. The creators consider this a practical realization of Marvin Minsky’s “Society of Mind” theory, where intelligence arises from the organized interaction of many simpler processes.
How the Concurrent Modular Agent Works
The CMA framework is built on three core components:
- Functional Modules: Each module is an independent, asynchronous Python function designed for a specific subtask, such as perception, memory, planning, or action execution. These modules don’t share internal states but coordinate through shared memory and message passing. They can interact with the external world (e.g., receive visual or audio input), retrieve and store information in the global state, and send messages to other modules.
- Shared Global State: To provide long-term memory and facilitate knowledge sharing among modules, textual messages are converted into vector representations and stored in a shared vector database. The framework uses ChromaDB, an open-source vector store, allowing all modules to asynchronously store and retrieve information. This enables modules to reason based on both their own generated context and external information. Running ChromaDB in a Docker container with HTTP access also means modules can be executed on separate hosts, enhancing scalability.
- Inter-Module Communication: Modules can send text messages to each other at any time. Upon receiving a message, a module can dynamically change its behavior, such as starting or stopping execution, triggering specific functions, or modifying its internal processes. This asynchronous message-passing mechanism is implemented using MQTT, a lightweight publish/subscribe protocol, further boosting the framework’s scalability and allowing modules to operate independently of their host environment.
Real-World Applications: Plantbot and ALTER3
The viability of the CMA system has been demonstrated through two compelling use-case studies:
1. Plantbot: A Hybrid Lifeform
Plantbot is a unique hybrid lifeform that connects a living plant with a mobile robot through a network of LLM-based modules. In its updated CMA implementation, the previous centralized communication hub and per-module memory were replaced with a shared vector store. Now, modules like the Vision Interpreter, Audio Interpreter, Soil Sensor Interpreter, Action, Chat, Thinking, and Memory Manager all independently read from and write to this shared memory. This shift from centralized coordination to memory-based interaction significantly improves modularity, scalability, and system resilience, allowing robotic, biological, and conversational modules to collaborate seamlessly.
2. Humanoid Robot ALTER3
The CMA architecture was also implemented on ALTER3, a sophisticated humanoid robot featuring over 20 concurrently operating modules. Designed in the spirit of Minsky’s Society of Mind, ALTER3’s system is organized into three hierarchical layers: the Hardware System (basic processing), the Base System (LLM-powered modules for functions like summarization, desire, inner dialogue, and memory cleaning), and the Meta System (modules that monitor the overall system state, generate autobiographical memories, and dynamically modify prompts). This setup allows for the emergence of higher-order behaviors, including self-description and contextual coherence. For instance, ALTER3 gradually establishes its self-identity through conversations and experiences, with its autobiographical memory continuously updated by module outputs and human interactions. The system even includes ‘Magi’ modules for internal dialogues and a ‘Prompt Modifier’ to dynamically alter system prompts, enabling open-ended evolution and adaptive behavior.
Also Read:
- Navigating the Landscape of AI Agents: Methods and Real-World Applications
- Bridging Language and Spatial Reasoning: A New Framework for Multi-Agent Path Finding
Emergent Intelligence and Future Directions
The emergent properties observed in CMA systems, particularly with ALTER3, suggest that complex cognitive phenomena like self-awareness can indeed arise from the organized interaction of simpler processes. This supports the Minsky-Society of Mind concept and opens new avenues for artificial intelligence research. The framework demonstrates how general-purpose, language-based AI components, when embedded in a structure-oriented, physically instantiated framework, can exhibit properties traditionally associated with life: self-regulation, identity formation, and context-sensitive decision-making.
This work aligns with David Ackley’s concept of indefinitely scalable computing and Paulien Hogeweg’s structure-oriented modeling, emphasizing local, asynchronous interactions over global synchrony. The source code for this work is publicly available for further exploration. For more details, you can read the full research paper here.
