Most AI problems I see do not start with the model

Most AI problems I see do not start with the model.

They start with the workspace around the model.

The chat gets long. The instructions get buried. The model starts guessing from whatever context is closest. You ask for one thing and get a polished version of almost the right thing. That is the part we call drift.

Interpretable Context Methodology, or ICM, is a practical way to reduce that drift. Model Workspace Protocol, or MWP, is the folder-based pattern that makes it usable. Instead of trying to control an agent with one perfect prompt, you give it a workspace it can read: folders, markdown files, router files, stage instructions, reference material and outputs.

That sounds almost too simple. And it really is.

The ICM white paper describes this as using filesystem structure instead of framework-level orchestration for sequential workflows where a human reviews the work at each step [1]. In plain English: the folder structure becomes the control surface.

The Real Problem Is Context

Prompting matters. The prompts are only one piece.

The larger problem is context. What did the model see? What rules did it load? What did it ignore? What output from the last step became input to the next step?

If all of that lives in one long chat, the model has to sort through everything. Old instructions, new instructions, side comments and half-finished ideas all sit in the same pile.

Long-context research backs up the concern. Liu et al. found that model performance can drop when relevant information is buried in the middle of long inputs, even when the model supports long context windows [2].

So the answer is not always more context. The answer is cleaner context.

ICM is built around this idea. Each stage gets the files it needs when it needs them. Nothing more than necessary. Nothing hidden if a human wants to inspect it.

What ICM Is

ICM stands for Interpretable Context Methodology.

The useful word is interpretable.

The workflow is not trapped inside a tool you cannot see. It is sitting in front of you as files and folders. You can open the instructions. You can read the references. You can inspect the output from each stage before the next stage uses it.

An ICM workspace usually includes:

• An identity file that tells the agent where it is.
• A router file that tells the agent where to go.
• Stage files that tell the agent what to do.
• Reference files that hold reusable rules.
• Output folders that hold the work product.

The white paper describes one orchestrating agent reading the right files at the right moment, instead of needing a separate multi-agent framework to pass context around [1].

That is the part I like. You are not asking the model to remember the workflow. You are putting the workflow on disk. Simple human-readable text files.

What MWP Is

MWP stands for Model Workspace Protocol.

If ICM is the method, MWP is the workspace pattern. The folder structure tells the agent how the work is organized. Markdown files carry the instructions. Outputs become handoffs. This makes the process easier to trust and modify.

You can see what happened. You can edit the brief before the draft runs. You can change one voice file instead of pasting the same style rules into every chat. You can rerun a stage because the stage has a defined input and output.

It is simple. It is useful.

The Five Layers

The ICM workspace can be understood through five layers.

The ICM paper separates structural routing from reusable reference material and per-run working artifacts [1].

For people learning the method, I would focus hard on L1 through L3.

L1 routes the work.

L2 defines the job.

L3 supplies the rules.

When those three layers are clear, the agent has less room to improvise.

Why This Helps With Drift

Drift usually comes from a few boring things:

• The instruction was not specific enough.
• The model loaded too much unrelated context.
• The handoff between steps was fuzzy.
• The human had no easy checkpoint before the next step.
• Context rot.

ICM attacks those problems with structure. One stage does one job. A research stage researches. A drafting stage drafts. A review stage reviews. A final stage finalizes.

Each stage reads defined inputs and writes defined outputs. The next stage consumes the previous output. The human can open the file between stages and correct it before the workflow continues.

That is the quiet value of the method.

If the final output is wrong, you can inspect the chain. You can look at the input, the brief, the source map, the draft and the review. You do not have to scroll through a giant conversation trying to find where the work went sideways. You also do not have to rerun a huge token-hungry prompt over and over again.

Configure the Workspace, Not Every Prompt

This is the mindset shift.

Stop rebuilding the whole instruction set every time you start a task. Put reusable rules where the agent can find them.

If tone matters, put it in a voice file. If citations matter, put them in a citation rule. If every post needs review before final, make review a stage. If the agent keeps adding sections you did not ask for, write that constraint into the stage.

This is where ICM starts to feel different from ordinary prompt work. You are not just writing a prompt. You are configuring the environment the agent works inside.

A Simple Triage Rule

AI should not do every part of the workflow.

The outline for this post used a 60/30/10 heuristic:

• Use deterministic tools for work with one right answer.
• Use rule-based automation for if/then logic.
• Use AI for judgment, synthesis and messy language.

I would treat the exact percentages as a working rule of thumb, not a scientific benchmark. If a spreadsheet, script or database can do the job better, use that. Save the model for the parts where judgment matters.

The ICM white paper makes room for this by using local scripts for mechanical work that does not need AI [1]. That is the right split. Let tools do tool work. Let the model handle the messy human-language work.

If you are new to ICM and MWP, do not start by trying to memorize every term.

Start with the shape:

1. Put the request in an input folder.
2. Route the work to the right stage.
3. Give each stage one job.
4. Keep stable rules in reference files.
5. Write outputs to visible files.
6. Review the output before the next stage uses it.

That is enough to understand the core move.

The model does not need to hold the whole workflow in its head. The workspace holds it and directs AI to the right context at the right time, and only the context it needs.

The Practical Point

ICM and MWP are useful because they make AI work visible. You can see the instructions. You can see the context. You can see the handoffs. You can see what changed between stages.

That is what control looks like.

Not a bigger prompt.

Not a louder claim about agents.

A workspace the agent can interpret and a human can inspect.

Side Note

This post was written using an ICM workspace. I fed it my idea, my text and some reference material. I went through several iterations. Then I read the drafts, looked at the reference material and citations, and had it move to the next stage only after I approved it.

The point is that I was in control. I gave it my text and my references, then let it add research for me to validate.

Sources

[1] Jake Van Clief and David McDermott, “Interpretable Context Methodology: Folder Structure as Agent Architecture,” arXiv, 2026. https://arxiv.org/html/2603.16021v2

[2] Nelson F. Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang, “Lost in the Middle: How Language Models Use Long Contexts,” arXiv, 2023. https://arxiv.org/abs/2307.03172