Chapter 11 — Frontier vs Local: Cloud Power and Private AI

“There is no cloud — it’s just someone else’s computer.” — IT maxim (widely reproduced on stickers and posters; author unattributed)

“O Timothy, guard the deposit entrusted to you.” — 1 Timothy 6:20 (ESV)

Why This Matters

For ten weeks you have reached for AI the only way most professionals ever have: you open a tab, you type into a box, and a model somewhere in a data center answers you. That model is frontier — the biggest, smartest, newest thing the industry has built. It is genuinely astonishing, and it has a cost you have been paying without always noticing. Your words left the building. They traveled over the internet to a company’s computer, were processed there, and came back. For “write me a LinkedIn post,” that is a fine trade. For “rewrite this employee’s medical-leave letter,” it may be a fireable one.

This week we put the second option on the table. There is another way to reach a model: run it yourself, on your own laptop, where your words never leave the machine. These are local models — and the tools to run them (Ollama, LM Studio, Jan, GPT4All) got good enough and easy enough, somewhere around 2024–2026, that an ordinary professional with an ordinary laptop can now hold a private conversation with a capable AI that no company ever sees. That changes what you are allowed to do. Some of your most valuable work — the parts that touch names, health, money, students, secrets — has been off-limits to AI because you couldn’t safely send it to the cloud. Local AI is how that work comes back onto the table.

So this is not a chapter about a bigger toy. It is a chapter about a fork in the road you will stand at every single day: for this task, do I reach for the frontier cloud model — maximum capability, at the price of sending my data away — or the local model — maximum privacy, at the price of a smaller, slower brain? Neither answer is always right. The professional skill is knowing which fork, when, and being able to defend the choice.

Underneath the practical question sits an older one, and it is this week’s real subject. The data you handle is not yours. The client’s financials, the patient’s chart, the student’s record, the colleague’s review — these were entrusted to you. Scripture has a word for a thing placed in your keeping that belongs to another: a deposit. Paul’s charge to Timothy is exactly the charge on your desk: “guard the deposit entrusted to you” (1 Timothy 6:20, ESV). The question this week asks you to answer with your own hands is: what does it mean to treat private data as a trust, not a convenience? Convenience says paste it, it’s faster. Trust asks where is this going, and did the person who gave it to me agree to that?

And so the spine rule of this whole book bends to fit the week:

You choose the venue. You own the verdict. The cloud gives you power; the laptop gives you privacy; you decide which the task deserves, and you answer for the choice. AI is an assistant — brilliant in the cloud, private on your desk — never an authority that gets to decide, on your behalf, where someone else’s secret is allowed to go.

Coach’s Note — If you take one sentence out of this chapter, take this: the biggest model is not always the right model, and the free tool is not always the private one. Most of the mistakes I see professionals make with AI in 2026 are one of those two confusions. We are going to dissolve both.

11.1 — Two Doors to the Same Kind of Machine

Every AI conversation you have goes through one of two doors, and it is worth drawing them plainly because most people have only ever walked through the first.

Door 1 — the cloud. You type; your words travel over the internet to a company’s servers; a very large model runs there; the answer travels back. ChatGPT, Claude, Gemini, Grok, Perplexity — every consumer assistant you have used is this door. The machine doing the thinking is someone else’s computer, which is precisely what our first epigraph is warning about. That is not a scandal; it is a trade, and often a good one. But it is a trade.

Door 2 — local. You download the model’s “weights” — the giant file that is the trained brain — onto your own machine once, and from then on the model runs there. Your words go from your keyboard to your own processor and back. Nothing leaves. No internet required after the download. No company sees the conversation, because there is no company in the loop.

The rest of the chapter is really just this table, unpacked and made usable. Hold the shape of it. Cloud buys capability with your privacy; local buys privacy with capability. You are learning to spend the right currency for the job.

11.2 — Frontier Cloud Models: The Biggest, Smartest, Newest

“Frontier” is the industry’s word for the models at the leading edge — the ones a lab has to build a data center to run. As of mid-2026 that tier includes Anthropic’s top Claude models (claude-opus-5, and the creative-frontier claude-fable-5), OpenAI’s gpt-5.6 family, Google’s gemini-3-pro, and xAI’s Grok — names and version numbers that will have moved by the time you read this twice, which is exactly why you pin the capability, not the SKU. What they share is scale: hundreds of billions of parameters, context windows that reached roughly a million tokens on the flagship Claude and Gemini models (a whole contract, report, or small book in one go), and the sharpest reasoning available anywhere.

