AI 101·Rabbit Hole

Open-weight · Forged, not rented · Vancouver BC

Understand the machine.
Then drive it.

Two weeks from "AI feels like magic" to training your own model, running local AI for free — then getting the frontier models to do things: a vibe-coded website you auto-publish yourself, your own offline mail + reminder agent on the model you trained, and a real research desk driven by a rented 31B brain. Move off expensive closed subscriptions to open-source, open-weight models — the right model per task, privately, offline, with the foundation to build or grab the next tool. On real, working, open-source software.

Built for senior professionals — the people sitting in meetings where an AI vendor pitches a six-figure contract to a table that can't tell a wrapper from a model. After two weeks, you can. Nobody is asked to become a programmer; you're asked to encode the judgment you already spent decades earning. The gain isn't syntax — it's the ability to read what is being sold to your company, and to run your own working stack for near-zero marginal cost.

2 weeks · crash pace 6 live webinars · all remote deep-dive track: optional, go as far as you want 12 seats · hard cap private Discord, during & after labs on the AiOn server, over VPN · your own Ollama account runs the meter

The thesis

Everything you use in week 2 — the big hosted models, the agent frameworks — is the same machine you build in week 1, scaled up and renting by the token. A model is a file. Inference is a command. Training is a command with more flags. Once you've held the small version in your hands, the big one stops being intimidating.

And the whole point: move away from expensive closed subscriptions to open-source, open-weight models — the right model for each task, done privately and offline, on a foundation that lets you build or pick up the next tool you want. Same machine, more secure, a fraction of the cost.

Why this course pays for itself

Cost Bring your AI costs down

Learn concretely which workloads a model on your own hardware handles fine — summaries, extraction, drafts — and which genuinely need the big cloud call. Most people pay frontier prices for tasks a small local model does for free.

Data Your sensitive data stays home

Client data, contracts, internal docs — a local model has no terms-of-service question, no third party at all. You'll have run one yourself and know exactly where its floor is. Not a privacy policy — working knowledge.

Tier Move off expensive subscriptions

Open-source, open-weight models — the right one for each task, not one big bill for everything. Privately and offline where it matters, $20 flat for the big cloud calls when you need them. You'll leave knowing the full gradient — free local → $20 flat cloud → per-token API when justified — and how to pick the right rung per task.

Meter A habit that outlasts every model

Models change monthly. "What does this cost in tokens, seconds, dollars — and what's the cheapest thing that does it correctly?" is permanent. Every output in week 2 comes with its meter readings.

Contract Read the proposal before it signs you

Half of CEOs report no revenue or cost benefit from AI yet, and most enterprise AI contracts are silent on the parts that matter — training rights, model deprecation, uncapped consumption pricing. Week 2 hands you the five questions to ask before any proposal gets signed, with the competence to ask them.

The format

Piece	Count	Notes
Live webinars — general track	4 · Tue/Thu · 90 min	The "understand & use" track, for everyone: what a language model is, how to run one daily. ~45 min working live on screen, ~45 min hot-seat Q&A on your setup
Live webinars — "In the Weeds"	2 · Saturdays · up to 4 hrs	The optional deep track, one extra webinar per week: week 1 you train the model live on the rig, week 2 you build the research desk + ladder. All remote — skip it and you still graduate the general track
The labs	during the webinars	All hands-on work happens on the AiOn server — you VPN in from your laptop and use it live during the sessions. No in-person lab, no local install during the course; your machine is just the window
Private Discord	during + after	Cohort channel during the course; the Foundry community after — also your lab notebook, limitations log, jargon sheet, and #bot-showcase, where your agents get used and critiqued by the rest of the cohort
The agent at the wheel	Claude Code, Codex, or Hermes	You touch the command line exactly once: day one, together, you VPN into the AiOn server where the stack is already running. From then on you tell a coding agent what you want — it drives the stack, shows you every command it runs, and you approve the moves. Choosing which agent is your first exercise in judgment — you make that call in prep week, with criteria we hand you, and you own it
Warden	the homework codebase	Dominic's open-source agent platform — explored between sessions in week 1, dissected, broken, fixed, and shipped-to in week 2
The Foundry stack	yours to keep	WSL + Docker, one compose file on GitHub — every tool, model, and the curriculum inside. During the course it runs on the AiOn server, over VPN — and taking it home is telling your agent "install the course from this URL" and watching it work. Lesson one teaches it from the ground: what Linux is, what a container is, and why breaking one costs nothing
What you bring	a laptop + one paid account	A laptop with a VPN client and a browser, and your own paid Ollama account — it's your frontier-model meter for the whole course, and it leaves with you when the course ends

