A lot of the current conversation around local AI focuses on models: which model to run, how fast it is, how much VRAM it needs, whether it is “agentic,” and how close it gets to cloud performance. Those questions matter, but I think they miss a more basic problem: local AI is still difficult to use as part of normal software workflows.

You can download a model, run a chat UI, and maybe point it at a folder. But the moment you want to do something concrete with files — convert this PDF, extract this table, summarize these documents, transcribe this audio, classify these images, turn something into structured data, then pass that result into another tool — things get messy quickly. Every app invents its own plugin model. Every workflow tool invents its own abstraction. Every “agent” framework wants to become the control room.

I think the better direction is more boring and more useful: deconstruct packaged software into small, typed utilities.

That is what I am building with MachineFabric. The idea is to treat AI-enabled tools more like Unix commands, but updated for local AI and modern file workflows. A cartridge is a focused utility: it accepts a known type of input, produces a known type of output, and can be connected to other cartridges. A PDF-to-text cartridge should not need to know about the final report. An embedding cartridge should not need to know about the UI. A summarizer should not need to own the whole workflow. Each piece should do its job, declare what it accepts and produces, and let the system compose them.

In MachineFabric, those compositions are typed DAGs between filetypes on macOS. You start with files, the system finds possible transformations, cartridges pipe into each other, and the workflow stays local, deterministic, and inspectable.

Underneath this is CapDAG, an open protocol for typed capability dispatch. It describes what a cartridge can do, how capabilities match, and how one transformation can be connected to another. The goal is not just “plugins for one app,” but a portable way to package and dispatch small capabilities across languages and runtimes.

This is also why I am skeptical of the word “agentic.” A lot of useful AI automation does not require pretending the software has agency. It requires reliable transformations, clear boundaries, and composable tools. Even complex workflows can often be described as a graph of concrete steps: extract, transform, search, rank, summarize, validate, write. That is not less powerful. It is just more honest.

My experience with LLMs is that they are very useful, but they have a reasoning ceiling. So I am less interested in putting an “agent” in the control room and more interested in building better machinery for the factory floor.

MachineFabric supports multiple local LLM backends today: GGUF, MLX, and Candle. You can paste a Hugging Face model ID, download it, and every cartridge that can use that model can pick it up. A small 0.5B model and a large 70B model become different engines behind the same capability system.

The user-facing idea is simple: right-click a file, choose what you want it to become, and let the typed graph run. Same Finder, same files, new transformations.

That is the problem I am trying to solve: local AI should not live only inside chat boxes or monolithic apps. It should be packaged as small, concrete, typed utilities that can be composed into real workflows. That is MachineFabric, and underneath it, that is CapDAG.