Here is what that scale buys you, honestly:

• Raw capability. On the hardest tasks — long-document analysis, careful multi-step reasoning, nuanced writing — nothing on your laptop will match a frontier model in 2026. If the task is hard and the data is not sensitive, this is the right door.
• Newest features first. Native image and video understanding, voice, agentic “computer use,” huge context — the frontier is where these land first.
• Zero setup. Open a tab. No download, no hardware, no maintenance.

And here is the bill, which comes in three parts:

• Privacy exposure. Your input leaves your building and is processed on a vendor’s computer. Consumer free tiers may use what you type to improve their models unless you turn that off (and sometimes you can’t). (A vetted institutional cloud tool is the exception — more on that, and on Concordia’s BoodleBox, in §11.5.) This is the whole reason the second half of this chapter exists.
• Subscription and usage cost. The best tiers cost money — commonly around $20/month for a consumer “Pro/Plus” plan as of mid-2026, with heavier “Max/Ultra” tiers well above that. Exact numbers move constantly; check the vendor’s pricing page rather than trusting a figure printed in a book. Free tiers exist and are genuinely capable, but they are rate-limited and often run a smaller model.
• Internet required. No connection, no model. On a plane, in a rural clinic, in a secure facility with no outside network — the frontier is simply gone.

Coach’s Note — Notice that two of the three costs — privacy and internet — have nothing to do with quality. A model can be the smartest on earth and still be the wrong choice because your data isn’t allowed to leave, or because you’re offline. Capability is one axis. It is not the only one, and this week it is not even the most important one.

11.3 — Local Models: The One That Never Leaves Your Laptop

A local model flips every one of those costs into a benefit — and pays for it in capability. You download the model once; after that it lives on your machine and answers you with the internet turned off. The conversation is yours. As of mid-2026, four consumer apps make this genuinely easy, and you do not need to be technical to use any of them:

What local buys you:

• Real privacy. The data never leaves the machine, which means whole categories of work — confidential and regulated (§11.5) — are back on the table.
• Free per use. After the download, there is no per-question cost and no subscription. Run it ten thousand times; the bill is your electricity.
• Offline. Airplane, cabin, locked-down facility — it works with the Wi-Fi off.
• No rate limits. It’s your machine; use it as hard as it will go.

And the honest cost:

• Usually less capable. The models you can run at home (typically 1–8 billion parameters — think Meta’s Llama 3.1 8B, Mistral 7B, Qwen3, or Microsoft’s Phi; bigger open-weight options like gpt-oss-20b or Llama 4 Scout exist for machines with far more memory) are smaller than the cloud giants. They draft, summarize, and answer well; they will not match a frontier model on the very hardest reasoning.
• Limited by your hardware. A model only runs well if it fits in your machine’s memory (that’s §11.4). Ask for one too big and it crawls.
• A little setup. You install an app and download a model once. Minutes, not a degree — but not zero.

Coach’s Note — For readers who can’t install anything. Many work laptops are locked down: no admin rights, no installing apps. That is fine, and you are not excused from this chapter. You can experience the entire frontier-vs-local tradeoff using only your browser: run each task once on a frontier cloud model (say gpt-5.6 or claude-opus-5) and once on a small, free cloud model (a “mini/nano/flash” tier, or a free DeepSeek/Qwen chat). The small model stands in for local — it shows you the capability gap without an install. In BoodleBox (Concordia’s licensed platform — sign in at box.boodle.ai) you don’t even need two tabs: start one chat, type @ to open the bot picker, and add both a frontier model and a smaller/faster one (exact names move — as of 2026 you’ll see a top Claude or ChatGPT model alongside lighter options); a multi-bot chat runs your one prompt through both so you can compare side by side. (Fallback: no BoodleBox access? Open one frontier free tier and one small free model in two browser tabs — same comparison.) You lose the privacy benefit (both are still cloud), so for the privacy lessons you’ll reason about where the data would go rather than prove it. Every lab and the project this week include this cloud-only path. See Appendix A for the no-install setup.

11.4 — How a Laptop Runs a Model: Quantization in Plain English

