Building a university for AI sounds absurd on its face.
Humans need universities because knowledge transfer can’t be accelerated. You learn calculus, and your colleague doesn’t automatically learn it too. Everyone has to start from scratch. Education is one of the few efficiency bottlenecks in human society that can’t be bypassed through copying.
AI is different. Once a model is trained, its capabilities can be copied infinitely. You don’t need every AI instance to relearn Python or statistics. Train once, copy as many times as you want. Training a frontier model costs hundreds of millions, but distributing its capabilities to tens of millions of users adds nearly zero marginal cost.
From the perspective of knowledge transmission, educating AI is a problem that technology has already solved. So why talk about building a university for AI?
A model having general knowledge doesn’t mean it knows how to work in a specific environment.
An agent can write code, but it doesn’t know what counts as “written correctly” in this company’s codebase. It knows how to call APIs, but it doesn’t know how far the team’s API documentation diverges from actual behavior. It can generate an analysis report, but it doesn’t know what the team cares about when reading reports, which metrics they focus on, which sections they skip.
These things don’t come from pre-training, and they can’t be transmitted through model distribution. They are environmental operating knowledge, acquired only by actually working in that specific environment. This is the first entry point for the question of educating AI: intelligence can be copied, but adaptation to a specific work environment cannot.
So what if we write environmental knowledge into files and distribute them to all agents that need them?
That works. I have such a system myself. My friends and I jokingly call it Old Duck Soup.
What Old Duck Soup does isn’t complicated: it writes work standards, judgment criteria, and past mistakes into files, so agents can read them upon arrival and know the rules without being taught from scratch each time. The core idea is to strip out the background content that keeps recurring in prompts and sediment it into persistent files. An agent walks in, reads through once, and knows everything it needs to know.
I wrote about the complete design philosophy in a blog post, and open-sourced the reference implementation on GitHub. It’s worked well for over half a year.
But after running a comprehensive audit, I discovered a problem I hadn’t anticipated at all.
Old Duck Soup had accumulated a batch of legacy rules: rules that no one remembered why they existed.
The most typical case: a rule requiring a specific parameter when calling Claude Code. This rule originated from a bug in early 2026: Claude Code’s adaptive thinking mechanism had a flaw that would allocate reasoning resources to zero under certain conditions. I had investigated this issue, confirmed the workaround was effective, and wrote the rule into the documentation. The rule itself even included a note: “revert if upstream fixes this.”
During the audit, I discovered that this bug had been fixed months ago. But the rule was still there. Every new agent that took over read the rule and followed it exactly. Not a single one knew why it was supposed to do this. And no one had ever set up a review schedule.
The root cause of this goes deeper than a single outdated rule. The moment experience is converted into a file, a lossy compression occurs. An agent hitting a wall in the environment, investigating the cause, finding a workaround—this process contains far more information than a single line of instruction: specific system versions, specific error patterns, what would happen if you didn’t do this. These constitute the rule’s discovery context. But when you write it into a file, all you can preserve is the conclusion: add this parameter. Hundreds of lines of error logs, version numbers, debugging reasoning—all compressed into a single line.
A new agent reading this instruction holds a conclusion without a cause. It doesn’t know what this rule protects, doesn’t know what the preconditions are, doesn’t know under what circumstances it can stop following it. It can only comply. A behavioral rule stripped of its causal chain, executed as an unquestionable directive—this is the mechanism by which superstition forms.
The same audit turned up more problems: duplicate entries in the rule index, broken links pointing to renamed projects, statistics in the axiom system that didn’t match the actual count. Every problem traced back to the same root: the system only had an add operation, no retire operation. Rules could only be added, and once added, no one touched them.
Human organizations call this institutional calcification. AI systems produce the exact same thing, just ten times faster.
I always thought of Old Duck Soup as the agent’s memory. But memory is bound to experience. You remember why you added that parameter because you lived through that failure, dug through that issue, verified that workaround. Memory stays fresh through the experience that produced it.
Files can’t do this. Files are separated from the subject. They only record conclusions, not experiences. They don’t update themselves, don’t automatically mark themselves as obsolete when preconditions disappear. That outdated rule in Old Duck Soup is like a ten-year-old textbook still teaching you to save files to a floppy disk. Textbooks need periodic new editions.
You can’t sit in your office and guess which page has gone stale, just like I couldn’t guess that the bug had already been fixed. The only effective signal for revision comes from students going back into practice and hitting walls.
The mechanism works like this: periodically send an agent carrying none of the old rules into the current environment to execute real tasks. It has all of pre-training’s capabilities, but none of Old Duck Soup’s accumulated workarounds.
If it completes the task smoothly, it means those old rules are already dead. The environment fixed itself, or the rule’s preconditions have disappeared. The team can safely delete them.
If it hits a wall, making the exact same mistake recorded in Old Duck Soup, it means the rule is still protecting the system. But this failure does something more important: it generates a fresh discovery context using the current environment in real time. This new experience can replace the stale one-line conclusion in the old file, giving the rule back its causal chain of why it should be done.
Three things merge into one action. The exam is the agent’s actual performance in the environment. Textbook revision is deleting dead rules or refreshing live ones based on exam results. Education is the net effect of the whole process: Old Duck Soup stays fresh, the agent becomes useful for the current environment. Every time a student hits a wall, it’s a signal for a new textbook edition.
So if we built a university for AI, what it teaches would be completely different from a human university. Pre-training has already given AI all its general knowledge, and this part can be copied infinitely. The university’s main function is anti-degradation: periodically pushing agents back into the environment for naked runs, checking which of their inherited rules are still alive and which have devolved into legacy rules. Living rules get re-injected with discovery context through regression testing; dead rules get cleaned out.
It’s more like an annual inspection. You don’t need to retake your driving test every year, but your car needs to go back to the inspection station annually to check which parts still work and which need replacing. Old Duck Soup needs this kind of annual inspection too. Otherwise it will quietly turn into a moldy old textbook, where every rule looks reasonable, but no one knows whether they still point to the real world.
I manually cleaned up the most obvious cases found in the audit this time. But manual cleanup is itself just a stopgap. The real solution is to turn annual inspections into an automated process: periodically run a round of naked agent regression tests, letting the environment’s real feedback determine which rules stay and which go. At that point, an AI university is no longer just a metaphor. It’s an engineerable system that keeps rule sets maintained through continuous environmental feedback.
Building a university for AI ultimately delivers an anti-aging inspection pipeline. Through continuous testing and cleanup, it keeps the rule system always connected to the real world.