# Why Modiqo

People keep asking me what the name means. The honest answer is: more than one thing on purpose.

I spent months before I let myself name the company. Naming is the last thing you should do, not the first — because the name has to survive contact with everything you eventually build, and you don't know what that is yet. You only earn the name once the primitives have settled into something you can defend.

So I waited until the primitives were real. Then I named the thing they belong to.

## What Modiqo means

The first read is the obvious one: **modular intelligence quotient.** A measure of how much intelligence you get per unit of modularity — how composable, recombinable, and portable the building blocks are. In an era where every team is gluing together LLMs and APIs and agents with bailing wire, the modular-IQ of the resulting system is what actually determines whether it ships, scales, or rots.

But the name carries a few more readings I like, and I let all of them live.

**Modus + quotient.** *Modus* is Latin for *way, manner, method.* A modus operandi is your manner of operating. Modiqo, in this read, is the quotient of methods — the residue you get when you divide all the ways of doing a thing by all the noise, and what's left is the pattern that actually works. The crystallized method. The thing that survives the division.

**Modulus.** In math, the modulus is what's left over — the remainder after the cleanest possible division. It's also the operation that finds invariance: 7 mod 3 is 1, and so is 10 mod 3, and 13 mod 3. The modulus tells you what *repeats* across cases. That's exactly what we're building — the layer that catches what repeats across an agent's exploration and crystallizes it into something you can run again without thinking.

**Modi.** Plural of modus — ways, modes, manners. The company isn't one way of doing things; it's a system that learns the many ways an agent might do something and keeps the ones worth keeping.

**Modo + qo.** *Modo* in Italian and Latin means *manner, mode.* *Qo* is mine — coined, but it scans the way *quotient*, *codex*, *quanta* scan. A small operator suffix. Mode + operator. The mode of operating, made operable.

And underneath all of those readings is the sound. Mo-dee-qo. Three syllables, bouncing, ending on an open vowel. It's a name you can say out loud without feeling like you're reading a whitepaper. That matters too.

## The principles underneath the name

The reason a name can carry that many readings is that the thing it names was built to carry that many readings. The primitives are designed to combine.

Six thinkers shaped how I built them. I'm going to be honest about each one because the lineage matters.

**David Marr** gave me the architecture. Marr's complementary learning systems theory says intelligence runs on two timescales: a fast hippocampal system that captures individual episodes, and a slow neocortical system that crystallizes those episodes into stable, generalizable structure. The fast system explores. The slow system consolidates. They're not competing — they're complementary, and the magic is in the handoff. Every primitive in Modiqo is some version of that handoff. An agent explores (fast); Rote crystallizes (slow); the crystallized thing runs deterministically the next time. Marr's two-system brain, ported to agents.

**Richard Dawkins** gave me the replicator. The selfish gene argument isn't really about genes — it's about *replicators* as the unit of analysis. Anything that gets copied, varies, and selects. In an agent ecosystem, the replicator isn't the agent or the prompt; it's the *successful trajectory.* The thing that worked once and is now worth copying. Modiqo's Hub is where those trajectories travel and replicate. The selfish flow, if you want.

**Christopher Alexander** gave me the grammar. *A Pattern Language* and *The Timeless Way of Building* taught me that good systems are built from patterns that compose at multiple scales — each pattern solving a recurring problem in a way that lets other patterns plug into it. Alexander wasn't writing about software, but he was the most software person who ever wrote about architecture. The Modiqo primitives are patterns in his sense: each one solves a specific recurring problem (probe an unknown API, crystallize a working path, share what worked) and each one composes with the others without needing to know about them.

**Claude Shannon** gave me the substrate. Information theory says the thing that travels is bits, and what matters is signal over noise. Most agent infrastructure today is drowning in noise — burnt tokens, lost context, traces nobody reads. Building Modiqo meant being ruthless about what counts as signal and what's just exhaust. Every primitive has a tight definition of what it captures and what it throws away.

**E.O. Wilson** gave me the courage to mix disciplines. *Consilience* is Wilson's argument that the great problems are solved at the seams between fields, not inside them. I read books on game design while building a security and agent infrastructure company. I read Alexander while designing APIs. I read Bak while thinking about how flows accumulate in a commons. Wilson made that promiscuity feel like the work, not a distraction from it.

**Ole Kirk Kristiansen** gave me the constraint. Lego is the cleanest example I know of a system designed for combinatorial play. The bricks are stupid simple. The studs are standardized. And out of that absurd constraint, you get every spaceship, castle, and Death Star a kid has ever imagined. Kristiansen's lesson: if you want infinite play, ruthlessly constrain the primitives. The Modiqo primitives are deliberately few. Adapter. Flow. Hub. Three studs. Everything else is what gets built on top.