Here is the single fact that decides whether a model runs on your machine: can it fit in your memory? A model is a huge pile of numbers (its “weights”), and to run, that pile has to fit in your computer’s fast memory (RAM, or a graphics card’s VRAM). Too big to fit, and the machine “swaps” pieces to the slow disk and grinds to a crawl. So the whole question is size, and size is governed by two things you can actually estimate on the back of a napkin: how many parameters the model has, and how many bits each one is stored in.

The rules of thumb (all approximate, all mid-2026):

• ~2 GB per billion parameters at full precision (FP16 / 16-bit).
• ~1 GB per billion parameters at 8-bit.
• ~0.5 GB per billion parameters at 4-bit.

That second lever — the bits — is quantization, and it is the trick that put AI on your laptop. Quantization means storing each number with fewer bits, like saving a photo as a smaller file. A little detail is lost; the picture is still clearly the picture. Squeeze a model from 16-bit down to 4-bit and it takes a quarter of the memory — with only a small, usually acceptable, drop in quality. The common consumer sweet spot has a technical name you’ll see in download menus, Q4_K_M (roughly 4.5 bits per weight); go lower (Q3, Q2) and you save more memory but the model gets noticeably worse at reasoning and math; go higher (Q8, FP16) and it’s near-perfect but big.

Now do the math you actually care about:

Add roughly 15–20% overhead on top for the conversation itself (the model’s short-term memory grows as the chat gets longer). The lesson lands in one line: quantization is why a 7B model that would need 16 GB at full precision runs comfortably in ~4–5 GB on your laptop. It is the compression that made private, personal AI possible — and it is also why your laptop tops out at “good,” not “frontier.” The 405B giant that fits in a data center will never fit on your desk, and that is the trade in a nutshell.

Coach’s Note — You will never do this arithmetic in front of a client. But carry the instinct: bigger models are better and heavier, quantization trades a little quality for a lot of room, and your laptop has a ceiling. When a download menu offers you “8B” or “70B,” you now know why one runs and one doesn’t.

11.5 — The Choice That Isn’t About Capability: When Privacy Forces Local

Most of this chapter frames cloud-vs-local as a tradeoff — power against privacy — where you weigh both sides. But there is a whole category of work where there is no weighing to do, because the data is not allowed in the cloud at all. For that work, local (or a formally vetted enterprise tool) isn’t the better option; it’s the only option. Capability doesn’t enter into it.

Use the four-tier ladder from your starter guide, code/data-sensitivity-guide.txt:

The test to tape to your monitor: if this text were on tomorrow’s front page with my name on it, who gets hurt? If the answer is “a specific person” or “my employer, badly,” you are in the bottom two rows, and the cloud door is closed. Pasting a patient’s chart into a consumer chatbot is a likely HIPAA violation. Pasting a student’s records is a FERPA problem. Pasting a client’s confidential financials is a breach of the trust that is your whole job. The frontier model’s brilliance is irrelevant — a locked door is locked no matter how nice the room behind it.

The vetted middle — and what it means at Concordia. Look again at the table: the bottom rows don’t say “no cloud, ever” — they say no consumer chatbot. Between a random public cloud tool and your own laptop sits a third door: a cloud platform your institution has formally vetted under a data agreement — contractually bound not to train on your input, and certified against the compliance bars the work demands. For Concordia people that vetted middle is BoodleBox, the AI platform the university licenses (sign in with your Concordia account at box.boodle.ai). As of 2026 it is FERPA-compliant, SOC 2-certified, and does not train on your data — which is precisely why it, and not a consumer chatbot, is the appropriate home for Concordia coursework and confidential work content. So read the “vetted tool” in the table concretely: for confidential business writing and FERPA-style student records, BoodleBox is the answer. (For anything under a stricter regime — HIPAA-level health data especially — don’t assume; confirm the specific tool is covered by an agreement before that data goes anywhere at all.) And keep local for the maximum-privacy end: data that must never leave a machine you control still belongs on your own hardware, where nothing leaves because there is no company in the loop. Public work → anywhere good; Concordia’s private-but-vetted work → BoodleBox; the truly untouchable → local (or no AI at all). Placing each task on that spectrum is this week’s whole skill.

