The tech press has officially run out of ideas.
Every time a modern AI startup drops a new framework for "multi-agent orchestration," the retro-futurists emerge from the woodwork. They dust off their copies of Marvin Minsky’s 1985 classic, The Society of Mind, and declare him the long-lost prophet of the generative AI boom. They write glowing profiles claiming Minsky predicted Anthropic's Claude Projects or OpenAI’s Swarm framework nearly forty years ago.
It is a comforting narrative. It is also completely wrong.
By equating Minsky’s "agents" with today’s Large Language Model (LLM) wrappers, the tech industry is not celebrating his legacy. It is misunderstanding his core thesis. Today’s multi-agent systems are a clumsy, brute-force caricature of the elegant cognitive architecture Minsky actually proposed.
If you are building your enterprise AI strategy on the assumption that today’s agentic workflows are the realization of Minsky’s dream, you are setting millions of dollars on fire. Here is the uncomfortable truth about why the current multi-agent hype is a dead end—and what Minsky actually wanted us to build.
The Lazy Consensus: Today's Agents Are Not What Minsky Built
The prevailing industry narrative goes like this: Minsky argued that intelligence is not a single, centralized mechanism but a collective of smaller, mindless processes called "agents." Therefore, when you link three different instances of GPT-4 in a chain—one acting as a researcher, one as a writer, and one as an editor—you have built a "Society of Mind."
This is a category error of massive proportions.
To understand why, we have to look at the scale and nature of the components.
In Minsky's model, individual agents are sub-symbolic, mindless, and hyper-specialized. They are incredibly simple. One agent does nothing but detect a vertical line. Another does nothing but move a finger. They do not possess language. They do not "reason" on their own. Intelligence emerges solely from the complex, hierarchical interaction of these dumb components.
Compare this to a modern multi-agent system:
- The "Agents" are massive: Every agent in a modern workflow is a multi-billion parameter LLM.
- They are not mindless: Each individual agent contains the entire sum of human knowledge encoded in its weights.
- The communication is bloated: Instead of fast, hardwired neurological signals, today's agents communicate via massive blocks of English text (natural language prompts).
Calling three LLMs talking to each other a "Society of Mind" is like calling a committee of three fully formed human bureaucrats a "neural network." It is a massive, computationally expensive waste of resources.
The Ruinous Cost of Text-Based Oratorical Agents
I have watched enterprise tech teams spend six months building "agentic swarms" to automate basic customer support or data retrieval pipelines.
They set up an "Agentic Planner" that writes a task list, hands it to an "API Agent," which queries a database, passes the raw JSON to a "Summary Agent," which then hands it to a "Politeness Agent" to draft the final email.
Here is what actually happens in production:
- The Latency Nightmare: Because these agents communicate in natural language, they have to generate thousands of tokens just to pass a simple state change. Your simple database query now takes 45 seconds to complete.
- Cascading Hallucinations: If Agent A makes a minor semantic error in its output, Agent B interprets that error literally, compounding the mistake. By the time the output reaches Agent D, the system is hallucinating entirely new realities.
- Astronomical API Bills: You are paying for input and output tokens across four different LLM calls for a task that could have been solved with a single, well-structured Python script and some basic heuristics.
We are using the most expensive, computationally heavy tool in human history—generative text models—to perform basic routing and logic gates.
Minsky’s agents were designed to be incredibly cheap. Today's agents are incredibly expensive.
What the "Experts" Get Wrong About Symbolic AI
The tech industry loves a clean, linear narrative. The current story is that symbolic AI (Good Old-Fashioned AI, or GOFAI) failed, connectionism (neural networks) won, and now we are just scaling neural nets to reach Artificial General Intelligence (AGI).
But Minsky, despite being a founding father of the MIT AI Lab, was deeply skeptical of pure connectionism. He famously co-authored the book Perceptrons in 1969, which mathematically demonstrated the limitations of single-layer neural networks—a blow that initiated the first "AI Winter."
Minsky's ultimate vision, which he expanded upon in his 2006 book The Emotion Machine, was a hybrid system. He argued that true intelligence requires multiple ways of thinking:
- Case-based reasoning: Drawing on specific past experiences.
- Rule-based reasoning: Applying formal logic and heuristics.
- Analogical reasoning: Finding similarities between different domains.
Today’s generative AI models do only one thing: statistical next-token prediction. They do not have a mechanism for rule-based verification or structured memory representation. When an LLM "reasons," it is actually just mimicking the linguistic patterns of human reasoning found in its training data.
By calling these models "agents," we trick ourselves into believing they possess the structural agency Minsky described. They do not. They are statistical mirrors.
The Thought Experiment: The Block-Building Child
Let’s look at Minsky's famous "Play Ball" or "Block-Builder" thought experiment. Imagine a child building a tower out of wooden blocks.
To the casual observer, the "Builder" is a single entity. But Minsky breaks "Builder" down into a hierarchy of sub-agents:
- FIND: Locates a block.
- GET: Reaches out and grabs it.
- PUT: Places it on the stack.
Underneath GET, you have:
- GRASP: Closes the fingers.
- MOVE: Aligns the hand.
These agents do not "talk" to each other in English. GRASP does not send a memo to MOVE saying, "Hey, I feel some resistance here, maybe you should halt." They are connected by direct, hardwired activation and inhibition loops.
Now imagine building this child’s block-building brain using modern "multi-agent" AI architecture.
You would have a GRASP LLM write a paragraph: "I am currently experiencing 0.5 Newtons of resistance on my optical sensors. I believe I have reached the surface of the block." This text is sent to the MOVE LLM, which parses the text, matches it against its system prompt, and replies: "Understood. I will now initiate the descent protocol."
It is absurd. Yet, this is exactly what companies are building right now under the guise of "agentic workflows."
Stop Wrapping LLMs; Build Structured Control Loops Instead
If you want to build AI systems that actually scale, stop trying to turn every step of your software pipeline into an LLM-to-LLM conversation.
The most robust "agentic" systems are not those with the most conversational agents. They are systems where a single LLM is used strictly for its strengths—semantic understanding and structured data generation—while the control flow, memory, and state transitions are managed by deterministic, traditional software.
Instead of deploying a fleet of costly LLM agents, adopt a Hub-and-Spoke Heuristics model:
| Component | Role | Technology |
|---|---|---|
| The Hub | Semantic Parser & Generator | Single, high-quality LLM |
| The Spokes | Deterministic Tools | Python scripts, SQL databases, APIs |
| The Controller | State Machine & Router | Hardcoded logic (e.g., LangGraph or custom code) |
| The Memory | Structured State | Vector databases and traditional relational databases |
In this architecture, the LLM never talks to another LLM. It only talks to structured systems. It takes in a user request, outputs a structured JSON schema, and a deterministic state machine decides which tool to run next. This prevents cascading hallucinations, drops latency to near-zero for non-semantic steps, and keeps your API costs predictable.
The Real Legacy of Marvin Minsky
Minsky’s true genius was not that he predicted LLM agents. His genius was pointing out that the human mind is a messy, patch-worked, highly engineered kludge of different systems that somehow work together.
He knew there was no single magic algorithm for intelligence. Backpropagation and deep learning are incredibly powerful, but they are still just one way of processing information.
If we want to build true AGI, we cannot simply keep stacking LLMs on top of each other and hoping that the resulting noise magically self-organizes into a mind. We have to do the hard work of building the connective tissue between symbolic logic, structured memory, and statistical pattern recognition.
Until we do that, stop calling your API chains a "Society of Mind." It is just a very expensive group chat.