Week 01 — The Machine

Meet a small local model, find its limits, fix them one at a time — then train it yourself.

The week at a glance

Session		You leave with	Brain
W01	"Meet the model, from zero" Tuesday · 90 min	The stack in, the container broken on purpose to prove it's free, a small local model answering you by the halfway mark, the good-at / sucks-at map, and RAG over your own documents	small local model — dense
W02	"Give it a personality" Thursday · 90 min	A Modelfile persona that reloads with the model, the prompt wall found firsthand, your team's specialist claimed for the deep-dive webinar — and a fictional character cast for Saturday's live persona train	same model, instructed
W03	W03 — "Build the orchestrator" deep-dive Saturday · 10:00–14:00 · live webinar · optional	Twelve people's training data combined into one 3B orchestrator that passes foundry-probe, runs Warden for real, and goes home with you	granite4.1:3b — your trained 3B

Said on day one: by Saturday night you've held the small machine in your hands — and taught it one thing it didn't know on Tuesday.

Webinar 01 · Tuesday

"Meet the model"

Goal: everyone is talking to an AI running on the AiOn server, over VPN, by the halfway mark — and can name what it's running inside. No training, no math — just play.

The kick. A familiar subscription AI on screen: what is this, actually? Guesses on the board, no answers yet. You don't know what you don't know — tonight you name one tool you pay for, and on Thursday the class pulls it apart
Ground zero: VPN into the AiOn server. The stack lives on GitHub — and for the course it's already running on our server. Day one you connect: one VPN profile from your laptop, and your chosen agent — Claude Code, Codex, or Hermes — drives the stack with you approving the moves. That's the first exercise of the course and the last time anything near a command line happens by hand. Then: what Linux is (the free operating system under almost every server on earth), what WSL is (Linux living inside your Windows laptop), what Docker is (the whole course sealed in one container — break it, nuke it, a fresh copy is one command away). Nothing can hurt your laptop — your machine is just the window. The same one-script install puts the whole stack on your own hardware the day you want it. Playing with new things safely is the permanent skill here; the stack is just this week's new thing
Play. Ask your agent for a model, and a small local model is answering your questions — your work, your hobbies, trick questions. It's fast, it's charming, it's wrong a lot
Map it. Build the good-at / sucks-at table together: great at summaries and tone, bad at recent facts, hopeless about your stuff, confident while wrong. Every limit gets a plain-English name. One line on what the model is — a dense transformer, every parameter firing on every token (why "dense" gets a name shows up Saturday). Then the map, once: the nine nouns every AI product online is built from — model (a file of weights), prompt, context window, RAG, fine-tune, agent, API, token, meter. Every subscription is an arrangement of these; you just used five. You weren't handed this map when they sold you the subscription — that gap is the business model
First fix: RAG. It doesn't know your stuff? Give it your stuff. Plug in a folder of documents, re-ask the questions it failed — now it answers from them. You just made the model smarter without touching the model

Webinar 02 · Thursday

"Give it a personality — and claim your one thing"

Goal: from "smarter" to somebody — find the wall only training gets past, then claim the one thing you'll teach it on Saturday.

