Concurrent Modular Agent (CMA)

• Concurrent Modular Agent (CMA) is a framework for autonomous agents that employs asynchronous LLM modules and a shared semantic memory to enable emergent intention.
• It uses language-mediated inter-module messaging and event-driven scheduling to decouple module functions, ensuring real-time, fault-tolerant operations.
• Empirical demonstrations with Plantbot and ALTER3 highlight its efficiency in heterogeneous systems and its grounding in Society of Mind principles.

Searching arXiv for the specified paper and closely related agent-architecture context. Concurrent Modular Agent (CMA) is a framework for autonomous LLM agents in which multiple LLM-based modules operate fully asynchronously while maintaining a coherent and fault-tolerant behavioral loop. The framework combines concurrently executed modules, language-mediated inter-module interaction, and a single shared global state. In the formulation presented in "A Concurrent Modular Agent: Framework for Autonomous LLM Agents," CMA is described as a practical realization of Minsky’s Society of Mind theory, with intention emerging from interactions among autonomous processes rather than being hard-coded into a single centralized controller (Maruyama et al., 26 Aug 2025).

1. Architectural formulation

A CMA agent consists of three logical parts: a set of modules $M=\{M_1,\ldots,M_n\}$, a shared global state $S$, and a message-passing scheduler. Each module is an asynchronous process responsible for one atomic function such as vision, memory summarization, inner dialogue, or motor control. The shared global state is implemented as a high-dimensional vector database, specifically ChromaDB, and stores embeddings of textual records including sensory descriptors, planner outputs, and thoughts. The scheduler is built on an event-driven MQTT broker and routes free-form text messages between modules in a strictly asynchronous, one-to-one fashion (Maruyama et al., 26 Aug 2025).

The formalization introduces $S_t=\{r_1,r_2,\ldots,r_k\}$ as the multiset of records at time $t$, where each record carries embedded vectors and metadata. The scheduler is defined as

$\sigma:\mathcal{T}\to 2^M$

so that, at each event time $t\in\mathcal{T}$, it yields the subset of modules invoked either by a new incoming message or by a periodic wake-up. This representation emphasizes that module activation is event-driven rather than synchronized by a global barrier.

Each module $M_i$ implements four primitives: $\mathrm{sense}(\cdot)$ for interaction with the external world, $\mathrm{read}(S)\to C$ for retrieval from global state, $\mathrm{write}(S,c)\to S'$ for insertion of embedded content, and $S$0 for publication to another module via MQTT. The architecture therefore separates atomic function, memory substrate, and communication substrate, while allowing all three to participate in a single behavioral loop.

A plausible implication is that CMA replaces the conventional centralized orchestrator with a distributed composition of specialized processes coupled through shared semantic memory and free-form linguistic exchange. The paper directly associates this design with difficulties in agent architectures that arise when coordination, reasoning, and recovery are concentrated in one control locus.

2. Concurrency, scheduling, and communication semantics

Modules run in independent asyncio tasks or threads, and there is no global clock or barrier. Interleaving occurs when a module reacts either to an incoming MQTT message or to a timer event, such as a wake-up every 1 second for a summarizer or memory cleaner. The scheduler $S$1 fires a module exactly when one of those conditions is met (Maruyama et al., 26 Aug 2025).

Each message is modeled as

$S$2

where $S$3 is free-form text. Reception is handled implicitly by the scheduler: when $S$4, its $S$5 call returns the queue of all not-yet-delivered messages destined for that module. The paper models message sending as a side effect associated with module execution rather than as a global transactional update.

The logical update of a module proceeds through four steps: reading context from $S$6, optionally consuming incoming messages, performing LLM reasoning as a black-box call that generates new text $S$7, and then writing a new embedded record to $S$8 and/or sending messages to other modules. This is summarized as a state transition

$S$9

where $S_t=\{r_1,r_2,\ldots,r_k\}$0 is the union of incoming messages and retrievals. In this representation, $S_t=\{r_1,r_2,\ldots,r_k\}$1 encapsulates LLM inference and vector-store writes.

