Folders Over Agents
Direct an AI with the folders and text files you already use, and check every piece of work before it goes anywhere.
There is one way to direct an AI that needs nothing new, and it is not clever. Every job lives in a folder. The instructions for each step are a text file. You tell the AI to open the folder, do what the file says, write its output as another text file, and stop. Then you read what it wrote, exactly as you would read a junior's work before it went out the door. It is run this way every working day in an ordinary business, on work that business depends on.
The method is called Interpretable Context Methodology. It was written up by Jake Van Clief and David McDermott in March 2026, and "Folders Over Agents", meaning folders instead of the self-running "AI agents" the software industry sells, is the phrase Jake Van Clief teaches it under. None of it is invented here; it is set out in their paper and run here in practice. This page is the long version of the line above, written for people who are not technical and do not want to be. At the bottom there is a free kit: the folders and files, already half filled in on an ordinary job, chasing overdue invoices, so you can give it to an AI on your own computer this afternoon, do the first check yourself and watch it run the next step. Before that, it is worth explaining how it works, who worked it out, and where it falls down, because an accurate picture is more use than an excited one.
Read the story, or go straight to the kit.
Contents
1. You already do this
Open the Documents folder on your computer. There is a folder for each customer, or each property, or each project. Inside it there is a folder for the year, and inside that the files for the job: the brief someone wrote, the working draft, the thing that was finally sent. If a new member of staff joined tomorrow, you could point at that folder and say "everything you need is in there", and you would be right.
That arrangement is not an accident and it is not primitive. It is how businesses have organised work since filing cabinets, and it survived the move to computers because nothing better came along. It carries three things at once: the order the work happens in, what belongs to which job, and where the finished result lives. Everything on this page rests on that arrangement: the way to direct an AI safely is to use the folders you already trust, not to build something new.
2. This is not new
The strongest objection is worth getting out of the way first. Keeping organised files with written procedures in them is not a discovery. Every well-run office has done it. The only thing that has changed is that there is now a reader who will follow the procedure at two in the morning without complaint, and that reader needs the procedure written down more carefully than a person does.
Van Clief and McDermott's own two-sentence description of it is the clearest there is. Three words in it need translating. A "markdown file" is a plain text file that opens in Notepad or Word. A "prompt" is the instruction you give the AI. "Context" is whatever you have put in front of it to read.
"Numbered folders represent stages. Plain markdown files carry the prompts and context that tell a single AI agent what role to play at each step."Van Clief and McDermott, Interpretable Context Methodology: Folder Structure as Agentic Architecture, arXiv 2603.16021, 2026.
Read that again with your own business in mind. There is a folder for the job, and inside it numbered folders for the steps in the order they happen, and each step holds a plain text file that says what to read, what to do and what to hand back. The instruction sheet that a person used to open and follow is now opened and followed by an AI, and the person moves to the desk where the results are checked.
Most of what is sold as "AI agents" is the opposite of this: several of them passing messages to each other, a piece of software in the middle deciding which one speaks next, and a dashboard so that you can watch it, because otherwise you could not. That is not needed for the work a small or mid-sized business does. The jobs are sequential, they repeat, and someone competent has to look at the result before it goes out. For that class of work, the folder does everything the software in the middle did. Kieran Klaassen, who runs Cora, an email product built by the publication Every, found the same thing from the other direction. In what follows he uses "model" to mean the AI itself; his definition of what the industry calls an "agent" is the one this page uses:
"But an agent is much simpler: a model with enough context so you don't have to re-explain everything each time you open the chat."Kieran Klaassen, "The Folder Is the Agent", Every, 13 April 2026.
"Just by changing the folder and not the model, I have a different agent."Kieran Klaassen, "The Folder Is the Agent", Every, 13 April 2026.
What this page adds is the experience of running the method every day on work a real business depends on, and the habit of writing down what went wrong. That is what the rest of it is.
3. Three steps, three files
Every repeatable job in the business that runs this is a folder with three numbered steps inside it: Gather, Work, Close. Each step produces exactly one file, and the files have the same names every time: brief.md from Gather, queries.md from Work, done.md from Close. The .md on the end only means a plain text file; you can open and edit it in Word or Notepad. Between each step a person reads the file and corrects it if they want to, which is the same skill as editing a Word document, and only then does the next step begin. The paper's authors make this the centre of the method, and it is the reason the whole thing can be trusted by someone who cannot read code:
"The intermediate output of each stage is a file a human can open, read, edit, and save before the next stage runs."Van Clief and McDermott, 2026, section 3.1.
Gather collects what the job needs and reports whether the job can actually start: the records are there, the period is right, nothing is missing. If something is missing, the brief says so, says what would fix it, and stops. Work does the job itself and writes the result together with everything it was unsure about, as numbered queries. Close records what was finally done, updates the running history, and writes down anything the run learned that should change the instructions next time.
The three files are the whole audit trail, because the evidence of what happened is the same thing as the work. The paper puts it plainly:
"There is no logging layer to build, no dashboard to configure, no special tooling to inspect pipeline state. You open a folder and read the files."Van Clief and McDermott, 2026, section 5.3.
4. The instruction sheet
Each step folder holds one instruction sheet, and every sheet has the same five parts. Inputs lists the only files this step is allowed to read, by name. Process says what to do, in numbered steps. Output names the file the step must write and where. Human check names the one thing a person is asked to do when the step ends. Verify is the list of checks the AI runs on its own work before a person sees it, each answerable pass or fail, one for every step in the Process.
The Inputs list is the part that matters most, and it is the part people skip. It is the control point of the whole system. The AI reads what is listed and nothing else, and anyone can see afterwards exactly what it was looking at. If a step produced something odd, the first question is always "what was on its Inputs list", and the answer is written down.
The discipline that makes the Process part work is that every line must be something you could check by looking. Ryan McKinney, who runs the method for agencies and writes about it at filesnfolders.com, put the test as plainly as anyone:
"Write in a friendly tone is not a rule, it is a wish. Never use an em dash is a rule, because either it is there or it is not."Ryan McKinney, filesnfolders.com FAQ.
A step written as wishes produces output you cannot argue with; a step written as checkable rules produces output you can mark, and it is why reviewing a run takes minutes rather than an afternoon.
A sheet like this is readable by anyone who can read a procedure, and that is the point. Anthropic, the company that makes Claude, the AI used here, calls an instruction sheet like this a "skill", and describes writing one in exactly the terms a manager would recognise:
"Building a skill for an agent is like putting together an onboarding guide for a new hire."Anthropic, "Equipping agents for the real world with Agent Skills", 16 October 2025.
The paper's authors report the same thing from their own community: people with no development experience changed what a step did by editing its text file. That is a practitioner report, not a study, and it is worth saying so; it also matches what happens in the business that runs this, where every instruction sheet was written and is maintained by the people who do the work, not by a programmer.
5. The recipe and the meal
There are two kinds of file in a job folder and it helps to keep them apart. The first kind is the recipe: the instruction sheets, the house rules, the notes on how a particular piece of software behaves. These are written once when the job folder is set up, and they stay the same from one run to the next. The second kind is the ingredients and the finished meal: the brief, the queries and the done file for one particular run, for one particular customer. These are new every time.
The distinction tells you where to put effort. You set up the recipe once; you never set up the meal. And because the recipe lives in the job folder while the ingredients live with the record they belong to, one job folder serves every customer a business has.
6. What the AI reads
In practice an AI given everything at once does worse, not better. Buried in forty pages of mostly irrelevant material, it loses the two paragraphs that matter, and the failure is silent: the output looks confident and is wrong. The method's answer is that no step reads everything. The step reads the sheet in its own folder, the handful of rules that apply, and the one file the previous step handed over.
This is also why the sheet's Inputs list is written as file names rather than pasted content. Anthropic's own guidance to the programmers who build these systems says folder structure is itself information to the model:
"Folder hierarchies, naming conventions, and timestamps all provide important signals that help both humans and agents understand how and when to utilize information."Anthropic, "Effective context engineering for AI agents", 29 September 2025.
7. The four human controls
The aim is not to make the AI transparent; no model is. What can be made transparent is the operation around it, and four rules do that, written into every job folder and never varied.
- Irreversible actions stop with a person. Anything that reaches a customer, a supplier or a third party, or that cannot be undone, is left for a human, every time. The AI never sends, files or approves.
- Actions are limited. Each job folder lists what the AI is allowed to do; anything not on that list is not allowed by default, and the AI reports it instead of doing it.
- Corrections feed the next step. Whatever a person changes in the file is what the next step reads. The AI does not work from its own memory of what it meant to say.
- The AI does not silently rewrite its own rules. If a run finds an instruction that seems wrong, it writes a proposed change beneath the original and leaves it for a person to accept or refuse.
These are not safety theatre. They are the reason the method can be run on real work at all, and they are the reason the work stays the operator's rather than the software's. They are shaped so that a person's time is spent where it matters, at the beginning of a job and at the end. Klaassen, again:
"AI agents don't have a speed limit, but the person managing them still does."Kieran Klaassen, "The Folder Is the Agent", Every, 13 April 2026.
8. A real job, start to finish
Here is one real run of this job, from a working business, in September 2026. It is the job of chasing overdue invoices: going through the accounts that are past their due date and drafting a reminder to each customer who owes. Nothing here is a demonstration; it is the job as it happened, with the customers' names, the amounts and the exact dates taken out. The kit at the foot of the page sets up this same job for you to try, but the run in the kit is invented and labelled so in the first line of every file; the run described here is a real one.
One thing to say first: in this business the AI is also allowed to look inside the system where invoices and payments are recorded, because the sheet lists that as an allowed action under the second control in section 7, and it may read there but not send, change or clear anything a person would need to undo. The kit's version of this job below is different on purpose: it needs no software at all, only the folder and a list of invoices.
Gather ran first. Its Inputs were the export of unpaid invoices for the business, the house rules, a short checklist, the business's own front page and its short history page of who has been chased before and how they respond. It confirmed the export covered the right period and that the totals on it agreed with the summary in the invoicing system, then ran the three readiness checks the sheet demands. The list of overdue accounts loaded. The customer history loaded. The third check failed: the export was a day old, and the automatic link that marks an invoice as paid the moment the money arrives had stopped updating, so some invoices still showing as unpaid might already have been settled. The AI wrote the brief with the status "blocked", said what was short, said what would fix it, said who was being asked, and stopped. It also recorded two things nobody had told it to look for: a saved shortcut in the invoicing system had opened a different account's records, which it backed out of and wrote up, and a pop-up had led it into a reconnection screen, which it left without entering anything. The Human check line asked for the payment feed to be refreshed, and for confirmation once the list showed only genuinely unpaid invoices.
The blocker was real when it was first written down. It was also a day old by the time it was read, and in that day the payment feed had caught up on its own and all but a handful of the invoices had cleared. The AI had reported a problem that had mostly gone away. It had not lied; it had done what the sheet said and repeated a problem from an earlier file without checking whether it was still true. The correction did not go into the brief. The same day, a new rule went into the house rules for every future run: a problem copied from an earlier file must be checked again, that day, before it is reported, and the sheet now says which quick check to run. The incident is cited beside the rule so that anyone reading it later can see why it exists. That is the method working as designed, and section 9 is about why.
Work ran the next day, reading the brief exactly as it had been left, the business's history page and the rules. Its first step is to clear the brief's blockers before drafting anything; the feed was refreshed and the list was current, so it proceeded. It grouped the overdue invoices by customer, worked out how far past its due date each one was, and drafted one reminder per customer in the tone the history records, gentle for the first reminder and firmer as the debt aged. It cross-checked every customer against the history in both directions, found the usual late payers consistent with their record, and found one account it wanted flagged: a customer who was on the overdue list but whom the history marked as being on an agreed payment plan, which meant they should not be chased in the ordinary way. Because new customers had appeared on the list, it checked for duplicates and found none. It wrote the queries file with four queries, one marked material: one customer on the list was on a payment plan and drafting the usual reminder to them would be wrong, so their draft was held back for a decision. Nothing was sent, and nothing left the folder. The file ended by calling for a stop to resolve query 1 before the next step ran.
A person ruled on the queries file's own status line: strike the customer on the payment plan from this run, and send the rest. The ruling was written on the note itself so that the next step would pick it up from the file and not from anyone's memory. A person sent the reminders that evening. The AI did not send them and could not have.
Close ran the following morning. It recorded which reminders had gone out and when, and left the final tidy-up for a person, because it follows the emails, which are a person's to send. Then it updated the business's records: it added an entry to the evidence log noting who was chased and who was held back, and rewrote the short history page from that log, adding the new customers and working out again what a normal run looks like. Section 9 explains why the history is kept as two files. Its footer listed every action it had taken in the invoicing system against the rule that covered it, and noted one wording in the rules that it thought was unclear, flagged rather than edited.
9. Fix the recipe, not the meal
When the AI gets something wrong, there are two places to put the fix, and the paper states the choice in two sentences:
"Editing the output fixes this run. Editing the source fixes every future run."Van Clief and McDermott, 2026, section 6.3.
In the business that runs this, a working rule is attached to it: if the same thing is corrected at two checkpoints, that is treated as a fault in the instructions rather than in the AI, and the closing file records what changed so that the pattern is visible. The fourth control in section 7 covers the loop: the AI proposes, a person decides. That gate is kept even over a person's own instructions, on the grounds that the person may be wrong too.
Two failures are worth naming, because both shaped the sheets in the kit. The first is the one the method's own guidance records as the most common: the last step of a job quietly diverges from a decision taken two steps earlier, so that Close records what Work drafted, not what a person ruled. The handwritten ruling on the status line in section 8 exists to stop that, because the next step reads the file and the ruling is in the file. The second failure was silent, and it happened in the business that runs this. The history for each record is two files: an evidence log that the AI appends to after each run and never reads while doing the work, and a short page that the Close step rebuilds from that log, which is what every step actually reads. A Close sheet said "append to the log, then rewrite the short page", and for two whole runs the AI only appended. Nothing was wrong with the instruction. Nothing checked it. The short page looked perfectly healthy while it went stale. The fix was a Verify line in the Close step that compares the short page's date stamp with the newest entry in the log, and the kit's Close sheet carries it.
One more thing keeps a folder system alive over years rather than months. A customer's payment terms live on that customer's page and nowhere else. A rule about how a particular tool behaves lives in one notes file, and every job folder that needs it points there rather than copying it. The moment the same fact exists in two files, one of them goes stale and nobody knows which. Ryan McKinney has the shortest statement of this:
"One fact, one home, and everything else points at it."Ryan McKinney, filesnfolders.com FAQ.
10. Where this does not fit
The method's authors, who shorten its name to ICM, are direct about its limits, and this page should be too. In their words:
"ICM is not a replacement for multi-agent frameworks in every context."Van Clief and McDermott, 2026, section 5.2.
| To do this | In a folder system |
|---|---|
| change the order of steps | rename a folder |
| change an instruction | edit a text file |
| add or remove a step | add or delete a folder |
| see what happened | open the folder |
| hand it to someone | copy the folder |
| who can change it | anyone with a text editor |
Where a programmed system does better
| To do this | In a programmed system |
|---|---|
| recover from errors on its own | the software retries; a folder stops and waits for a person |
| choose the route mid-job | the software branches on its own; here a person chooses the next step |
| run many jobs at once | the software runs them in parallel; a folder runs one at a time |
| connect to other systems by code | the software calls an interface directly; a folder is read by a person or one AI |
It does not fit work where several AIs must talk to each other as they go, or where many people use one system at the same moment. In this method, a fork in the road is a person choosing which step runs next, and if you find yourself writing software to make that choice you are building the thing in the middle again, and should either stop or hire someone to build it properly.
The evidence base is also thin, and the authors say so. Their community at the time of writing was invite-only and self-selected. The pattern they report of where people intervene most, heavily at the first step and the last and lightly in the middle, came from practitioners describing their own habits in conversation, not from measurement. And, in their words, nobody has yet measured the method against simply giving the AI everything at once:
"No controlled comparison has been conducted between ICM's staged context loading and a monolithic prompting approach on the same tasks"Van Clief and McDermott, 2026, section 4.6.
Every worked example in the paper is content production. In practice the method carries across to the ordinary back-office work of running a business; that is one operator's experience, described in section 8, and nothing on this page should be read as more than that. It has not been measured against the alternative, because the alternative in a business this size was doing it all by hand. Reasonable people will want to try it on one job of their own before believing any of it, and the kit below is built for exactly that.
11. The kit
The kit is a folder. Inside it is one complete job, set up the way a working job is: a job page, three numbered step folders each with its instruction sheet, a house-rules file, a business record with its two-file history, and one example run already done so that you can read what the three files look like when they are finished. A second run of the same job is started and left half-way, with the brief written and the Human check waiting for you, because the hardest part of any of this is a blank text file, and you should never have to face one. There is also a blank job folder with the same shape and prompts in every sheet, for the first job of your own.
It is structure, not a tool, and that is the point of it. Jake Van Clief puts the durability of that well:
"You relearn AI every time a model updates. The tools change. Your work resets. Build the structure underneath instead, and it lasts a decade."Jake Van Clief.
The job in the kit is chasing overdue invoices, because every business has that job, it needs no special software, and it makes the human control obvious: the AI drafts the reminders, and a person sends them. The example figures in it are invented and say so in the first line of every file.
Claude, the AI the kit is built for, is a rival to ChatGPT and Microsoft Copilot. Claude Desktop is its app for Windows and Mac, and Cowork is the setting in that app that lets the AI work inside one folder on your computer and nowhere else. The kit is built for that because it is the simplest way today for someone with no technical background to give an AI a folder. You install the desktop app (at work you may need IT to do this, or try it on a home computer first), choose Cowork, click "Work in a project or folder", and pick the kit's folder. In Anthropic's words, where "Claude Code" is its programmers' tool and a "terminal" is the typed command window programmers use:
"Claude Cowork uses the same agentic architecture that powers Claude Code, with no terminal required."Anthropic, Claude Help Center, Cowork setup page.
The kit is only folders and text files, so any other AI that can be given a folder to work in should be able to read it; it has only been tested with Claude, and the setup sheet says so. Cowork needs a paid Claude subscription, and the personal one is priced on Anthropic's website; the kit itself costs nothing and always will. If you cannot install anything, or do not want to yet, the kit still opens in Word or Notepad, and reading the finished example run is worth the download on its own. The one-page setup sheet inside it takes you from the unzipped folder to your first Human check in a single sitting. The kit arrives by email, which is why the form below asks for your address.
Confirming your address adds you to the list, so you may also get the occasional note about running a business this way; every email unsubscribes in one click. Your address is handled as set out in the privacy notice.
12. Where this comes from
This page is an account of other people's work. The method is Interpretable Context Methodology, by Jake Van Clief and David McDermott: "Interpretable Context Methodology: Folder Structure as Agentic Architecture". The paper is on arXiv, the open archive where researchers post papers before journal review, at arXiv 2603.16021, submitted 17 March 2026; it is free to reuse with credit (Creative Commons BY 4.0, deed at creativecommons.org/licenses/by/4.0). The authors' own working set of folders is at github.com/RinDig/Interpretable-Context-Methodology, free to copy under the MIT licence. The paper has not been peer reviewed, and it has been treated as a preprint throughout. Readers who follow the arXiv link will notice the listing's abstract still uses the paper's earlier name, Model Workspace Protocol; the paper's text uses the current one. Diagrams 3, 5, 6 and 14 on this page are redrawn from Figure 4, Table 2, Figure 3 and Table 1 of the paper; Diagram 3 substitutes different step names, Diagram 6 keeps only the proportions of the original, and Diagrams 5 and 14 are redrawn as they stand. The originals are the authors', the redrawing is original.
"Folders Over Agents" is the slogan of the Lyceum, Jake Van Clief's certification programme at Eduba ( lyceum.eduba.io). This site is not the Lyceum, is not affiliated with or endorsed by Eduba, does not teach the method for money and does not certify anyone.
"The Folder Is the Agent" by Kieran Klaassen, published by Every on 13 April 2026 ( every.to), made the same argument from inside a team building software with AI and is quoted in sections 2 and 7. Ryan McKinney's plain-English answers at filesnfolders.com are quoted in sections 4 and 9. Anthropic is quoted in sections 4, 6 and 11: "Equipping agents for the real world with Agent Skills", anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills, 16 October 2025; "Effective context engineering for AI agents", anthropic.com/engineering/effective-context-engineering-for-ai-agents, 29 September 2025; and the Claude Help Center's Cowork setup page. The use of Claude here is an ordinary paid subscription.
The house additions on this page, meaning the Human check line on every sheet, the adoption of the Verify section the paper proposes in section 6.2 but had not implemented, the first, second and fourth of the four controls (the third is the paper's own review gate, restated as a rule), and the two-file history, are added here and are not part of the published method. If they are wrong, that is a fault here and not the paper's, and you are welcome to them on the same terms as the rest.
The kit is released under the MIT licence, the same licence as the reference implementation, and its README and LICENCE files carry this credit in full so that it travels with the folder.