Fabric — 265 ready-made instructions for your model, from the command line

Fabric — 265 ready-made instructions for your model, from the command line
What it does
You have a model. It knows how to write, summarize, explain. And yet every time you start from a blank page: you write the instruction, you correct it, you rewrite it. The model does not have a capability problem. It has a problem of integration into your daily work.
That is where Fabric steps in. It does not give you another model. It gives you ready-made instructions, written and refined by people, which you download to your computer and run with one command. It calls them patterns. The repository is github.com/danielmiessler/fabric, with an MIT license, 44,349 stars, 4,307 forks and 4,308 change entries. The tool opened in January 2024, and the last push was on 18 October 2026. In other words, it is alive and worked on every day.
An instruction is a small text file. Inside it tells the model what role is being asked of it and exactly what to output. One instruction says “summarize this text in three paragraphs.” Another says “pull out the decisions and next steps.” Another “judge this argument.” Fabric downloads 265 such instructions to your folder, keeps them there, and does not ask for them from the internet again. They are yours now.
Around the instructions there is a command-line program, fabric. It takes text from input, passes it through the instruction you choose, sends it to the model you have declared, and returns the answer to you. You can also run it as a local server that accepts requests over the network, so you can call it from other programs.
The catalog is not only for text. The instructions cover summarization, idea extraction, code explanation, argument critique, and even transcription from a YouTube video, which Fabric pulls itself with one flag. And you can write your own instructions and put them in the same folder; the program sees them the same way, without distinguishing its own from yours. That is where the point lies: it does not lock you into its catalog.
There is one point I should say immediately, because our audience expects MCP everywhere. Fabric is not an MCP server. We checked the repository: 1,330 files, not a single mcp file. That means it does not go into Claude Code or Cursor as a tool that calls the model on its own inside the conversation. It comes in as a command. How exactly, I explain below in order.
What it does not do
It sees only what you give it — it will not work as an embedded component inside an assistant. It is not a tool that “goes into” an assistant as MCP or as a cohesive part of the conversation. If you expect to add it to a chat window and have the model use it automatically, you will be disappointed. It is CLI: you call it with a file and get a result. It does not keep continuous state inside a conversation.
It does not add knowledge to the model. The instructions are templates. Fabric simply sends them to the model you have configured. If you want project history, “memory” or a knowledge base that grows automatically, you have to build that around it yourself. It also does not do complex orchestration by itself: complex pipelines or connections between many steps need scripts or external automation.
It does not host models nor provide a GUI. It does not automatically encrypt sensitive data: whatever you send goes to the provider you set with your keys. Some patterns depend on external tools (for example transcription), which may break or require extra setup. Check the token limits and privacy policy before you give it secret data.
Who it is for
For anyone who uses models for repetitive work. Article summarization, cleaning text, extracting ideas from a transcript, critiquing a plan, translation with style. If you do even two of these regularly, Fabric saves you from rewriting the same instruction every time.
You do not need to know programming. The basic use is one command with the name of the instruction, and the text comes in from a file. You read the result with your eyes.
It fits especially well for anyone who works from the command line, because that is where it feels at home. And for anyone who wants their instructions to stay theirs, in their own folder, without asking any cloud for them again.
It makes no sense if you work exclusively inside a graphical environment and never touch a terminal. It makes no sense if you have already built your own collection of instructions and maintain it. And you must not confuse it with a tool that adds knowledge to the model: Fabric knows nothing about your project, it simply gives you good questions.
One example to tie it together. You take the transcript of a meeting, forty minutes of text. You run the idea-extraction instruction, and it gives you fifteen lines with the decisions. The same text, with another instruction, becomes an update email to the team. You did not rewrite a single instruction; you chose two names from a catalog.
Installation
The installation happens once. On Windows the official route is Winget, Microsoft’s tool:
winget install danielmiessler.Fabric
I am reproducing it as the maker gives it; I did not run it through Winget, I downloaded the Windows binary file (103 MB) from the releases and ran it directly. It worked the first time.
Check that it was installed correctly:
fabric –version
For us it returned v1.4.526, the latest release, published on 18 October 2026 at 21:17 UTC. If you see an older number, download again from the releases.
The first real command is setup:
fabric –setup
This asks you to choose a provider and enter keys, and creates the settings folder for you. The folder is ~/.config/fabric/, and that is where everything lives.
After setup, you download the instructions to your disk:
fabric -U
For us that took 24.3 seconds and downloaded 2 MB with the 265 patterns. From then on it is local and does not download again.
To see what you got:
fabric -l
The list of all 265 names prints on the screen. Read it once — it is the catalog of the jobs you can request.
One trap, from the start. On npm there is another package also called fabric. It is not this one. It is Fabric.js, a canvas drawing library for websites (npm). Anyone who runs npm install -g fabric gets another tool and will then wonder why it does not work. Fabric is installed from the repository releases, or via Winget, or via Scoop.
Use in every LLM
Fabric is not MCP, so you do not “add” it to an assistant with a setting. You use it from the command line, and assistants that have terminal access call it like any other command.
The basic way is one pattern and a piece of text on input. The text must be in a file, not inside the command; I explain why in the Test section.
See the flow first in plain form. You write your text to a file, and then:
fabric -p summarize < keimeno.txt
For us it returned a clean summary in Greek. The same job through the local server took almost half the seconds.
Claude Code
Claude Code is an assistant that runs in your terminal and can execute commands. Because Fabric is a command, Claude Code calls it like it would any other program. You tell it, inside the conversation, to pass a file through one pattern:
fabric -p extract_wisdom < shmeiwseis.txt
And it reads the result back itself. There is no registration in any MCP configuration file, because there is no MCP here.
There is also the reverse relationship, and it is interesting. Fabric can use Claude Code as a backend engine, through your Claude subscription and the local CLI (README). In other words the two tools go inside one another. I read that in Fabric’s documentation, I did not run it, because we do not have a Claude subscription on this machine.
Codex CLI
Same logic. Codex CLI runs in the terminal, so it calls Fabric as a command inside its workflow. An example:
fabric -p explain_code < kommati.py
So you put it in the same basket as any other command-line program; there is no separate integration.
And here too there is the reverse relationship. Fabric supports OpenAI Codex as a provider, through your subscription, from version v1.4.437 in March 2026 (releases). So you can have Fabric talk to Codex, and Codex call Fabric. What I did not run, I state clearly: we do not have Codex CLI here.
Cursor
In Cursor the story is cleaner, because Cursor knows MCP — and that is exactly where Fabric loses, since it has no MCP. There is no “add the Fabric server” option. The route is this: you open the terminal built into Cursor, and run the command from there.
fabric -p summarize < keimeno.txt
Cursor’s assistant, if it has permission to run commands, calls it and reads the result. My own estimate is that this is enough for most people; I did not run it in a real Cursor instance, because we do not have one here.
The local server
If you want Fabric to listen on an address instead of running once and closing, you bring it up as a server:
fabric –serve
The server starts on the default address :8080 and accepts requests over the network. You can close it behind a key with the –api-key option, and set another address with –address (README). That is where the whole meaning of “use in every LLM” comes in: any program that can send a request to a local port can ask Fabric.
One warning we saw with our own eyes. When the server starts without a key, it says itself that it is running exposed, and if you do not give it a key it does not answer correctly. In other words the option is not decorative.
Where it wins, where it loses
It wins because it solves the integration problem, not the capability problem. The model already knows how to summarize. Fabric gives it the right question, ready-made, 265 times.
It wins because the instructions are yours. They are downloaded once, stay in your folder, and you do not depend on any service to read them.
It wins because it is open, under MIT, and speaks to many providers — from OpenAI and Anthropic to OpenRouter, Ollama, DeepSeek and others. It does not lock you into one.
And it wins because it gives one command, not an environment. You can put it in a pipeline with other programs and it works.
It loses because it is not MCP. In a world that is learning to add tools with one config line, Fabric asks you to call it yourself, as a command. The model does not call it by itself.
It loses in setup. On first run it expects the ~/.config/fabric/.env file. If it is missing, the program gets stuck or throws a message instead of working. It does not say “come on, create the file first”; you have to know that.
It loses with Greek if you pass it wrong. When we sent Greek text through an embedded curl command inside git-bash, it reached the model corrupted. From a file, it passed correctly. So the rule is one: the text goes into a file, not into the command.
It loses because it moves so fast that it forces you to keep up with updates. Five releases in three days — from 15 to 18 October 2026 (releases). Good sign of vitality, bad for anyone who forgets to update it.
And one comparison with what we have seen in this column. Most of the tools we covered — Context7, Basic Memory, MarkItDown — go into the assistant as MCP servers. Fabric goes the other way. It does not sit inside any assistant; it stands beside them, on the command line. It is the first entry in the automation column, and rightly so, because it does something no MCP does: it gives you a ready-made, local catalog of good questions.
Test
What follows we ran on Windows. I downloaded the Windows binary file, 103 MB, and ran it. Then fabric -U downloaded the 265 patterns in 24.3 seconds, 2 MB, into the ~/.config/fabric/ folder.
The total disk space after installation was 133 MB. That is how much the tool takes: about two mobile-phone photos.
The real test was with Greek text in a real model. First through the command line:
fabric -p summarize < keimeno.txt
It worked cleanly, with 15.9 seconds to answer. Then the same request through the local server:
fabric –serve
The same job took 8.4 seconds. The server came up and answered while holding 59.2 MB of memory. In other words the server route is about twice as fast, and its memory cost is small.
The cost in text, from the real numbers. One summary charged 263 input tokens and 4,108 output tokens. With OpenRouter prices for the model deepseek v4.1 flash, as read today, that is 0.00034 dollars. In other words three thousand jobs for one dollar, if you keep it on that model.
And the check that interested us most. We opened the repository and counted the files. 1,330 files, not one mcp file. So it is confirmed from its own guts as well: Fabric is not an MCP server. It is a program and instructions.
Let me also say what we did not test. I did not run Claude Code, Codex and Cursor from beginning to end, because we do not have them all here; their route was tested as a command, not inside each program. I did not test installation through Winget, only the binary file. And I did not touch the reverse relationship, where Fabric calls Claude or Codex, because it requires a subscription.
What it costs
Fabric is free — MIT, no subscription, no account. You only pay for the model you give it, and you pay with your own pricing.
Money. One text summary charged 263 input tokens and 4,108 output tokens — that is 0.00034 dollars with OpenRouter pricing on the deepseek v4.1 flash model, the prices I read on 19 October 2026. One thousand such summaries cost about a third of a euro. Fabric does not make the cost; the model you assign to it does.
Space. 133 MB on disk after installation, of which 103 are the program itself and 2 are the 265 patterns. It is not light for a command-line tool, but it is not a beast either — it is one executable file.
Memory. Its local server came up and answered with 59.2 MB. It stays in memory only while you keep it open; the command line itself leaves nothing behind.
Time. Downloading the 265 patterns took 24.3 seconds — once. The same job took 15.9 seconds from the command line and 8.4 seconds from the local server, because there the model does not warm up from scratch each time.
Context. Here is its real gain: you do not load a tool library, you load one pattern at a time — a few hundred words. An MCP tool with ten functions is paid for in every message, even when you do not touch it. Fabric is paid only when you call it, and only for the piece you called.
The hidden charge. Five releases came out in three days. You do not pay in money, but in attention: a tool that moves like this needs updating, and updating does not happen on its own. If you leave it for six months, you will have to relearn it from the beginning.
The cost verdict. For someone who already runs agents, Fabric is among the cheapest bets they can make: zero euros for the tool, fractions of a cent for use, and the context you save you gain in every message. The expensive part is not the program — it is the time you will spend learning to write your own patterns.
Verdict
Fabric is not magic in a box. It is a simple, fast tool that solves a real problem: the model knows what to do, you do not know what to tell it. With 265 ready-made instructions and one command, the problem disappears, and for free.
Its strength is the cost-to-benefit ratio. 133 MB on disk, 24.3 seconds to download all the instructions, 0.00034 dollars per summary. There is almost nothing to lose by trying it.
The objections are specific. It is not MCP — 1,330 files confirm it — so it does not go into Claude Code and Cursor as a tool, only as a command. It needs the ~/.config/fabric/.env before the first run, otherwise it gets stuck. And with Greek, it needs care: the text in a file, never in the command.
If you work even a little from a terminal and use models daily, install it today. Download it from the releases, run the setup, download the patterns, and try a summary on one of your own texts. It is the cheapest improvement you can make in your workflow.
Score: 8.4/10.
See also
In the same category we also tested:
gws: all Google services with one command, from the command window
worktrunk: two jobs at the same time, without one stepping on the other
lefthook: the checks you forget become automatic, and run in parallel
Sources: repository https://github.com/danielmiessler/fabric · releases https://github.com/danielmiessler/fabric/releases · installation instructions https://github.com/danielmiessler/fabric#installation · local server https://github.com/danielmiessler/fabric#rest-api-server · supported providers https://github.com/danielmiessler/fabric#supported-ai-providers · other package with the same name on npm https://www.npmjs.com/package/fabric · OpenRouter prices https://openrouter.ai/