This is the moment local AI earns its keep. Before it was easy to run a model privately, this work simply couldn’t use AI, and professionals either did it the slow way or (worse) quietly pasted it into a chatbot and hoped. Now there is a right answer: run it on your own machine, where the deposit entrusted to you never leaves your keeping. That is not a limitation you are working around. That is stewardship, made practical. (The deeper legal one-paragraph explainers — HIPAA, FERPA, GDPR — live in Appendix C.)

Coach’s Note — “But local isn’t automatically safe either” — correct, and important. A local model is private only if the machine is really yours, your notes aren’t auto-syncing to a cloud drive, and nobody’s screen-recording the session. Local removes one big risk (the cloud), not all of them. Privacy is a discipline, not a checkbox. We drill exactly this in Chapter 14.

11.6 — The Same Task, Two Places: Running the Showdown

The only way this stops being theory is to run one task in both places and look at the difference. That is your project this week and the shape of it is simple: pick a handful of real tasks, run each on a frontier cloud model and on a local model (or the free-small-cloud stand-in), and score three things — quality, speed, and privacy.

A worked example, so you know what you’re looking for. Take the task “summarize this three-page benefits memo into five bullet points.”

Your starter worksheet, code/cloud-or-local.csv, is built for exactly this. Each row is one task; you fill in its sensitivity tier, its volume, whether it needs the very newest capability, whether you’re ever offline for it — and then the recommended venue and, crucially, why. Six example rows come filled in; the rest are yours. By the time the sheet is full, you’re not choosing cloud-or-local by vibe anymore. You’re choosing by a defensible rule you could hand to a colleague.

The pattern that will emerge, almost every time, is this: route by sensitivity first, capability second. Ask “where is this data allowed to go?” before you ask “which model is smartest?” The smartest model is worthless if the data can’t legally reach it. Only within the allowed venues do you then optimize for quality, speed, and cost.

11.7 — The Bridge Between the Two Worlds (One Sentence)

You will hear a phrase — “OpenAI-compatible endpoint” — and I want you to understand it in one plain sentence, because it is the quiet thing that makes local AI practical:

Most local runners answer at the same web-address format that OpenAI’s cloud uses, so an app built to talk to ChatGPT can be pointed at the model on your own laptop by changing one setting — the address — and nothing else.

That’s it. That’s the whole idea. Ollama, for instance, quietly listens on your own machine (at an address ending in port 11434), speaking the same “language” the cloud speaks. So a writing app, a note-taker, or a browser extension that was built for ChatGPT can often be redirected to your private local model just by swapping the address — no rebuilding, no coding. Practically, it means the ecosystem of AI tools isn’t locked to the cloud: the same tool can run public work on the frontier and private work on your laptop, and switching between them is a settings change, not a new career. You don’t need to do any of this by hand — you just need to know it’s possible, so that when a tool offers a “local model” or “custom endpoint” option, you know what it means and why it’s a gift to your privacy.

11.x — Interactive Lab: Cloud-or-Local Decider

Below this chapter on the website you’ll find an interactive panel called the Cloud-or-Local Decider. Go use it now — it’s not decoration, it’s the rep that turns this week’s judgment into a reflex.

The Decider asks you a short series of questions about a task — How sensitive is the data? How much of this do you do? Do you need the very newest capability? Are you ever offline? What hardware do you have? — and then gives you a recommendation: frontier cloud, local, or either (with a note when a free/small cloud tier is the right fit), and the reason. Run it against several of your own real tasks. Try to make it change its mind: take a task it sends to the cloud and add “the data includes an employee’s name,” and watch the recommendation move to local. Take a local recommendation and change the data to “already public,” and watch it free you to use the frontier.

What it teaches is the ordering of the questions, which is the whole skill: sensitivity first, capability second. After a dozen runs you’ll stop reaching for “the best model” by habit and start reaching for “the right venue” — asking where the data is allowed to go before you ask which model is smartest. That reordering, made automatic, is what separates a professional who uses AI from one who governs it.

In BoodleBox — when the Decider lands on “either,” or points you to a vetted tool for Concordia coursework or work data, the concrete answer on this campus is BoodleBox (box.boodle.ai, Concordia sign-in): a FERPA/SOC-2, does-not-train-on-your-data platform, so it clears a bar a consumer chatbot can’t. Keep the far ends intact — public work can go to any good cloud tool; data that must never leave your machine still goes local. (No BoodleBox access? A public free assistant covers the public-work end; the private end still needs local.)