X-ray a tool you actually pay for. Each student names one AI product from their own wallet or daily routine; the class places it on Tuesday's map — which model is under it, what the wrapper prompt is doing, whether there's RAG, where the meter is, where your data goes. No shame, just literacy: two days ago these tools were magic with a price tag — now you read one the way a mechanic reads an engine
Traits by prompt — what a Modelfile change does: first tell it to do a task outright ("do X"); then move the task into an Ollama Modelfile and reload — now just say "go" and it does it automatically. The instruction travels with the model, not the prompt. Same move for personality: name it, set its tone, quirks, rules, backstory — watch the same questions come back in a completely different voice
The wall: push the persona until it breaks — drops character under pressure, forgets mid-conversation, can't learn a habit. Prompts are instructions reread every time; training changes the model itself
Claim your team's specialist for Saturday: three teams of four — each team teaches the orchestrator to delegate to ONE specialist. Atlas (knowledge: retrieval against a course-invented fake company's bounded fact pack), the Council (deliberation: when to plan and route instead of answering — a quiet preview of week 2's planner/executor split), and Vulkan (action: one tool call it never fumbles — including knowing when not to call). Each person writes their facet of the training data
Homework — cast your character: pick a fictional character with a sharply defined personality — Luke Skywalker, Frodo Baggins, Mary Poppins — if you can hear their voice in your head, they qualify. Write twenty or more persona lines in that voice: how they greet, how they refuse, what they'd never say. Saturday, the rig trains it into a 3B live — and you hear the difference between a character that was told and one that was taught

Webinar 03 · Saturday · 10:00–14:00 · "In the Weeds" deep-dive · remote · optional

"Build the orchestrator: three teams, one brain"

Goal: three teams of four each train the delegation data for one specialist — then the cohort combines all of it into one 3B orchestrator that becomes Warden's brain. Everyone takes that model home. Optional: the general track ends Thursday — this webinar is the deep end, for the ones who want the training itself.

Training runs live on the course rig, streamed on screen — a 3B fine-tune takes minutes. While it trains, you read the ~30 lines that combine everyone's work into one model. That's what "one orchestrator from twelve people" physically is
Prove the training stuck: each team passes foundry-probe — five paraphrased requests, asked with no instructions on how to delegate. A prompted model can't pass this; only a trained one can. That's the point
The climax — your 3B runs Warden for real: swap the cohort's model in as Warden's brain, replacing the bigger stock model it shipped on, and run real tasks. It probably doesn't work the first time — troubleshooting the failures live is the lesson
The moment the thesis lands: the same Warden task, two models — your trained 3B (free, your hardware) against the larger, untrained gemma it replaced (the stock model Warden shipped on). Both run it. The trained 3B delegates correctly; the bigger untrained model doesn't — because training beat scale. That's the point
Your expertise, made durable: say it out loud — nobody here is learning to code instead of having a career. The ~50 lines of training data you wrote this week are your career: decades of judgment about when to delegate, to whom, and when to say no, encoded. Using AI stops feeling like cheating the moment the expertise inside the model is yours
Dense vs MoE: your 3B and the untrained gemma are both dense — every parameter fires on every token. The rentable frontier ~1T models are a mixture-of-experts — only a few experts fire per token, so a 1T-parameter model runs like a smaller one. That's why the big ones are rentable by the token — and why a trained dense 3B can hang with them on the right task
Where the torch passes: the 3B running Warden, taken home, is the course. Extra specialists, the baked-in persona, rerunning the comparison at a larger size — that's the optional play tier, yours as far as you want to take it
The character trains, live, in parallel: while orchestrator runs cycle, every student's Thursday-night character lines go through the rig as their own persona fine-tune — minutes each. Five questions, asked twice: once to the base model with the character only prompted, once to the model trained on it. The prompted one drops character under pressure; the trained one holds. Told vs. taught, on a voice you cast yourself
Take two models home: one instruction to your agent drops the cohort's orchestrator into your own Warden — and your character-trained 3B comes with it, persona baked into the weights

Week 02 — The Exit Ramp

Week 1 you trained a model. Week 2 you turn it into a stack of four tools, each of which replaces something you rent from big tech — your web presence, your assistant, your research subscription, and the landlord relationship itself. Nothing you build this week has a login wall, a monthly fee, or a terms-of-service page: "We're not building apps this week. We're cancelling subscriptions."

The contract — every module, every time

Each module names three things out loud: the big-tech thing it replaces, the plain-old tool it's built from — FTP, cron, IMAP, a text file — and what it kills: the fee, the data leak, the dependency. Boring is the feature. Boring tools have no business model pointed at you.

Offline means the thinking happens on hardware you control — the AiOn server you VPN into during the course, your own machine after — and the core of each tool works with the network cable pulled. Simple means a short script you could have written yourself after this course — no framework, no dashboard, no vendor console. Autonomous means each tool ends the week on a timer, running unattended — an assistant you have to remember to run is just another app.

The week at a glance

Module	Session	You build	Brain	Replaces
01	Publish without a landlord Tuesday · 90 min	A ~3-file static site + publish.sh + a nightly timer	e4m, by default — choosing is Module 04's lesson	Squarespace / Wix / Substack / Medium
02	Your mail, your machine Thursday · 90 min	An agent over your inbox + a reminders file, on cron	granite4.1:3b — the trained 3B from Week 1 (ships in the stack if you skipped the deep-dive)	Cloud assistants reading your mail, syncing your reminders who-knows-where
03	Your research desk deep-dive Saturday · 10:00–13:00 · live webinar · optional	A plan → search → read → cite loop with receipts	gemma4:31b-cloud — rented, metered · your Ollama account	"Deep Research" subscriptions at $20/mo
04	The ladder — the graduation hour Saturday · 13:00–14:00 · live webinar · optional	Wire every tool's model slot e2m / e4m / 31b-cloud, all on timers — finish & graduate	the Gemma 4 ladder	The landlord relationship itself

Said on day one: by Saturday night your site publishes itself, your agent briefs you over breakfast, your research desk files cited reports to your own URL — and you can say exactly which brain does which job and what each costs.

Weekend homework — arrive practiced, not installed

One weekend between the two weeks. Everything you need is already inside the Foundry stack you've been running since day one — so the homework is practice, not setup: Week 1's core moves, run once each, plus two credentials of your own to bring back with you.

Practice the Modelfile move one more time. Ask your agent to change one trait of your Week 1 persona and rebuild it — confirm the instruction travels with the model. Ten minutes of Week 1's core move; you'll do it blindfolded by Thursday when your mail agent inherits it.
RAG over one folder of your own documents. Have your agent re-run Tuesday's RAG exercise on a real folder from your life — meeting notes, a project, a hobby wiki — and re-ask one question the bare model got wrong in class. Post the before/after in #lab-notebook. It's also Module 02's rehearsal: your mail agent is RAG-shaped.
Give your trained 3B one real task from your actual week. A summary, a draft, a plan — something you'd normally throw at a subscription. Then stamp it like the meter is on: what it did well, where it fell over, posted in #lab-notebook. This is how the ladder gets built later — you find out what the model you made is actually worth to you by giving it real work.

Arrive with Week 1's moves warm — Week 2 spends its hours building, not setting up.

Module 01 · Tuesday · 90 min

"Publish without a landlord" — vibe-coded website + FTP auto-post

Goal: everyone vibes a small static site into existence, puts it on the open web through their agent, then wires the auto-post: write markdown, tell your agent to publish (or don't — the timer does it), site updates itself.

The meeting-room x-ray, before anything gets built: a real enterprise AI proposal / pricing page, read as a board member — find the training-rights clause (43% of reviewed contracts are silent on whether your data trains their model), the deprecation notice (78% lack one — the model you integrated can vanish), the consumption cap (uncapped token pricing is how pilots become invoices). Then the handover: the five questions to ask before any AI proposal gets signed, carried home tonight (this opens the general track — the students most likely to skip Saturday are exactly who need it)
Replaces: hosted website builders — Squarespace, Wix, Substack, Medium — and the $10–20/mo and the algorithm that come with them. Built from: HTML you didn't type (the model wrote it), one FTP account on plain $2/month hosting (or a home box), and one shell script wrapping a single lftp mirror line. Kills: the platform — your site is files on a disk you rent. FTP is forty years old, dumb as a rock, and that is exactly why it works
Vibe-code the site: prompt the model into being your web developer — "a personal page, one CSS file, dark, my name, three sections." Iterate out loud: ugly? Ask for better. Broken? Paste the error. Keep it to ~3 files — small enough to read, so it stays simple. The honest lesson, stated plainly: you didn't write a website, you briefed one
Publishing is one instruction: no GUI client, no dashboard — you tell your agent "publish my site," it runs publish.sh (one lftp mirror line, on screen as it goes), and the files land in the directory. That is the whole ceremony, and it's the same move the agent runs for you forever. Creds in .env, and the standing rule: .env never leaves the machine, never goes to Discord. Jargon cards: FTP (a file conveyor belt — forty years old, plain, everywhere), static site (pages that are just files — no database, nothing to hack)
Auto-posting, on a timer: a build step (markdown → pages, ~30 lines, the model writes it with you) + publish.sh = one command — then a systemd --user timer or cron line runs it nightly. Change a file, go to bed, wake up published. No dashboard, no plugin, no API key — a timer and a conveyor belt
Homework: draft your first real post and let the timer publish it; post the URL in #receipts, $-stamped. Bring read-only email credentials (app-password) for Thursday

Module 02 · Thursday · 90 min

"Your mail, your machine" — offline Granite 3B email/reminder agent

Goal: the week's payoff build — driven by granite4.1:3b, the cohort's trained 3B from the Week 1 deep-dive (in your stack either way — you trained it live, or it shipped with you). The model Saturday produced is now your daily driver; that sentence lands hardest here, so we say it out loud.

Replaces: the cloud assistants — Gemini in your Gmail, Copilot in your Outlook, Siri/Google reminders syncing who-knows-where — and their habit of reading your mail on someone else's computer. Built from: IMAP (read-only, app-password), a reminder store that is a plain text file, the week-1 agent anatomy (a toolcalling model + a tool registry + a loop), and cron. Kills: the data leak — mail fetched locally, summaries made locally, reminders live locally. An assistant that dies when the Wi-Fi does was never yours
Build the agent: the same small skeleton the course knows — a toolcalling model + a registry + a loop, now with a real job. Register two tools: inbox.py (IMAP, read-only, app-password — overnight mail, summarized) and reminders.py (append/list/clear lines in a plain reminders.txt). Point your trained 3B at them; ask your agent for a morning briefing, then "remind me to water the plants at 6" — and watch a text file gain a line. The Week 1 Modelfile personality already travels with the model, so the assistant sounds like theirs. Jargon card: IMAP (the oldest, most boring, most universal mail protocol — answers to no platform)
Autonomy + the offline proof: a cron line runs the brief at 07:00 and a reminder check every 15 minutes (desktop notification, or mail from your own box). Then the demo that carries the theme: unplug the network → reminders still fire → plug back in → mail flows again. Offline-first doesn't mean no internet; it means the internet is optional
Make it yours: a runway, not a recipe — add a tool (RSS peek, local calendar file, weather), retune the Modelfile tone, teach the reminder format a new pattern. Read-only scopes, app-passwords, .env stays home — the day's second real lesson
The $0.00 stamp: everyone $-stamps their brief — tokens / seconds / $0.00. The first genuinely zero-dollar agent of the course, because the brain is local and you already paid for it with Week 1's GPU hours
Homework: run it three days straight; post one morning brief and one reminder fired in #lab-notebook. Saturday: bring your questions list — the research desk needs something to chew on

Module 03 · Saturday · 10:00–13:00 · "In the Weeds" webinar · remote · optional

"Your research desk" — a Gemma 4 31B research agent

Goal: an honest plan → search → read → cite loop, driven by gemma4:31b-cloud, whose brief lands on your site and in your inbox — metered, deliberate, and on your terms.

Replaces: metered deep research — ChatGPT/Gemini "Deep Research" at $20/mo, per-query frontier APIs, and the quiet fact that your questions become their data. Built from: one honest loop where planner/researcher/writer/reviewer are prompts, not platforms; keyless search (SearXNG or Jina AI Reader); and the same Ollama Cloud credentials the course has used since Week 1. Kills: the subscription — renting a bigger brain deliberately, metered, and on your terms. We buy reasoning by the sip, not the subscription
X-ray the thing you're replacing: five minutes with the hood open on a "Deep Research" product, read through Week 1's map — every organ in it is one you've already assembled by hand (the meeting-room x-ray already happened Tuesday — this one is consumer-side). Then build yours: four roles, one file each of prompt + glue — planner (break the question into sub-questions), researcher (search + fetch sources), writer (synthesize), reviewer (check citations against sources, kick back gaps). The class has seen this anatomy already: a crew is just agents in a trench coat. Jargon card: sub-agent (a prompt with a job and its own context — not a product)
Drive it with the 31B: run the class question live — watch the fan-out, the sources land, the cited brief assemble. $-stamped in the open: this is the week's one deliberately paid model
Local vs. rented, head-to-head: the same question through your trained 3B. Where does the small brain break — context, citation discipline, synthesis depth? Log it in #limitations-log (the big ones fail too — it never fills up). Week 1's density story from the other side: train a small model for the jobs it's scoped to, and rent scale for the few jobs that need it
Close the loop through your own stack: register two week-2 tools on the desk — publish (the brief becomes a post via module 1's publish.sh) and mail (module 2's agent delivers it). Run it end to end: question → cited brief → live on your URL → in your inbox. Nobody's platform touched any of it
Autonomy: a weekly cron — your standing question list → the desk → your site and inbox, Monday mornings. Discord: post your first cited brief (URL + stamp) in #receipts; one 3B-vs-31B surprise in #limitations-log

Module 04 · Saturday · 13:00–14:00 · "In the Weeds" webinar, part 2 · optional

"The ladder: smallest brain that does the job" — Gemma 4 e2m / e4m / 31b-cloud

Goal: the engineering heart of the theme — three tiers of the same family (a tiny e2m, a daily-driver e4m, the rented 31b-cloud) and the discipline of assigning each job the smallest brain that does it correctly, proven with stamps rather than vibes.

Replaces: the landlord relationship itself — the default where every job, big or tiny, silently runs on a big-tech cloud because that's what the app chose for you. Built from: a one-line change with outsized consequences — every agent you built this week takes its model from a --model flag / config slot — plus the tier chart and your $-stamp ledger. Kills: the autopilot — big tech demoted from landlord to utility. Autonomy isn't no cloud; it's the cloud on a leash you hold
The tier chart, filled in together: reminder phrasing & mail triage → e2m (fast, free, dumb enough to trust with small jobs); daily briefs & the website pipeline → e4m (the default driver — quality where it shows); research synthesis → 31b-cloud (rented, metered, deliberate). And a home row for your trained Granite 3B: your Week 1 fine-tune — the jobs you personally scoped. Jargon card: model ladder (one family, many sizes — swap by tag, same API, same calls)
Same task, three tiers, stamps on screen: one real job run through each tier — score correctness out loud, stamp tokens / seconds / dollars per run. Smallest correct answer wins
The everyday stack card: before touching configs, each student draws their actual daily AI life onto the tier chart — every recurring search, draft, summary, question gets a rung (local, trained 3B, e2m, e4m, or a deliberate rented call). And the honest last rule, said out loud: sometimes the paid tool is the right rung — you choose it knowingly, use it as intended, and can say what it cost and why. That's the opposite of the autopilot, not a betrayal
Tuesday's five questions, made yours: the card from Module 01's opening, rewritten in your own company's context — what's the ROI claim and how would we check it ourselves; who here is accountable when the output is wrong; what does this cost at 3x usage and is it capped; may they train on our data, is it written down; what happens when the model is deprecated — do the weights, prompts, and data leave with us? After two weeks of meters, contracts, and exit ramps you don't memorize these — you've already answered worse ones about your own stack
Rewire the week: each student sets their own slots — which tier drives their email agent, their site builder, their research desk, and why, in one sentence each ("e4m because…"). Timers re-pointed; fallbacks named honestly — 31b-cloud is the only line item with a meter, everything else runs for free at home
Graduation receipts: the stack, live, end to end — site auto-published, agent briefing daily at $0.00, research desk filing cited briefs to your own URL, every brain chosen and stamped. The graduation bar: you own the tools, you chose the brains, you can rebuild any piece — nothing in this stack can be taken away by a pricing page

Standing rules and safety lines — repeated every session

$-stamps on everything. Every model call, every session: tokens / seconds / dollars. Module 02's $0.00 and Module 03's metered cents are the story; Module 04 makes it a discipline.
The Discord is the lab notebook. #receipts for URLs and stamps, #lab-notebook for runs, #limitations-log for every wall a model hits — big or small, it never fills up.
#bot-showcase is open mic. Ship your bot there — a persona train, a mail agent tweak, a wild specialist — where other students actually use it. Show it off, get it critiqued, borrow someone else's and break it. A bot nobody else has talked to is a hypothesis.
Read-only scopes, always. Every agent runs with the smallest scope the job allows — no write, no send, no delete — until you grant it one feature at a time, in the open, with stamps.
App-passwords, never real passwords. Every credential in Week 2 is a scoped app-password (or an SFTP key) you can revoke in one click without touching your real inbox.
.env never leaves the machine, never goes to Discord — not even "accidentally cropped." Creds live in a file that is .gitignore'd, local-only — do not FTP it, ever.
No new signups. Everything runs on the course Ollama Cloud credentials from Week 1 plus whatever is local. No Anthropic, no per-student cloud accounts, no surprise meters.

What you keep

Log The Limitations Log

The cohort's running catalog of every named limitation — from "no true memory" to "the tokenizer cliff." The cheat-sheet you consult before every AI purchase decision.

Term The Jargon Sheet

Every term, one line of plain English, pinned forever. You own the vocabulary instead of fearing it.

Stack The Foundry stack

Your whole environment in one Docker container: local models, the training tooling, the codebase, every config from class. You use it on the AiOn server over VPN during the course; install it on your own laptop and it runs offline, forever — break it and a fresh copy is one instruction away.

Kit Your orchestrator + your agents

Your own site, auto-published by a timer; your own offline mail + reminder agent (your trained 3B driving tools — your code, $0.00 stamp); and a research desk that files cited briefs to your own URL and your own inbox — every brain on the smallest tier that does the job, chosen and stamped. Proof, not promises.

How it's taught

Script-first, concept-second. Run the command, see the output, then get the explanation. A win in the first ten minutes of every session.
Break it first. Every concept arrives as a broken or limited thing you diagnose — not a diagram you memorize.
You direct, the agent types — and you watch every move. After install day, every exercise is you telling your coding agent what you want and reading the commands it runs to make it happen. A model is a file; inference is a command; training is a command with more flags — your agent shows you each one, so when you meet a big app later (Warden, a research crew, a site pipeline), you recognize it: the same root moves, stacked and packaged.
Real software as homework. From day 1, Warden — a real public codebase — is what you explore between sessions. When we open its hood in week 2, nothing in it is foreign.
The meter is always on. Tokens, seconds, dollars — stamped on everything from week 2 onward.
Taught by the person who builds the software. Not slides about tools — the actual tools, from the actual author, on a real machine.

The graduation bar

You leave with four autonomous tools, each replacing a big-tech dependency, every one rebuildable from scripts you wrote: a self-publishing website, an offline email + reminder agent, a research desk with citations, and a model ladder you set deliberately — with stamps to defend every choice.

Said out loud, for the last time: you own the tools, you chose the brains, you can rebuild any piece — nothing in this stack can be taken away by a pricing page.