Back to Blog

The Modularity Revolution: Why AI's Next Breakthrough Is About Pulling Things Apart

8 min read

Something interesting is happening in the AI world that doesn't fit the dominant narrative. Every week we're told the story is about bigger models, larger parameter counts, and more compute. But scratch the surface of what's actually being built — by researchers, by open-source communities, by practitioners — and you find a different story entirely.

AI is being pulled apart.

Not into pieces that don't work together, but into composable modules — specialized components that do one thing extremely well and plug into each other through clean interfaces. This is the modularity revolution, and it's quietly reshaping everything from how robots plan to how scientific workflows get executed to why a $600 Mac Mini is selling out.

The Crack in the Monolith

For years, the dominant instinct in AI was unification. One model to rule them all. A single transformer that could see, hear, speak, plan, and act. The logic was compelling: more parameters, more capabilities, more general intelligence.

But a series of papers released this week reveal the cracks in this approach — and point toward a more promising path.

LoHo-Manip, a paper from researchers at UC San Diego and NVIDIA, tackles a problem that has bedeviled robotics for years: how do you get a robot to execute a long-horizon task — like "fill the kettle" — without compounding errors destroying the plan halfway through? Their answer: don't try. Instead, they decompose the system into two distinct components. A high-level task manager (a vision-language model) answers the question "what remains to be done?" and draws a visual trace — literally a path on the image — showing where to go next. A low-level executor (a VLA policy) handles the "how" — the muscle movement. When the executor fails, the world state reflects that failure, and the manager automatically updates its plan without any hand-crafted recovery logic.

The key insight isn't the decomposition itself — hierarchical planning has been around forever. It's that the interface between the two modules is so clean it converts a difficult long-horizon planning problem into a sequence of short-horizon control problems. Each module can be upgraded, swapped, or retrained independently. A GR00T executor can plug into a π0-style manager. The manager doesn't care what executes; the executor doesn't care where the plan came from.

This is a profound shift from the "one big model" paradigm. When you build modularly, the whole becomes greater than the sum of its parts — not because you've built a more powerful individual model, but because specialized components can be composed in ways a single monolithic system never could.

Context Unrolling: Modularity Within a Single Model

The same pattern — pulling things apart to make them work better together — shows up in an unexpected place: within a single model.

A new paper on Omni, a unified multimodal model trained natively on text, images, videos, 3D geometry, and hidden representations, introduces what the authors call Context Unrolling. The idea is simple but powerful. When given a task, Omni doesn't immediately produce an output. Instead, it unrolls a context workspace — reasoning across multiple modalities, aggregating complementary information — before generating. It might first "think" in text about what a scene contains, then roll out visual tokens that carry structural spatial information, then reason about depth and geometry — all before producing a final answer.

This is modularity not between models, but within the reasoning process itself. Each modality provides a different "projection" of the same underlying world knowledge. By unrolling them separately and then composing the results, Omni recovers a more complete approximation of the multimodal manifold than any single-modality approach could achieve.

The practical consequence: the same model that generates images also understands them. The same model that processes video also reasons about 3D geometry. And crucially, you can selectively invoke different reasoning modalities depending on what the task demands. The capability is there when needed, modularly, without forcing everything through a single undifferentiated forward pass.

Self-Programming Through Structured Composition

If there's one paper that crystallizes where AI is heading, it's Nemobot Games, which revisits Claude Shannon's 1950 taxonomy of game-playing machines and shows how modern LLMs can operationalize — and extend — each category.

Shannon's original framework distinguished between: dictionary-based machines (pre-stored solutions), mathematically rigorous systems (for solvable games), heuristic machines (for complex scenarios), and learning machines (that adapt through experience). Nemobot shows that each category maps cleanly onto a different LLM pattern — compression for dictionary-based games, symbolic reasoning for rigorous games, minimax plus crowdsourced data for heuristic games, and RLHF plus self-critique for learning games.

But the deeper insight is architectural. The authors show that you can't just prompt an LLM to play a game well — you get non-deterministic, irreproducible behavior. To get structured, auditable, improvable gameplay, you need to build a system — a programmable framework where LLM capabilities are modular components (planner, executor, critic, memory) with well-defined interfaces. The LLM provides the intelligence; the framework provides the structure. Neither alone is sufficient.

This is exactly the lesson the agentic AI community is converging on. A single LLM API call is not an agent. An agent is a composition of capabilities — tool use, memory, planning, reflection, execution — connected through interfaces that make each piece testable, improvable, and replaceable.

