The Difference
The one thing that makes this different
Almost every school can now say we use AI in the classroom. Few can say the next sentence. Our students build and operate our own AI on our own compute, with open-weight models they can open and change, and they answer honestly for what it costs to run, in dollars and in energy. That second sentence is the whole program. It is a position built on operating the stack rather than consuming a product.
The Vision
The vision, stated plainly
Over the next decade we run a living AI system that our students help build, operate, and improve. We use open-weight models because they are ours to open, inspect, and change. We hold the architecture, we see the costs, we swap models as the field moves. Our students get into the real architecture of the thing: what a request costs, which models spend tokens well, where compute is the wall, what runs on our own metal and what we rent, and what all of it costs the world. It outlasts any single semester. It compounds, handed down and sharpened by every class that inherits it.
Architecture
The architecture that makes it stand up (two layers)
One move separates a real program from a fragile one: we keep two layers apart.
The production layer. Steady, secure, dull on purpose. The gateway and the models that class runs on every day. Nobody breaks it, because everything runs on it. It carries uptime, access control, monitoring, content safety, and data governance, the way any real service does.
The lab layer. Where our students build, tune, benchmark, break, and operate open-weight models. This is where the learning lives, and where failure is allowed, because nothing load-bearing sits on it.
Fuse the two and we get the thing we refuse: a classroom hostage to flaky compute. Hold them apart and the same decision buys us both the reliability that makes the program real and the freedom that makes it teach.
The Spine
The intellectual spine: economics and energy
What turns this from a hardware stunt into a decade-long study is the accounting we refuse to skip. We measure the real things: what a task costs in tokens, how long it takes, the energy per answer, the trade between our own metal and the cloud. We study the trade instead of announcing the answer. Our own hardware is not automatically clean, a card running all day has a real footprint, and honest numbers sometimes send us back to the cloud. That honesty is the whole credibility. A program that measures its own costs and says them out loud survives a second look.
The Identity
Care for creation applied to compute
The identity: Laudato Si in a server rack
This is the part no other school can borrow. A Jesuit school that teaches its students to build AI and to answer for its cost to creation is care for the world applied to compute. It is the mission itself, not a footnote to it. It gives the work a spine a secular version cannot copy, and it is the version anyone paying attention remembers. The reckoning with cost, to our budgets and to the earth, sits at the center, not in the fine print.
Continuity
Continuity: the students are the continuity
A decade-long system has to survive the people who build it. Our students are how. Each year a student crew inherits the stack, documents it, and hands it on, and that documentation is the coursework. Keeping the thing alive is the class. That is why it stays alive.
Sequence
Phases and gates
Each phase has a gate, a thing that has to be true before we move. One rule holds across all of them: nothing critical runs on a personal machine. Personal gear earns its keep only as a proving ground.
| Phase | What runs | Gate to advance |
|---|---|---|
| 0: Now | Frontier access for every student in the coding class, so no one is throttled by what they can afford, plus one local open-weight model seeded in the room as the first taste. No new hardware. | Access working; a local model running in class; the first cost and speed logs on paper. |
| 1: Proof | A gateway plus a local open-weight model (a Qwen coder or gpt-oss) on a real box: one the school buys, one we rent by the hour, or a proving rig. The cost study runs for real. | The numbers beat paying per seat at scale; the people who run our network are in; the privacy story holds; the measurements are real. |
| 2: School compute | A production gateway plus local models on school-owned hardware, serving the AI and coding classes both. The frontier stays one hop away through the same gateway, so nothing feels downgraded. Local carries the routine, the high-volume, and the private work. | Load-tested for a full class; governance settled; a second node planned for the whole school. |
| Scale: the decade | The program across the curriculum: student crews, a roster of open-weight models that turns over, the cost-and-carbon study as a record that grows for years, and a story earned by the work. | Ongoing. The gate is honesty: every claim carries a measurement. |
The Law
The anti-workaround law
Red-letter rule
The standard has to be the best tool in reach, or we route around it, students and teachers alike. We treat that as a law. So the standard is never a model held back to save money. The frontier is always one hop away through the gateway. Local models earn their place on their own merits, free and private and unlimited and ours, never a downgrade we impose. The gateway holds back nothing on quality, it can serve the frontier. Quality is set by the model we pick and the budget we set, and both are ours.
Day One
Field note the whole program in miniature · nothing bought
How we start, with what we have
The test of all of this is whether it reaches the first day of class with nothing bought. It does, and that first move is the whole program in miniature.
What we have: a machine in the room, free software, one open-weight model, and browsers pointed at the frontier.
The move: we stand up one local model, the biggest the machine will hold, even a 7 to 8 billion parameter coder. On day one our students run the same real task against the local model and the frontier side by side, and they start the log that runs for ten years: does it work, how fast, what did each one cost. Then the sentence that plants everything: this model runs on that machine, in this room, and it is ours; the other lives in a data center we rent. Over this class and the years after it, we build and run and answer for our own.
That one exercise holds the two layers, the honest accounting, the open weights, and a student's hand on the stack. Nothing is bought, no one is asked. Everything else is that first day, scaled up.
The Accounting
What it costs and needs, honestly
Phase 0 is a subscription per student, about the price of one streaming service a month, on hardware we already own. Phase 1 is one GPU workstation in the low five figures, or a rented card measured in dollars an hour with nothing bought up front, which is how we prove the numbers before we spend. Phase 2 is a real purchase, earned by the Phase 1 study rather than argued from a slide. The whole point of the phases is that we never buy ahead of the evidence.
Open Questions
Open Questions
The honest ones we carry into the build. What is the real budget line for a school-run gateway, and in time for school-owned compute, and who signs it. How do the people who keep our network running want the lab layer to sit next to the production layer, and what does student data staying on our own metal change about that. Who holds the production layer when a class graduates and the next one arrives. None of these block the first day of class. All of them decide how far the thing goes.
The Trap
The one trap
The story is what falls out of doing the real thing well. It is never the point. The moment we build the program for the telling of it, it rots, and the rot shows. So we build the real system, teach the real stack, measure the real costs, and let the story arrive on its own and hold up to a hard look. That order is the whole discipline.