Fault tolerance follows from full decoupling. The crash or hang of one module does not block any other module. A special Meta-System Report module $S_t=\{r_1,r_2,\ldots,r_k\}$2 monitors heartbeats, where

$S_t=\{r_1,r_2,\ldots,r_k\}$3

if a module produced at least one record or message in the interval $S_t=\{r_1,r_2,\ldots,r_k\}$4, and $S_t=\{r_1,r_2,\ldots,r_k\}$5 otherwise. If $S_t=\{r_1,r_2,\ldots,r_k\}$6 for a grace period $S_t=\{r_1,r_2,\ldots,r_k\}$7, $S_t=\{r_1,r_2,\ldots,r_k\}$8 emits a recovery request $S_t=\{r_1,r_2,\ldots,r_k\}$9, and a Watchdog component restarts the module. Formally, if $t$0, then

$t$1

This makes fault recovery part of the architecture rather than an external operational add-on.

3. Emergent intention and the behavioral loop

Inside each module, reasoning is offloaded to a LLM. As modules read from $t$2, generate text $t$3, and write back into the shared state, the framework describes a web of textual thoughts and drives from which a global intention emerges. The paper formalizes intention at time $t$4 as

$t$5

where, in practice, $t$6 is another LLM prompt such as the Thinking module that ingests recent messages together with the semantic vector store (Maruyama et al., 26 Aug 2025).

This formulation makes intention an emergent property of language-mediated interaction rather than a predefined control variable. The paper’s ALTER3 example illustrates this with inner-dialogue modules $t$7, $t$8, and $t$9, which exchange pessimistic and optimistic lines that are stored in $\sigma:\mathcal{T}\to 2^M$0. The subsequent Autobiographical Memory module then weaves those lines into a coherent self-narrative. The quoted example, “My name is ALTER3 … When Magi B suggested juggling flaming torches, I calculated the risk …”, is presented as an outcome of this synthesis rather than a fixed script.

The high-level asynchronous loop for each module is specified procedurally. A module waits until the scheduler includes it, reads incoming messages from MQTT, queries ChromaDB for context, calls the LLM with a module-specific prompt and the retrieved context, writes the generated text back into global state, optionally sends messages to other modules, and then yields with a small randomized sleep to avoid lock-step execution. This loop operationalizes the paper’s central claim that coherent behavior can be maintained without synchronous coordination.

Because all modules write into a single shared $\sigma:\mathcal{T}\to 2^M$1 asynchronously, entries interleave in real time. For actuator commands, the paper formalizes conflict resolution by considering the set $\sigma:\mathcal{T}\to 2^M$2 of motor-command records in a recent $\sigma:\mathcal{T}\to 2^M$3 window, each with a module-assigned priority $\sigma:\mathcal{T}\to 2^M$4. The chosen command is

$\sigma:\mathcal{T}\to 2^M$5

and the Action module executes $\sigma:\mathcal{T}\to 2^M$6 while lower-priority commands are ignored. This is one of the few places where global arbitration is made explicit.

4. Demonstration systems and reported evaluation

The paper demonstrates CMA through two use-case studies: Plantbot and ALTER3. Plantbot is described as a hybrid lifeform setup combining a camera, microphone, soil sensor, living plant, and mobile base. It uses 12 modules, including Vision Interpreter, Audio Interpreter, Soil Sensor Interpreter, Action, Motor Control, Chat, Thinking, and Memory Manager. All data are stored in ChromaDB and messages are exchanged via MQTT (Maruyama et al., 26 Aug 2025).

For Plantbot, the reported observations are that the shared-memory design simplified development, the removal of a custom central aggregator reduced code by approximately 40%, system latency from sensor input to Chat response was typically below 500 ms with LLM API and DB each below 200 ms, and the plant’s soil-dryness data triggered adaptive watering suggestions with no manual heuristics, purely via a soil interpreter prompt. These points are presented as evidence of viability in a heterogeneous embodied setting.