The Real Signal: Mac Minis Selling Out

While the research community is discovering modularity, the market is voting with its wallet in a way that's equally revealing.

The M4 Mac Mini — a $600 computer — is selling out. Not because Apple ran a brilliant marketing campaign. Because people have realized that a $600 machine running Qwen 3.6-27B at 23 tokens per second via MLX can replace $180-per-million-tokens API calls for a growing class of tasks. The Mac Mini selling out is a revealed preference for local, modular AI infrastructure.

This is the downstream consequence of the modularity revolution working in practice. When models can be optimized for specific hardware, when quantization and inference techniques compress capable models into small footprints, when the open-source ecosystem provides the tools to run these models locally — the economics of AI change. You stop paying the cloud inference tax. You start owning your AI stack.

And critically, ownership enables composition. When you run models locally, you can run many of them. You can have a small fast model for routine tasks and a larger one for complex reasoning. You can swap models as they improve without renegotiating API contracts. You can build purpose-built pipelines for your specific use case. The modularity revolution isn't just about software architecture — it's about who controls the components and who can recombine them.

The Infrastructure Layer Is Being Built

None of this works without the plumbing. The third thread running through this week's research reveals the infrastructure layer that's finally maturing.

A paper from AGH University Krakow and Sano Centre — "From Research Question to Scientific Workflow" — demonstrates an agentic architecture for automating scientific computation. The system translates natural-language research questions ("compare mutational patterns in European and African populations across chromosomes 1 through 5") into executable Kubernetes workflows. But the architecture is what's noteworthy: a Conductor agent handles user interaction, a Workflow Composer handles semantic interpretation, and a deterministic generator produces the actual DAG. Critically, domain experts author Skills — markdown documents encoding vocabulary mappings, parameter constraints, and optimization strategies — that the agents consult deterministically at runtime.

This is a profound observation: the knowledge layer and the execution layer are fundamentally different in nature. Knowledge is authored by humans, evolves slowly, and must be auditable. Execution is deterministic, automatable, and should be reproducible. Confusing the two — trying to use an LLM to generate both the domain knowledge and the execution plan — produces non-determinism. But separating them, and connecting them through clean interfaces, yields systems that are both intelligent and reliable.

The community is building this infrastructure fast. GitHub is seeing rapid growth in agentic frameworks — tools that provide the scaffolding for multi-agent composition, skill authoring, tool use, and workflow orchestration. The gap between "we have capable models" and "we have reliable AI systems" is closing, and the bridge is modular infrastructure.

Why This Matters More Than Bigger Models

The tech press will tell you the story of AI is measured in parameters and benchmarks. The reality on the ground — in research labs, on GitHub, in the hands of practitioners running local models — is different.

The real breakthrough is architectural. The field is learning that composition beats concentration — that specialized modules composed through clean interfaces outperform general-purpose monoliths. That determinism beats non-determinism when reliability matters — separating what the LLM does (interpret intent) from what code does (execute plans). That ownership enables innovation — when you control your AI stack, you can recombine it in ways API-gated services never allow.

This isn't a story about which lab has the biggest model. It's a story about an entire ecosystem learning to build with AI the way engineers have always built with other complex systems: in pieces, with well-defined interfaces, composed into something larger than any individual component.

The modularity revolution is here. And unlike the parade of "biggest model ever" announcements, it's actually usable.

Sources

Academic Papers

Hacker News Discussions

Reddit Communities

  • This is where we are right now, LocalLLaMA — r/LocalLLaMA, April 24, 2026 — Viral post (2912 upvotes) showcasing current local AI capability; strong signal of community optimism about local AI
  • DeepSeek V4 people — r/LocalLLaMA, April 24, 2026 — Community discussion on DeepSeek V4 performance and capabilities
  • Qwen 3.6 27B is out — r/LocalLLaMA, April 22, 2026 — Qwen 3.6-27B release discussion; 1698 upvotes; evidence of open-weight model ecosystem momentum
  • Kimi K2.6 is a legit Opus 4.7 replacement — r/LocalLLaMA, April 21, 2026 — Community validation of Kimi K2.6 as first credible Opus-class replacement from open-weight models

X/Twitter

GitHub Projects

  • garden-skills — GitHub, April 2026 — 1322 stars; skill-authoring framework for AI agents
  • mercury-agent — GitHub, April 2026 — 1294 stars; modular agentic framework for composing LLM capabilities