11.8 — Guarding the Deposit: Data as a Trust, Not a Convenience

Now the week’s question, given its due. What does it mean to guard the good deposit entrusted to you — to treat private data as a trust, not a convenience?

Paul’s word to Timothy is paratheke — a deposit, something valuable placed in your keeping that belongs to someone else. In the ancient world you would leave a deposit with a trusted friend before a journey: money, documents, a treasure. The friend’s whole duty was singular and unglamorous — don’t lose it, don’t spend it, don’t hand it to a stranger; give it back intact. Paul lifts that image to charge Timothy with guarding the faith he’d been given. And it lands, unchanged, on your desk. “Guard the deposit entrusted to you” (1 Timothy 6:20, ESV).

Because that is exactly what your data is. The client’s financials, the patient’s chart, the student’s file, the colleague’s blunt performance note — none of it is yours. It was placed in your keeping, on the understanding that you would guard it. When you paste it into a public chatbot because that was faster, you have done precisely what the ancient depositor feared: you handed the treasure to a stranger — a company’s computer — without the owner’s consent, because it was convenient. The whole moral weight of this chapter sits in the gap between two words: trust and convenience. Convenience asks what’s easiest for me right now? Trust asks what did the person who gave me this agree to?

The Lutheran Confessions sharpen this under the Eighth Commandment. Luther’s Small Catechism explains “You shall not bear false witness” not merely as don’t lie but positively: we should “defend [our neighbor], speak well of him, and explain everything in the kindest way.” To guard a neighbor’s reputation and secrets is commanded, not optional. The nurse who keeps the chart private, the HR coordinator who keeps the review off the public model, the teacher who keeps the student’s record on her own machine — each is keeping the Eighth Commandment with a keyboard. This is what the Confessions call vocation: God serving your neighbor through your faithfulness in an ordinary job. The neighbor never sees the moment you chose the private model over the convenient one. God does, and so does the neighbor’s protected dignity.

Here is where the AI era sharpens the old duty rather than dissolving it. The frontier model is a genuinely good gift — fast, brilliant, generous. And the temptation of a good gift is to use it for everything, including the things that were never yours to feed it. Local AI is, in one sense, a technology of faithfulness: it is the tool that lets you keep the deposit intact and still do the work well. So the spine rule and the Scripture say one thing from two directions. You choose the venue; you own the verdict — because the deposit was entrusted to you, not to your tools, and no model’s brilliance transfers the trust off your shoulders. Guard it. Route it where it’s allowed to go. Give it back intact.

11.9 — Common Pitfalls

Pitfall: Pasting confidential or regulated data into a public chatbot because it’s convenient. Example: An HR coordinator drops an employee’s medical-leave letter — diagnosis and all — into a free consumer AI to “clean up the wording.” Fix: Route by sensitivity before capability. Confidential and regulated data go to a local model or a vetted, agreement-backed tool — never a consumer chatbot. Use the tiers in code/data-sensitivity-guide.txt.

Pitfall: Assuming “local” is automatically private and safe. Example: You run a model locally, but your notes folder auto-syncs to a personal cloud drive and a meeting app is screen-recording the session — so the “private” text left anyway. Fix: Local removes the cloud risk, not every risk. Confirm the machine is yours, disable auto-sync for sensitive folders, and don’t run private work on a shared screen.

Pitfall: Confusing “free” with “private.” Example: A team standardizes on a free cloud tier for sensitive drafts, believing free means their data is protected — when the terms actually permit training on user input. Fix: “Free” is the price of the tool, not a promise about your data. Read the vendor’s data-use terms; turn off training if you can; if you can’t verify it, treat it as if your data is being kept.

Pitfall: Chasing the biggest local model your hardware can’t actually run. Example: You download a 70B model onto a laptop with 16 GB of memory; it swaps to disk and takes minutes per reply, so you conclude “local AI is useless.” Fix: Match model size to memory using the §11.4 rules — a 7–8B model at 4-bit (~4–5 GB) is the realistic laptop target. Local isn’t useless; the oversized model was.

