For thirty years your operating system has been answering the same question. You right-click a file and macOS shows you a list of apps. Open With Preview. Open With Pages. Open With QuickTime. The OS knows the file’s type. It knows which apps can open it. The choice is mechanical.

We wanted a different question.

What do you want this file to become?

Right-click a PDF in MachineFabric and you don’t get a list of apps. You get a menu of destinations. Searchable text. Page thumbnails. An audiobook. A summary. The answer to a question you have about the document. You pick where you want to go; the system finds the route.

A folder of receipts becomes a spreadsheet. A meeting recording becomes minutes. A video becomes a transcript and a scene-by-scene description. The same right-click, the same menu position, the same Finder you already use — just a different verb on it. The verb is Transmute.

This is what MachineFabric is. Not “the best macOS PDF viewer.” Not “ChatGPT for files.” It’s a different kind of menu attached to the operating system you already have, backed by a typed plugin protocol that means yesterday’s files unlock new destinations the moment you install a new cartridge tomorrow.

Pick the destination, not the steps

Drop a video. Pick “transcribe.”

Behind the scenes there are three steps: extract the audio out of the video container, decode the audio to a model-friendly format, run it through speech-to-text. You don’t pick those. You pick “transcribe.” MachineFabric finds the path on its own — and shows you the route before it runs, so the journey from your file to your result is inspectable.

This isn’t agents picking tools at random. The capability graph is bounded; the planner does pathfinding through it; the same input always produces the same path. If a destination isn’t reachable — a missing model, a format the installed cartridges don’t cover — the planner says so by name. There is no opaque “cannot do this” state.

The protocol underneath is CapDAG: an open specification for how capabilities are named, typed, and matched to requests. A cartridge declares what it accepts and what it produces; the dispatch rule (standard function subtyping, contravariant inputs, covariant outputs) decides which cartridge serves which request, and ranking picks the most specific match when more than one applies. The math is textbook; the value is that the rule is the same for every implementation, which makes routing inspectable and third-party cartridges portable.

Runs on your machine, period

MachineFabric is a native macOS application. Files stay on your disk. Inference happens on your Mac. There is no account to create and nothing to subscribe to. Disconnect the network and the only thing that changes is which models you can download — the ones already there keep working.

Cartridges run sandboxed in an XPC service with no default network access. The intelligence happens here, not on someone else’s server.

You can paste a HuggingFace model id into the model browser and watch it download. The moment it lands, every cartridge that knows how to use it picks it up — embeddings, transcription, vision, generation. Apple’s MLX, llama.cpp via GGUF, and Candle are all first-class runtimes. The 0.5B model that fits in a few hundred megabytes works. The 70B beast that wants your whole GPU works. Same surface, same Transmute menu — only the speed and the answer change.

Watch the work happen

A long pipeline shouldn’t be a beach ball. Every step shows you what it is doing right now — the page being rendered, the frame being decoded, the token being generated. Memory, throughput, time elapsed — all in plain view. Live progress is a property of the protocol, not a UI afterthought: cartridges emit progress frames over the wire as they work, and the host translates those frames into UI events for the running task.

If something stalls, you see why. If something fails, you see where. There is no opaque green checkmark waiting for you to come back later — there’s a system that explains itself while it works.

Build with it, not just on it

A cartridge is a small program. Fifty lines of Python — or Rust, Swift, or Go — and your tool joins the system. The Transmute menu picks it up. The planner routes through it. Other cartridges call it. You didn’t write a plugin; you wrote a citizen.

The SDK is open. The protocol is open. The capability registry at capdag.com is browsable. Submitting a cartridge is a GitHub issue against cartridge-shelf; proposing a new capability or media def is the same against capfab. Every submission is reviewed by hand and merged into the canonical manifest that ships with every install.

If you’ve written a Python script that parses your weird domain-specific format, or a model wrapper for a niche task — that’s a cartridge. The path from idea to installable cartridge is the kind of weekend project that ends with something real on every Mac that runs MachineFabric. The Getting Started tutorial walks through it end to end in Python.

What’s next

MachineFabric isn’t just an app. It’s a new layer of macOS, an open protocol, a modular ecosystem, and a private place for your data — all of those at once, and meaningless without all of them.

The macOS app is signed, notarized, and Apple Silicon native. The four bundled cartridges (PDF, text, embeddings, LLM) cover the spine of what most people want their files to become; the cartridge browser inside the app extends that as the registry grows. The whitepaper covers the technical design — dispatch formalism, Bifaci wire protocol, routing internals — if you want the full picture.

Download it, open Finder, pick a file you’ve been meaning to do something with — and Transmute it.