ICM on enterprise level - introducing Taurus

Folders, not frameworks: how Taurus makes Claude repeatable for a whole team

Giving an AI agent the right context at the right moment is still the hardest part of using coding agents like Claude Code in real, daily work. We've all felt it: the agent is brilliant when it knows where it is, and frustrating when it doesn't. So how do you give it that context — reliably, for more than one person? A small team will work but what happens when you try to on-board 100+ people?

The popular answers don't scale. Elaborate memory systems help a single power user, but in an enterprise they become a liability: they're hard to curate, easy to pollute, and brittle the moment you add more people and more projects. And anything built around one person's bespoke setup — their servers, their wiring, their mental model — is expensive to onboard a whole team onto. Honestly, the wheel hasn't been invented yet. Nobody has a clean, proven answer for how context should work at enterprise scale.

This is where the Interpreted Context Methodology (ICM) changes the conversation. Its core idea is deceptively simple: folder structure as agent architecture. Instead of orchestration code or a sprawling

memory store, the context lives in the folders themselves. A workspace is just numbered folders for each stage, with markdown files (CLAUDE.md, conventions, reference material, working artifacts) that load in layers when an agent starts there. The agent reads downward and stops when it has enough — typically 2–8k tokens instead of 30–50k. You "configure the factory, not the product": set the workspace up once, then every run reuses it with new inputs. Outputs are plain text, editable, reviewable at every step.

ICM is elegant because it's filesystem-native and human-readable — a non-developer can reshape a workflow by moving files. But it has one practical dependency that's easy to overlook: When you add more and more folders agents begin to skip information. Guidelines are missed, rules are overlooked. What worked for one person doesn't work for another because the model scans economically and thinks it knows enough. The solution is again simple, the agent has to actually start in the right folder. Start in a central place and the layered context never loads; start in the right place and the agent is instantly grounded. In a team, "just cd to the correct directory" is exactly the kind of invisible, error-prone step that breaks repeatability.

That's the gap Taurus fills. Taurus is the entry point for ICM.

Taurus is a small desktop launcher that runs Claude Code agents as embedded terminal tabs — and every launch button is bound to a specific process folder. A teammate doesn't memorise paths or wire up anything: they open Taurus, click "ASTRID (projects)" or "Invoices" or "Porter (e-mail assistant)" and the agent starts exactly inside that ICM workspace, with that folder's CLAUDE.md and conventions already in context. The user instantly knows where they are; the agent instantly knows what it's working on. Same button, same starting context, same repeatable result — across people and across runs.

A few ways Taurus and ICM reinforce each other:

- A tab per workspace/stage. ICM is built for sequential, reviewable workflows; Taurus lets you run several of them side by side as tabs and switch between them, instead of juggling terminal windows.

- "Configure the factory" becomes a shared button set. The launch buttons live in one small config; set them up once and the whole team reuses them. Onboarding a new person is "open Taurus, click your project" — not a half-day of environment setup.

- Human checkpoints. ICM pauses for human steering; Taurus lets you start an agent in Plan mode when you open a design process and auto mode for processing e-mails.

- Review the artifact, not just the log. ICM treats every output as an editable file. When an agent writes an HTML dashboard or report, Taurus shows it inline (click the path → it renders next to the terminal), so you review the output without leaving the window.

- Local-vs-network clarity. Each button shows a LOCAL/NETWORK badge and the exact folder, so people never run the right task against the wrong location — a small thing that quietly kills a lot of "why did it do that?" moments.

The deeper point: ICM moves context out of fragile memory and into the filesystem, where it's transparent, versionable, and team-shareable. Taurus removes the last bit of friction — getting everyone to the right folder, every time — and turns "start an agent" into a single, consistent click. It's not the final word on context-at-scale, but together they make agent work boring in the best way: predictable, repeatable, and easy to onboard.

Taurus is open source (MIT) and Windows-first: https://github.com/astetic-dev/taurus — pair it with ICM and let your folders do the context work.

(it's a first release, expect a few bugs and use github for feature requests)

6 comments