Local AI Setup Kit
Hardware sizing, the install path, model picks by memory, document grounding, the routing rule, and scripts for one daily job. Nothing leaves the machine.
A private assistant on your own computer by the end of the afternoon, with your real files, and a rule for what still goes to the cloud.
Beer Bond holder? Sign in and it is already yours.
The situation you are in
You have material you cannot paste into a chat box. Maybe a contract says so. Maybe your employer blocks it at the proxy. Maybe it is a client file, an investigation, a salary band, a draft you are not ready to hand to a vendor, or notes about a person who did not consent to being processed by anybody. So you do the work the slow way, while watching everyone else get an hour back every day.
Or you have no constraint at all and you simply want the thing to keep working — the same model, the same behavior, no per-token bill, no rate limit at four in the afternoon, no email announcing that the version your workflow depends on is deprecated in ninety days.
Either way you have heard you can run one of these on your own computer, and every guide you have found either assumes you already know what quantization is or is a fifteen-minute video where someone with a very expensive desktop says it is easy. You do not know whether your laptop can do this. You do not know which of the four hundred model files on the download page to pick. You suspect that if you spend a Saturday on it you will end up with something that answers slowly and gets things wrong, and you will have learned nothing about whether that was your hardware, your model, or your prompt.
What this kit is
The afternoon, written down. Nine chapters and eleven files that take you from "I have a laptop" to "there is a private assistant on it that does one job for me every day."
It is opinionated where opinions save you time. It says memory is the only hardware number that matters and tells you to buy memory over every other upgrade. It says start at four-bit quantization and take the bigger model, not the higher precision. It says the system prompt is worth more than the next model size up. It says paste the whole document before you build a retrieval pipeline. It says run one job for two weeks and delete it if it does not earn its keep. Where reasonable people differ, the templates leave room — but the kit takes a position rather than listing options, because a list of options is what you already have.
It is also honest about the ceiling. Chapter 1 states plainly what a model that fits in your memory cannot do, because the fastest way to abandon local AI is to expect it to replace a frontier model and discover in week two that it does not.
What is inside
- The guide. Nine chapters: why local and the honest ceiling; hardware, where memory is the number; models, sizes, and quantization in plain words; the install afternoon on all three platforms; the three settings that matter; grounding it in your own documents; what stays local and what goes to the cloud; one daily job wired to run; and keeping it running a year later. About 14,500 words.
- Sizing and picking. A hardware sizing record you fill in for your own machine, carrying the table from 8 GB to 64 GB with speed ranges, the headroom rule, and an upgrade-request section you cannot fill in on vibes. A model-pick worksheet: five questions from your memory number to one specific download, plus the twenty-minute head-to-head that actually decides it.
- Install. Separate runbooks for macOS, Windows, and Linux, each with the failures that happen on that platform — the PATH that did not refresh, the download a proxy stalls, the graphics card the runtime cannot see, the antivirus that quarantines the binary — and each ending in the record of what was installed.
- Running it well. A settings card for temperature, context length, and system prompts, with three worked cards you can steal. A document-grounding setup covering corpus discipline, the refusal instruction, the citation rule, and the ten-question acceptance test that tells you whether the answers can be trusted.
- The rule. A four-tier routing rule and a six-step redaction path, both written to be marked up by your security reviewer rather than adopted silently, with sign-off blocks.
- The daily job. Daily-job scripts in two versions — a fifteen-line shell script and an HTTP API version that returns JSON — plus the prompt files, the scheduling notes for each platform, and the two-week tally with a kill criterion you commit to in advance.
- Maintenance. A troubleshooting checklist with the diagnostic order, thirteen symptoms and what each one actually is, a twenty-minute monthly list, and the yearly hour.
- START-HERE. One page that tells you what to read depending on whether you have an hour, an afternoon, a day, or a week, and which file to open at which moment.
Every template uses [BRACKETED PLACEHOLDERS] for your specifics and carries a "How to adapt" note. They are plain markdown, so they paste into a word processor, a wiki, or a ticket without fighting formatting.
Who wrote it and why he can
Wayne Bridges, a public-sector solutions engineer who builds and runs AI agent systems daily. The guidance about what these models do, where they break, and how much memory it actually takes comes from running them, not from reading about them. The chapters on the ceiling and on grounding exist because both lessons were learned the expensive way.
He is not an attorney. The chapters that touch licensing, confidentiality obligations, or organizational policy say so at the top and are built to be reviewed by the person who owns that risk.
What this is not
- Not a benchmark roundup. No leaderboards, no numbers that cannot be supported. Speeds are ranges. The kit teaches you to run your own ten prompts against two models in twenty minutes, which beats any comparison written by someone with a different machine and a different job.
- Not a promise that local replaces the cloud. It is the opposite. The routing rule is a core deliverable precisely because the two-tier habit is what makes this survive past month one.
- Not a fine-tuning or model-training course. You will download weights and prompt them well. Training is a different project with a different budget.
- Not legal or compliance advice. The routing rule is a draft for your counsel and your security team, not a substitute for them.
- Not a permanent list of the best models. Model names move monthly. Chapter 3 teaches you to read any model name and pick from your own memory number, which does not expire.
Who should not buy this
- Anyone with an 8 GB machine who wants frontier-quality answers. Chapter 2 will tell you honestly what you get, and it is not that. Better to know now.
- Anyone who will not open a terminal. There are graphical front ends and the kit covers one, but the install, the scripts, and the troubleshooting all assume you can paste a command and read what comes back.
- Anyone looking for a zero-maintenance appliance. This is twenty minutes a month, forever.
- Anyone who needs this to satisfy a specific regulatory obligation. That conversation starts with the person who owns the obligation. Bring them chapter 7; do not bring them a download.
If you have a machine with 16 GB or more, work that involves text, and a reason — a rule, a contract, or just a preference — that the work should not leave your desk, this is for you. Read the sizing table, pick your model, and give it an afternoon.
- People who cannot paste their work anywhere — regulated, under contract, confidential, or just private — and want AI assistance anyway.
- Technical-enough owners of a recent laptop or desktop who have never run a model and do not want to spend three weekends finding out which guide was wrong.
- IT admins standing up a local option for a team, who need a sizing table, an install path that works on all three platforms, and a routing rule they can defend in a meeting.
- A sizing table that maps your machine's memory to a model size and an expected speed, stated in ranges, so you know what you can run before you download anything.
- A step-by-step install on macOS, Windows, and Linux with one open tool and one model family, plus the eight failures that actually happen and what each one means.
- Document grounding: feeding it your own notes and files, keeping it honest with a refusal instruction and mandatory citations, and a ten-question test that tells you whether to trust the answers.
- A routing rule — local versus cloud — in four tiers you can write on one page and defend, with a six-step redaction path for the half that leaves.
- Scripts and prompts for one daily job, wired to run on a schedule, with the two-week test that decides whether you keep it or kill it.
- 9-chapter guide, about 14,500 words, from what local actually gets you through keeping it running a year later
- 11 editable templates in plain markdown. Sizing and picking: hardware sizing record with the 8 GB-to-64 GB table, model-pick worksheet. Install: macOS runbook, Windows runbook, Linux runbook. Running it well: settings card, document-grounding setup with the ten-question acceptance test. The rule: routing rule, redaction path for the cloud half. Daily use: daily-job scripts (shell + HTTP API + the prompt files), troubleshooting and maintenance checklist.
- The Hardware Sizing Table as a standalone one-pager — the free piece, yours to hand to a colleague
- A START-HERE map with one-hour, one-afternoon, one-day, and one-week paths, and a table of which file to open at which moment
- Every template uses [BRACKETED PLACEHOLDERS] and opens with a 'How to adapt' note; the seven that touch licensing, confidentiality, organizational policy, or a spend approval carry a disclaimer and are built to be reviewed
- Working scripts for one daily job in two versions — a fifteen-line shell script and an HTTP API version that returns JSON — plus the prompt files and the two-week tally that decides whether to keep it
9 chapters · 11 template files · read on the site or download the zip.
The Hardware Sizing Table
One page that tells you which model your machine can actually run, and how fast. Free, no login.
- Why local, for whom, and the honest ceiling — What running a model on your own machine actually gets you, which three reasons hold up and which three do not, and a plain account of what a model that fits in your memory cannot do.
- Hardware: memory is the number — Fast memory decides which models you can run and how fast they answer. How to read your own machine, a sizing table stated in ranges, and the three hardware mistakes that cost money for nothing.
- Models: families, sizes, quantization in plain words, and how to pick — How to read a model name, what the B and the Q mean, the one trade that matters most, and a five-question path from your memory number to a specific model you should download first.
- Install, download, talk: the afternoon — The ninety-minute path from nothing to a working local assistant on macOS, Windows, or Linux, with the eight failures that actually happen and what each one means.
- The three settings that matter — Temperature, context length, and the system prompt account for nearly all the difference between a local model that feels useless and one that feels sharp. What each does, what to set it to, and the two secondary knobs worth knowing.
- Your own documents — Two ways to put your files in front of a local model, why you should start with the crude one, how retrieval actually fails, and a ten-question test that tells you whether to trust the answers.
- What stays local and what goes to the cloud — A four-tier routing rule you can write on one page and defend in a meeting, a redaction path for the half that leaves, and an honest list of what running locally does not get you.
- One daily job, wired — Choosing the single job worth automating, the four-part shape every local automation takes, working scripts for the command line and the HTTP API, and the two-week test that decides whether you keep it.
- Keeping it running: updates, disk, and when to move up a size — A twenty-minute monthly window that keeps a local setup healthy, where the disk actually goes, the three signals that justify buying memory, and when to admit a job does not belong on your machine.
What kind of machine do I need?
Sixteen gigabytes of memory is the comfortable floor and gets you a genuinely useful assistant. Eight works for small models and narrow jobs, and chapter 2 is honest about what you get. Anything with 24 GB or more is a good experience. The sizing table covers Apple Silicon, discrete graphics cards, and CPU-only machines separately, because the number that matters is different on each.
Will a local model be as good as the ones I pay for?
No, and the guide says so in chapter 1 rather than burying it. A model that fits in your memory is worse at hard reasoning, obscure facts, and long multi-step work. It is very good at transformation, extraction, summarizing what you hand it, classification, and first drafts — which is most of the daily volume. That is why the kit includes a routing rule instead of pretending local does everything.
Does this name specific tools, or is it all theory?
It names the open tools you have to actually install and the open-weight model families you will meet, because you cannot follow an install walkthrough for an unnamed program. It does not rank products, cite benchmark numbers it cannot support, or recommend a paid service. Speeds are given as ranges, because they depend on your machine's memory bandwidth more than anything you can configure.
Is this legal or compliance advice?
No. The author is a solutions engineer, not an attorney. The chapters that touch law, licensing, or organizational policy carry a disclaimer and are written so you can bring a draft to your counsel, your security reviewer, or whoever owns the risk — not so you can skip them. Running a model locally removes one risk. Chapter 7 lists plainly what it does not remove.
How long does it take?
An afternoon to get a model answering questions on your own machine — about ninety minutes of it is downloading. Another evening to point it at your documents and build the honesty test. An hour to wire one daily job. After that, about twenty minutes a month, and chapter 9 is the checklist.
What happens when the tools and models change?
Written September 2026 against the runtimes and open-weight families available then. Model names move fastest, the install path and the concepts move slowly, and chapter 3 teaches you to read any model name rather than memorizing one. One payment. When the kit is revised, the current version is what you see and download from your account.
What is the refund policy?
30 days, no questions. If it does not save you a week, email and you get your money back.
Can I share it with my team?
Yes. The license covers organization-internal use: your team, your admins, your security reviewer, and the people whose machines you are setting up. It does not cover reselling it, posting it publicly, or distributing it to other organizations. If someone at another company wants it, send them the link.
Local AI Setup Kit. $29, once.
Card through Stripe. Yours the moment it lands: read it here, download the zip, keep it. Or a Beer Bond: every deal and every product, for life.