The Right-Click
For thirty years your operating system has answered the same question: which app opens this file? MachineFabric answers a better one: what do you want this file to become?
Right-click anything in Finder. Pick Transmute. The menu shows you destinations — verbs that describe what’s possible with this file given the cartridges you have installed. A PDF can become text, page thumbnails, an audiobook, an answer to a question. A video can become a transcript or a scene-by-scene summary. A folder of receipts can become a spreadsheet.
You don’t pick the steps. You pick the destination. The system composes the journey, every time, from the parts you have installed.
The Transmute menu doesn’t show you apps. It shows you what your file could become. If you install a new cartridge tomorrow, the same right-click on the same file shows new destinations on its own — without re-indexing, without rebuilding anything. The menu is a live read of the capability graph.
Pipelines You Didn’t Have to Design
Drop a video. Pick “transcribe.” MachineFabric finds the path on its own — extract the audio, decode it, run it through speech-to-text — and shows you the route before it runs.
For multi-step destinations, the planner draws the graph. You see the journey from input to result step by step before a single byte moves: which cartridge handles which stage, which media type flows between them, what the expected output of each step looks like. If a step is unsatisfied (a missing cartridge, a model that hasn’t been downloaded), the planner tells you which one and the menu offers to install it.
This is pathfinding through a capability graph, not general AI planning. The graph is bounded — built from the cartridges you actually have installed. The same input always resolves to the same path. The path is inspectable. There is no hidden agent picking tools at random.
How the planner gets there is the CapDAG planner and executor; how the dispatch rule decides which provider serves each step is CapDAG dispatch; how it picks the most specific match when more than one applies is CapDAG ranking. The protocol underneath is open and inspectable.
The Library
Every file you’ve added, every run that produced something from it, every result indexed for search — that’s the library. It’s what the application opens to.
A run, internally, is a typed pipeline: an input file, a destination, a route through the cartridge graph, the outputs each step produced. Runs are reproducible — the same input plus the same cap selection plus the same installed cartridges will trace the same path. Runs are inspectable — you can open one and see every step, its progress events, its memory and time spent, its output payload.
Outputs are typed too. A summary is text. A transcript is text with optional timestamps. A thumbnail is a PNG. A “make decision” output is a JSON record with a discriminated value. The library knows what each output is, so the search index can read it and the next Transmute on it knows what destinations are reachable from there.
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 LOG and progress frames over the Bifaci wire as they work; the host translates those frames into UI events for the running task; tokens-per-second, frames-per-second, percent-complete are all real readings, not animations. See CapDAG progress and logging and progress mapping for the wire-level details.
If something stalls, you see why. If something fails, you see where. Heartbeats keep stuck cartridges from hiding behind a spinner — a missed heartbeat tears the cartridge down and surfaces the failure on the task. There is no opaque green checkmark waiting for you to come back later; there’s a system that explains itself while it works.
Tasks Under Memory Pressure
Local AI runs on whatever Mac you have. Some pipelines are large; some files are larger; some models eat memory on contact. MachineFabric watches process and host memory continuously and applies graduated responses:
- Normal (under ~70% pressure): full performance.
- Warning (70–80%): logging tightens up, monitoring frequency increases.
- Pressure (80–90%): light throttling on non-essential operations, smaller queue limits.
- Critical (90–95%): running tasks can be cancelled; the scheduler stops starting new ones from
PENDING. - Emergency (>95%): heavy throttling everywhere, unused models unloaded, non-critical requests rejected.
Tasks do not have a special THROTTLED state. Under critical memory pressure, running tasks are cancelled outright and pending tasks are not started until pressure normalises — simpler than a hidden state where tasks sit in limbo forever.
LLM-specific memory is tracked separately so MachineFabric can decide which models to keep loaded and which to evict when pressure climbs. Models that haven’t been used recently are unloaded first; models actively serving a request are the last to go.
Runs on Your Machine, Period
MachineFabric is a native macOS application. There is no account to create, no key to paste, nothing to subscribe to. Files stay on your disk. Inference happens on your Mac. Disconnect the network and the only thing that changes is which models you can download — the ones already there keep working.
Sandboxed by default. Signed and notarized. Apple Silicon native. The intelligence happens here, not somewhere else’s server.
The cartridges that do the work run in a separate XPC service with no default network access. A cartridge that explicitly proxies to a cloud service can declare that and have it reviewed before being accepted; nothing speaks outward without you knowing about it. See Cartridges for the sandbox details and Contributing for the review criteria.
Where to Read Next
- Models — bring-your-own-model: paste a HuggingFace id, MLX/llama.cpp/Candle backends, model families.
- Capabilities — what the menu actually shows and how it gets there.
- Cartridges — install layout, sandboxing, code signing.
- Getting Started — build your first cartridge.