AI 101 · Learning AI at Home
A crash course for business users: where to start, how to start
No computer-science degree required. This page takes you from your first AI subscription to running your own private AI on hardware you already own — including the gaming PC in your basement. Everything here was researched and verified in August 2026.
The path: three steps
Step 1 — Get your feet wet ($0–20/mo)
Pick one mainstream subscription and use it daily for a month on real work: drafting, summarizing, spreadsheets. The habit matters more than the vendor.
Step 2 — Learn to steer
Master the vocabulary below: prompts, directives, skills, artifacts, and agents. The difference between mediocre and excellent AI output is almost always the instructions, not the model.
Step 3 — Go private
Run models on your own hardware with Ollama. Your data never leaves the building, there's no per-token bill, and old gaming hardware you already own is usually enough to start.
Starter subscriptions (verified pricing, Aug 2026 — USD)
Claude Pro (Anthropic)
US$20/mo ($17 annual)
Includes Claude Code and Cowork agentic tools, Projects, and memory — the strongest pick for writing quality, long documents, and hands-on agent work.
ChatGPT Plus (OpenAI)
US$20/mo
The biggest ecosystem and most familiar interface — GPT-5-series models, image generation, voice mode, and a huge app/plugin catalogue.
Google AI Pro (Gemini)
US$19.99/mo
Gemini 3-series Pro with a 1M-token context window — the largest working memory of the consumer tiers — plus deep Gmail/Docs integration. A cheaper AI Plus entry tier is the lowest-cost toe in the water (pricing varies by region).
Microsoft 365 Premium
≈ US$19.99/mo
Copilot AI inside Word, Excel, PowerPoint, and Outlook plus the full Office suite. (The old standalone Copilot Pro was discontinued in favour of this bundle.) The pick for people who live in Office.
Prices are USD and move often — confirm on each vendor's site. CAD pricing differs.
The vocabulary — models, MCP, prompts, skills & friends
Twelve terms that cover 90% of every AI conversation you'll have this year.
Model
The AI "brain" itself — a large file of learned numerical patterns produced by training on huge amounts of text. When you chat with Claude or run something in Ollama, you're sending text into a model and getting its predicted response back.
Parameters vs Tokens
Parameters are the model's internal dials set during training — a "9B model" has 9 billion of them; more usually means smarter but heavier. Tokens are the chunks of text (~¾ of a word) the model reads and writes while you use it — usage and API pricing are counted in tokens. Size of the brain vs. amount it's reading: both quoted in billions, endlessly confused.
Context window
The model's working memory — the maximum text (in tokens) it can consider at once: your documents, the conversation, and its answer. Current local models offer 128K–256K tokens (roughly a 200–400 page document). Anything beyond the window is simply forgotten.
Training vs Fine-tuning vs RAG
Training builds a model from scratch on trillions of words — months and millions of dollars, big-lab territory. Fine-tuning nudges an existing model with your examples so it adopts a style or specialty. RAG changes nothing in the model — it looks up passages from your documents and feeds them in at question time. RAG is the cheapest, most common way to make AI "know" your business.
Prompt
The instruction you give the model. The whole art is writing a clear brief with context, examples, and constraints — think of briefing a very fast, very literal contractor.
System prompt / Directive
A standing instruction the model sees before every user message — "You are Acme's service agent; never quote prices" — that sets role, tone, and rules. Chat users never see it, but it governs the whole conversation.
MCP (Model Context Protocol)
An open standard, created by Anthropic in late 2024 and now governed under the Linux Foundation with OpenAI, Google, Microsoft, AWS and others aboard, that lets AI assistants plug into outside tools and data — calendars, databases, Slack, GitHub — through one common connector instead of a custom integration for every pairing. Claude, ChatGPT, Gemini, and Copilot all speak it.
Skills
Folders of instructions — a SKILL.md file plus optional scripts — that teach an AI how to do a specific repeatable task your way (your report format, your review checklist). Introduced by Anthropic in 2025 and published as an open standard. If MCP gives the AI hands, Skills give it your procedures manual.
Artifacts
Standalone outputs — documents, web pages, small apps, dashboards — created in a side panel you can view, edit, and reuse, instead of being buried in chat scroll. The chat is the conversation; the artifact is the deliverable.
Agents
AI set up to complete multi-step tasks, not just answer one question: it plans, uses tools (search, files, email, code), checks results, and keeps going until done. A chatbot answers; an agent does. The 2026 shift is from "chat with AI" to "delegate to AI."
Hallucination
When a model confidently states something false — a made-up citation, price, or fact. It is a structural behaviour of all current AI, not a rare bug: models predict plausible text, not verified truth. The operating rule for business use: AI drafts, humans verify — especially anything with numbers, names, laws, or money.
Quantization
Compressing a model by storing its billions of parameters at lower precision — like rounding prices to the nearest dollar. Standard 16-bit precision needs 2 bytes per parameter (70B ≈ 140 GB); 4-bit needs about half a byte (70B ≈ 40 GB) with only small quality loss. This is the trick that puts serious models on home hardware.
How big does your AI need to be?
Drag the slider from tiny embedding models to 400B+ frontier giants and watch cost, hardware, and capability change — with honest sweet spots for business sizing marked along the way.
Model size: 7–14B parameters (Mid class)
Drag to scale from millions to 400B+ parametersCapability
55 / 100
Solid daily driver — the home 'AI coworker' class
GPU VRAM (Q4)
5–10 GB
System RAM: 16 GB
Disk (SSD strongly advised)
4–9 GB
NVMe loads a 20 GB model in ~10 s; a hard drive takes minutes
Typical speed
30–70 tok/s on a consumer GPU (RTX 3090: 8B ≈ 115 tok/s)
30–70 tok/s on a consumer GPU (RTX 3090: 8B ≈ 115 tok/s)
Cost signal
Free to run locally
Free local · comparable APIs ≈ $0.10–0.40 per M
Hardware tier
RTX 3060 12GB
RTX 3060 12GB · RTX 2080 Ti · RX 6700 XT
Capability vs. model size — relative capability score across size classes (log-spaced)
View this chart as a table
| Class | Parameters | Capability | VRAM (Q4) | Home status |
|---|---|---|---|---|
| Tiny | 100–500M | 12/100 | < 1 GB | Home-runnable |
| Small | 1–4B | 30/100 | 2–4 GB | Home-runnable |
| Mid | 7–14B | 55/100 | 5–10 GB | Home-runnable |
| Large | 24–34B | 70/100 | 14–20 GB | Home-runnable |
| XL | 70–90B | 82/100 | 40–48 GB | Prosumer rig required |
| MoE Mid | 100–200B (MoE) | 88/100 | 65–80 GB | Prosumer rig required |
| Frontier | 400B–1T+ | 100/100 | Multi-node only | API-only for homes |
Parameters vs tokens: model size is measured in parameters (the model's learned "dials"); tokens measure how much text you feed it and are what APIs bill for. Both come in billions, which is why they get mixed up.
VRAM rule of thumb: at 4-bit quantization budget ≈ 0.6 GB per billion parameters (weights + overhead), then add 1–4 GB for context (KV cache) — long contexts eat VRAM and can halve speed.
CPU-RAM offload: spilling layers from GPU VRAM to system RAM works but costs ~10× speed — offload more than ~20% of a model and it stops being worth it. Capability scores are BEARACH editorial estimates for comparison, not a benchmark.
Ollama — why it's the key to private, personal AI
Ollama is a free, open-source tool (v0.32 series, updated near-weekly) that downloads and runs AI models entirely on your own computer — macOS, Windows, or Linux. Why it matters for private AI agents: your prompts and documents never leave your machine, there is no per-token cost (hardware and electricity only), it works fully offline, and it exposes an OpenAI-compatible API — so almost any AI tool can point at your own computer instead of the cloud with a one-line change.
# 1. Install (Mac/Windows: download from ollama.com)
curl -fsSL https://ollama.com/install.sh | sh
# 2. Run your first model — downloads automatically
ollama run gemma4
# 3. Your private OpenAI-compatible API, for any tool
http://localhost:11434/v1
- Ollama: The default. One command to run any of thousands of models; OpenAI-compatible API built in.
- LM Studio: Point-and-click desktop app — pick it if you never want to see a terminal.
- Open WebUI: Self-hosted ChatGPT-style web interface on top of Ollama — logins, RAG, multiple models for the whole team.
- llama.cpp: The engine underneath most of these — pick it directly for maximum tuning control.
- vLLM: High-throughput GPU serving for many simultaneous users — the production office-server choice.
- Jan / GPT4All: Privacy-purist desktop apps; GPT4All's LocalDocs is the easiest chat-with-your-files for non-technical users.
The Tech Graveyard — your old gaming PC is an AI server
That retired gaming rig in the basement is likely a capable private AI machine. The one spec that matters most is GPU memory (VRAM) — here's what the common veterans can honestly do in 2026:
| Old GPU | VRAM | Runs (quantized) | Verdict |
|---|---|---|---|
| GTX 1080 Ti (2017) | 11 GB | 7–8B well; 14B tight | Works today, but NVIDIA driver/CUDA support for Pascal is ending — usable, not future-proof. |
| RTX 2060 | 6 GB | 3–4B; 7B with offload | Marginal as the main brain — great as a small-model or client box. |
| RTX 2070 / 2070S | 8 GB | 7–8B fully on GPU | Solid entry point; tensor cores and still fully supported. |
| RTX 2080 Ti | 11 GB | 7–14B | Best of the 20-series for local AI. |
| RTX 3060 12GB | 12 GB | 7–14B; 12B multimodal | The budget darling — cheapest well-supported 12 GB card. If you buy one card used, consider this. |
| RTX 3090 | 24 GB | 27–34B fully on GPU | The used-market king (~US$1,100 used). 8B at ~115 tok/s; 32B-class at ~34 tok/s. |
| RX 6700 XT / 6800 XT | 12–16 GB | 7–14B / up to 27B | Good value if you tolerate AMD tooling — use the Vulkan backend for the low-drama path. |
Minimum viable AI box
- • 16 GB RAM floor, 32 GB comfortable (DDR4 is fine)
- • CPU from ~2013+ (needs AVX2 — Haswell / Ryzen or newer)
- • SSD strongly recommended — a hard drive turns 10-second model loads into minutes
- • Healthy power supply — old PSUs + hungry used GPUs is the classic revival failure
Not worth reviving: pre-2013 CPUs, 8 GB-max machines, GPUs under 6 GB VRAM (use those as client screens instead), and power-hungry old servers that cost more in electricity than they deliver.
Your home cluster pattern
Don't try to make old machines share one brain — make your strongest box the AI server (Ollama serving on your home network) and every other device a client through a browser. Laptops, tablets, and weaker PCs all get "free" AI this way.
True multi-machine inference exists (llama.cpp's RPC mode splits one big model across mismatched boxes; the exo project does it for Mac clusters) — but it adds capacity, not speed, and wants wired gigabit networking. Treat it as the graduate course.
The starter stack: your own AI coworker
Ollama + Open WebUI + a 7–14B model — honestly, a competent, tireless junior assistant that never phones home.
- Private chat, drafting, and rewriting — 100% offline, nothing leaves the building
- RAG over your own documents (Open WebUI has it built in)
- Coding help and autocomplete (point VS Code's Continue extension at Ollama)
- Frontier-level reasoning or long multi-step agentic coding
- Very long contexts at speed — big contexts eat VRAM and throughput
"Training your AI" — what that actually means
You almost never train
Building a model from scratch costs millions and months. Unless you're a frontier lab, this word doesn't apply to you — and anyone selling you "custom-trained AI" probably means one of the next two.
You occasionally fine-tune
Nudging an existing model with hundreds of your examples to lock in a style, format, or narrow specialty. Worth it for high-volume, repetitive, well-defined tasks — after RAG has been tried.
You usually want RAG
Give the model your documents at question time. No model changes, updates instantly when your files change, keeps data governed. This is the right first answer for "make the AI know our business."
Want this built for your business instead of your basement?
BEARACH designs private AI deployments for Ontario businesses — from a single workstation running your first agents to governed, PIPEDA-aligned local AI platforms. Start with a capability audit.
Book Your Ontario AI Audit