**Geoffrey West** gave me the scaling discipline. *Scale* shows that biological and urban systems follow predictable power laws — and the ones that break those laws collapse. If you design infrastructure that doesn't have a scaling story baked in, it dies at the second order of magnitude. Modiqo's primitives have to scale across one agent and ten thousand, across one team and the whole commons. That constraint shaped the architecture from day one.

**Per Bak** gave me the model for emergence. Self-organized criticality — the sandpile model — shows that systems near the critical edge produce avalanches at every scale, governed by a power law. The interesting behavior isn't designed in; it emerges when the primitives are tuned to the right edge. The Hub is a self-organized-criticality bet: throw enough Adapters and Flows into a commons, get out of the way, and watch the avalanches of recombination happen. You can't plan the avalanches. You can only design the slope.

## Bricolage as the design philosophy

There's a word from Claude Lévi-Strauss that I kept coming back to: **bricolage.**

A *bricoleur* is a tinkerer — someone who builds with whatever's at hand, by recombining the materials available, rather than designing from a blueprint. Lévi-Strauss contrasted the bricoleur with the engineer. The engineer specifies the tool needed and then makes it. The bricoleur looks at what's already in the toolbox and asks what can be combined into the thing that's needed *right now.*

Agents in production are bricoleurs, not engineers. They don't get to redesign the world. They have to work with the APIs, specs, models, and tools that already exist, and they have to recombine them into solutions on the fly. That's the actual job.

Modiqo is the bricoleur's toolkit. The primitives are deliberately under-specified so that they can be recombined into things I didn't anticipate. Adapter doesn't know what it'll be pointed at. Flow doesn't know what trajectory will succeed. Hub doesn't know what someone in a different org will fork next week. That uncertainty is the point. It's what makes the system *playable* by an agent — and what makes the agent's output *recombinable* by a human.

Bricolage is what happens when you give someone constrained, well-formed primitives and trust them to combine. That's the bet.

## Rote — the first thing we built

Our first product is called **Rote.**

I picked the name carefully, because "rote" has bad PR. We say *rote learning* when we mean *mindless repetition.* Memorizing without understanding. The kind of learning we don't want kids to do.

But that's a cultural misreading. Rote, in the older sense, is what a master pianist does when she stops thinking about which keys to hit. It's what a surgeon does when she's tied a thousand sutures. It's what a fighter pilot does when she pulls the right lever before her conscious mind has named the problem. Rote is not the opposite of intelligence. It's intelligence that has been *consolidated* — moved from the slow, expensive, deliberate system to the fast, cheap, automatic one. Marr's slow system. Procedural memory. Muscle memory.

That's what Rote does for agents.

When you cut an agent loose in production, you don't want it solving the same problem from scratch every time. You don't want it paying the full cognitive cost of figuring out, again, how to talk to Stripe or Workday or Snowflake. You want it to have *muscle memory.* You want the trajectories that worked yesterday to be there, crystallized, ready, deterministic — so the agent can spend its real cognition on the parts that are actually new.

Rote is the layer that builds that muscle memory. Adapter lets the agent probe and discover. Flow catches what worked and crystallizes it into deterministic code. Hub lets that muscle memory travel across agents, teams, and organizations.

It took me months to formulate these primitives. Most of those months were spent throwing things away. Earlier versions had five primitives, then seven, then four. I kept asking the Kristiansen question — *what's the smallest set of studs that produces infinite combinations?* Three was the answer. Adapter, Flow, Hub. Each one flexible enough to be pointed at anything. Stackable enough to compose without coordination. Adaptable enough to absorb whatever the agent ecosystem looks like in three years, which is not what it looks like now.

Three studs. Bricolage as a service. Modular intelligence quotient.

## Why the name matters

I could have called the company something forgettable. The market doesn't care about names; it cares about whether the thing works.

But I care about names, because a name is a promise you make to yourself before anyone else hears it. The name is the thing you have to keep being worthy of, every time you make a product decision.

*Modiqo* keeps me honest. It reminds me that the primitives have to stay modular, even when a customer asks for a one-off feature. It reminds me that the intelligence is in the quotient — the residue, the pattern, the thing that survives division — not in the noise. It reminds me that the building blocks have to combine the way Lego bricks combine: stupidly simple on their own, infinite together.

And it reminds me that the goal isn't to build an intelligent system. The goal is to build a system where intelligence — agent intelligence, human intelligence, the intelligence of teams swapping flows across the commons — gets to *play.*

Toys first. Games after. Bricolage in between.

That's Modiqo.