For decades the file menu has asked the wrong question.
Right-click a file and the operating system gives you a list of apps. Preview. Pages. QuickTime. Word. The file becomes a passport stamp for whatever application claims it. We think that is backwards.
Pick the destination, not the app
Most people do not care which app opens a file. They care what they need from it.
A PDF should become text. A recording should become a transcript. A folder of receipts should become rows in a spreadsheet. A screenshot should become a description. The intent is obvious. The software path is the annoying part.
So in MachineFabric we changed the question. We do not ask, “Which app opens this file?” We ask, “What do you want this file to become?” That is the whole interaction reframe. Small on the surface. Deep underneath. The Finder menu stops being an app switcher. It becomes a transmutation menu.
The old model makes you think in steps
Take a scanned PDF. In the old model you have to think like this:
- This is probably an OCR problem.
- Which app do we use for OCR?
- Open the file there.
- Run the export.
- Save the result somewhere else.
That is software making the user do routing work.
We do not want people planning toolchains in their heads for ordinary file work. We want them naming the result.
Extract text.
That should be enough.
The route should be automatic and inspectable
The moment you let people pick destinations instead of apps, you need a real routing system underneath. Not keyword matching. Not a pile of hard-coded if-statements. Not an LLM guessing which tool to call.
You need something formal. That is what CapDAG is.
Every cartridge declares what it accepts and what it produces. The host does dispatch using one rule:
- Inputs are contravariant.
- Outputs are covariant.
That sounds academic. It is not. It is just standard function subtyping applied to file transformations.
If a cartridge accepts Document, it can handle a PDF. If a cartridge produces SearchablePDF, it can satisfy a request for PDF.
That one rule is enough to make dispatch precise. No ambiguity. No hand-maintained route tables. No “works most of the time” matching heuristics. The graph resolves from type signatures.
That matters because once the rule is formal, chaining becomes reliable.
pdf -> page text -> summary
video -> audio -> transcript
image -> description -> generated text
This is the Unix pipe idea, but for typed media instead of raw byte streams.
Think pdf | ocr | summarize, except the system knows the shape of every step before it runs anything.
Cartridges do one job each
We did not build this as one giant application with every file feature glued into it. We built cartridges.
A cartridge is a small program with a tight contract. It takes a specific input. It produces a specific output. It exposes capabilities. That is it.
This separation matters. It makes the system easier to reason about. Easier to test. Easier to audit. Easier to extend.
It also keeps responsibility narrow. A cartridge does not get ambient authority just because it exists. It gets the capabilities and permissions its job requires. That is not a security story we bolt on later. It is the architecture.
Privacy falls out of the design
A lot of software talks about privacy after the fact. We wanted privacy to be the boring default.
The dispatch is local. The planning is local. The execution is local. The models run on your machine through local runtimes like MLX and llama.cpp. So the file never has to leave your Mac for the system to work.
That is the kind of elegance we care about.
A good design does not add three more settings pages to manage a problem. It removes the problem class entirely. No upload pipeline. No account requirement. No cloud round-trip just to turn one file into another.
This is a different layer of computing
We are not trying to make a better “Open With” menu.
We are trying to replace application-centric file interaction with transformation-centric computing. That is the real shift.
Files stop being objects you hand to apps. Files become starting points in a typed transformation graph.
You name the destination. The system finds the route. The route is inspectable. The execution is local. The components stay small and composable.
That is why MachineFabric feels different. It is not a context menu with AI glued onto it. It is a new answer to a very old operating-system question.