Pitfall: Expecting a local model to match a frontier model, then shipping worse work. Example: You use a small local model for a subtle, high-stakes public document and hand in something noticeably weaker than the cloud would have produced. Fix: Local is “good enough” for private drafting and summarizing; it is not the frontier. If the data is public and the task is hard, use the cloud. Let sensitivity, not stubbornness, pick the venue.

Pitfall: Forgetting the cloud’s hidden dependency: the internet. Example: You build a workflow entirely on a cloud model, then travel to a rural site or a secure facility with no outside network — and your whole process is dead. Fix: For work you must do offline, keep a local model installed as a fallback. Know before the trip which door your task walks through.

Pitfall: Choosing a venue by vibe and being unable to defend it. Example: A colleague asks “why did you run that on the cloud?” and your only answer is “it’s the one I always use.” Fix: Fill in the worksheet (code/cloud-or-local.csv) so every task has a recorded reason. A choice you can defend in one sentence is a choice you actually made.

11.10 — Reps

The work is in the exercises. The keyboard is the gym — this is where the tradeoff stops being a table you read and becomes a judgment you own. A preview of what’s waiting:

• Name your venues — list the AI tools you use and mark each cloud or local, then find the gap.
• Classify your own work — sort five real snippets from your job into the four sensitivity tiers and pick a venue for each.
• Do the napkin math — estimate which model sizes fit on your laptop using the quantization rules (no install required).
• Run the showdown — same prompt on a frontier model and a local (or free-small) model; score quality, speed, and privacy.
• Pull the plug — turn off the Wi-Fi and find out what still works.

This week’s AI policy for reps: you may (and should) use AI, but every rep that touches it ends with an honest one-line AI usage note — what you asked, which venue you used and why, what you verified. And a hard rule that starts now and never stops: no real confidential or regulated data goes into a cloud tool for these reps. Use fictional stand-ins. The habit is the lesson.

A short Check Your Reps quiz is embedded on this page, right under the chapter. Take it before you move on — five questions, straight from what you just read.

11.11 — This Week’s Project

Your project is P11 — “Frontier vs Local Showdown,” specified in Project 11. You’ll take a set of real professional tasks, run each on a frontier cloud model and a local model (or the cloud-only fallback), and produce an evidence-backed comparison of quality, speed, and privacy — ending in a clear recommendation for when to reach for each. You’ll classify every task’s data sensitivity, complete the routing worksheet, and — in the Hard tier — write a one-page venue-routing memo that a real manager could adopt.

At a high level: Normal tier runs the showdown and scores it. Medium tier adds volume/cost analysis and a second local model. Hard tier asks for the judgment a machine can’t produce for you: a recommendation, defended, about which categories of your organization’s work must never touch the cloud — and why.

11.12 — Coach’s Final Word

Here’s what I want you to carry out of Week 11. For most of your life, “using AI” meant one thing: the cloud. This week you learned there are two doors, and that the professional’s job is not to always sprint through the bigger one. It’s to stand at the fork, ask where is this data allowed to go? before which model is smartest?, and walk through the right door for this task — every time, defensibly.

The models will keep changing. The frontier will get more astonishing; the laptop models will get better; the names in this chapter will all have higher version numbers by autumn. None of that touches the discipline. Route by sensitivity first. Match the model to the memory. Never confuse free with private, or local with automatically safe. Defend every venue choice in one sentence. Those outlast every product in the fact brief.

And underneath the engineering, the steward’s charge. You spend your days holding what other people entrusted to you — their money, their health, their records, their words. The frontier model is a gift, and part of wisdom is knowing which gifts a given task is allowed to accept. Local AI is the tool that lets you do excellent work and keep the deposit intact. That is not a constraint you’re grudgingly obeying. It’s the shape of faithfulness in a job that touches other people’s lives. Guard the deposit entrusted to you. Route it where it belongs. Give it back whole.

Now go do the reps. The Decider is waiting right below this page, the worksheet is in code/, and Project 11 is where it all comes together.

See you on Monday.

Up next: Read the exercises and do all of Week 11’s reps, then build Project 11 — Project P11: Frontier vs Local Showdown. Set up (or extend) your toolkit from Appendix A — including the optional local-model path — browse venues in Appendix B, review the privacy rules in Appendix C, and check any unfamiliar terms (quantization, open-weight, frontier/local) in Appendix D. Then Chapter 12 — Building Your Prompt Library.