ICM "2.0" 🗂️🎂🪎

ICM "2.0" 🗂️🎂🪎

I have been living inside ICM for a while now, and it changed how I build. Recently I started pairing it with one more idea, and the combination clicked hard enough that I wanted to share it here and see what you all think.

Quick version: ICM 2.0 = ICM (the interpretable filesystem) + Colibri style routing (a router that only wakes the experts a task actually needs). One gives you a system you can read. The other gives you a system that stays light. Together they run local and sovereign (this system build ACTUALLY helped me move the needle, i.e. KPI, creating content, closing deals, etc)

---

🗂️ First, why ICM already wins

For anyone newer to it, the core of ICM as I understand it:

1. The filesystem is the operating system. Plain-text steps, one job per folder. No black box.

2. It documents itself. Every folder says where you are and what is next, so you never lose the thread.

3. It is resumable. Close the laptop, come back next week, pick up exactly where you were.

4. It is portable. What runs in your head, in an agent, or on a local model is the same folder of plain steps.

The magic is interpretability. You can always open the box and see the reasoning.

🐦 The piece I added: Colibri (the router)

The problem with a big system is that it gets heavy. You do not want every folder, every expert, every context loaded for every task. A hummingbird does not flap every muscle to hover, it uses only what the moment needs.

Colibri is a mixture-of-experts idea applied to a whole life or business:

1. Only a sliver is ever active. Roughly 5 percent at a time, not the whole library.

2. A router picks the ~8 experts the task needs** and wakes only those folders.

3. Core stays pinned, the rest streams in** on demand and caches while it is hot.

4. It learns to predict which experts you will reach for next, so the right context is already warm.

🧬 Put them together and you get ICM 2.0

1. The ICM filesystem becomes the DNA / schema** — the canonical map of every expert the system can call.

2. Colibri becomes the routing layer — for any signal, it reads the map and lights up only the folders that matter.

3. A local model (I am running toward Gemma) is the runtime — it reads the DNA, wakes the experts, and produces the deliverable on your own machine.

4. Result: a system you can still open and read (ICM), that stays light and fast (Colibri), and that runs sovereign and local (no cloud dependency).

Interpretable + intelligent routing + local. That is the whole pitch.

🌊 Where it is taking me

I am using ICM 2.0 as the backbone of a content engine right now. Every signal I notice routes into the right folder, only the relevant helpers wake up, and the whole thing is a plain-text system I could hand to a local agent tomorrow. It feels less like using software and more like tending a garden that documents itself.

---

The conversation I want to start:

@Jake Van Clief

and everyone building on ICM — has anyone else tried layering a router on top? How are you deciding what to keep pinned vs stream in? And where does it break for you at scale? I would love to compare notes and give back what I have found. 🙏

14 comments

ICM "2.0" 🗂️🎂🪎