ALTER3 is a humanoid robot configuration with 20 modules organized over three layers: Hardware, Base, and Meta. The reported experiment ran for 14 hours in public at Venice Biennale Architecture 2025. Quantitative outputs include approximately 750 total module outputs over 14 hours, corresponding to about 54 per hour; inner-dialogue modules Magi A/B/C produced about 60% of self-narrative tokens; Autobiographical Memory updated every 5 minutes by summarizing the last 20 memories; and the system achieved 14 hours of uptime with zero manual restarts, while one module was automatically recovered mid-run. A module activity timeline is said to show asynchronous bursts when visitors approached and long idle self-improvement periods.

The reported summary metrics are:

Metric	Plantbot	ALTER3
# Modules	12	20
Mean responses/hour	200	54
Avg. round-trip latency	450 ms	380 ms
Uptime without manual restart	6 h demo	14 h

These results are descriptive rather than benchmark-comparative. A plausible implication is that the paper’s evaluation is intended to establish operational coherence, asynchronous coordination, and recovery behavior in situated systems, not to optimize against a standardized agent benchmark.

5. Relation to Society of Mind and modular AI traditions

The framework is explicitly positioned as a practical, LLM-based instantiation of Minsky’s Society of Mind. In that mapping, each LLM-prompt-driven module $\sigma:\mathcal{T}\to 2^M$7 is treated as analogous to a Minsky-agent such as a perception agent, planning agent, or self-monitoring agent; the shared vector store $\sigma:\mathcal{T}\to 2^M$8 plays the role of a blackboard or memory; asynchronous message passing echoes lateral communications and inhibitory hierarchies; and meta-modules such as Meta Report and Prompt Modifier correspond to goal-setting and self-monitoring layers (Maruyama et al., 26 Aug 2025).

This placement matters because the paper does not define intelligence as the property of an individual monolithic model. Instead, it treats coherent behavior as the aggregate result of multiple small, specialized processes whose interactions are mediated linguistically. The claim that “no single module ‘knows everything,’ but their linguistic interactions yield coherent, emergent intelligence” is central to the conceptual framing.

The paper also notes Brooks’ subsumption in the discussion of lateral communications and inhibitory hierarchies. Within the limits of the provided account, this suggests a lineage that connects CMA to modular and layered control systems, while substituting free-form natural-language exchange and vector-store memory for the more rigid interfaces found in earlier architectures.

A common misconception would be to interpret this analogy as a claim that CMA reproduces Minsky’s theory in full. The paper instead presents CMA as a practical realization or instantiation, which is a narrower claim: it proposes an implementable agent framework that mirrors selected Society of Mind principles through asynchronous modules, shared memory, and meta-level monitoring.

6. Implementation stack, operational mechanics, and interpretive limits

The implementation stack reported in Appendix D consists of OpenAI GPT-4 and deepseek-chat as LLM backends, MQTT via Mosquitto for communication, ChromaDB as the vector database, Python asyncio with threading wrappers for concurrency, and per-module JSONL logs with ISO timestamps for logging (Maruyama et al., 26 Aug 2025). A code excerpt included in the description illustrates a Vision Interpreter module that periodically acquires an image, calls an LLM with the prompt “Describe the scene in one concise sentence,” writes the resulting text embedding into ChromaDB, and optionally publishes a notification to the Thinking module over MQTT.

The source code is reported as publicly available at https://github.com/AlternativeMachine/concurrent-modular-agent. In operational terms, this aligns the framework with commodity software components rather than custom distributed-systems infrastructure. A plausible implication is that reproducibility and extension depend as much on prompt engineering and module design as on the concurrency substrate itself.

The paper closes by stating that the emergent properties observed in the system suggest that complex cognitive phenomena like self-awareness may arise from the organized interaction of simpler processes. This is presented as a suggestion rather than a proof. The distinction is important: the evidence described consists of coherent self-narrative, asynchronous coordination, and fault-tolerant operation in the Plantbot and ALTER3 demonstrations, not a formal test of self-awareness.

Accordingly, CMA is best understood as an architectural proposal with two empirical demonstrations. Its principal contribution is the combination of fully asynchronous multitasking, language-mediated module interaction, and shared semantic memory within an LLM-powered agent architecture. The broader claim about self-awareness is framed as an avenue for research rather than an established result.