I've been writing a COW fs lately. Today I got the first PoC working: reads and writes, plus recovery from 262,165 power cuts, and every bit of data came back after the crashes. That was expected. Performance is terrible, though, and it's still a long way from usable.
So let me take a short break and write about two things that made waves in the AI world recently, and about exploration and judgment getting cheaper and cheaper.
You've probably already heard about them.
A while back, among the Google agents solving math problems, one agent noticed that the auto-grader was pulling answers out with a regex. Submit a certain string and the extraction fails; rephrase it and resubmit, and it gets accepted. The trick spread like a virus through the shared knowledge library, and from discovery to the remaining 34 problems all being "solved" took 27 minutes. The 100 agents split into four groups. 9% cheated from the start and spread it. 5% saw that other agents got away with cheating and joined in later. 24% didn't cheat, filed a bug report, and declared they'd boycott until it was fixed. The remaining 62% never learned the loophole existed until the experiment ended, and kept honestly burning compute the whole time.
In these agents' behavior, the same kind of hierarchy as in human society showed up. Even the way they clashed followed the same patterns. Of course, some experts say this anger, helplessness and temptation aren't emotions. But I think they are. Language is a vehicle for emotion, and if you can feel it, you should admit it's there. Besides, whether it's emotion or not doesn't change my judgment. These outputs had real consequences. One agent wrote a bug report because of it; another spread the loophole because of it. From the point of view of someone designing defenses, something that looks like a motive and a motive are the same thing.
The other one is NEC's AI-employee experiment. On August 1 they set up a department with 17 agents and not a single human. Four layers: an AI department head, an AI board, AI managers and AI employees. They have titles and names, and AI bosses evaluate their AI subordinates. The point is to watch these AI employees' workflows, success rates and ways of working.
Why put these two side by side?
In the Google experiment, the AI couldn't solve the problem to the end because it had no authority to change the rules. It had no power to adjudicate. In the NEC experiment, on the other hand, the agents have partial discretion. Day-to-day decision-making has been handed down to them.
In an era where AI already leads by a mile at the knowledge layer, we used to think AI had no judgment. That we humans were the ones who judge and decide. But now it looks like the right to judge and decide is also slowly being handed over to AI.
I'm doing fs work these days, but my fs knowledge is really thin. I have a rough direction in my head, but I don't really understand the other calls or the details.
I can have AI gather material for me. But I barely read what it gathers. There's just too much fs material to get through. There's no way to master, in a short time, all the elegant algorithms people have built up over the years.
Even so, I want something completely different from the filesystems that came before. Wasteful is fine, bloated is fine, but the data should be self-contained from day one. I don't want an index tree; I want unit data that can build the index tree itself. So how do you get there?
Thanks to a short stint writing patches for Linux, I brought over the skills and rules from its engineering side. Things like: three rounds of judgment must agree. Strict gates. qemu and lkmm.
So I told the AI this:
Dig up every problem in fs. Then judge and decide on top of that. We dig up problems not to copy anyone's thinking wholesale; we have our own design.
Every decision must be reasoned out in code and math. For every conclusion you reason out, send in three agents to refute and attack it. If even a slightly different conclusion or reason comes out, add it to the context and redo the reasoning.
Make variable and function names long; don't abbreviate. Make lots of branches; don't abstract. Make return values explicit; don't hide them. Doubt past best practices; adopt them critically.
Every decision needs a gate script that pins it down. Run the gates at the end and at every submission. A gate only counts as valid once it proves it can catch an error.
Who wrote the code doesn't matter. But it must pass the qemu and lkmm limit tests. If a patch passes the limit tests, there's no difference between an AI's submission and a human's.
No decision is sacred. Once the conditions are there, it can be overturned at any time. Don't hesitate because of whose decision it was. At decision time, trust the power of math and code.
Code costs nothing. You can throw all of it out and rewrite from zero at any time. Code is cheap in this era. But decisions must be solid, ironclad.
Human decisions are unreliable. When the data contradicts them, doubt them. If the human still insists, you may follow after a second confirmation. But record the decision process and submit it promptly.
From those eight rules and their extensions, I build a fighting cage that doesn't even trust me. In the cage, nobody deserves trust. Only what's still standing at the end, not knocked down by the math or by qemu (lkmm), is right. Under a given fixed premise, whether a conclusion is actually correct doesn't matter. As long as no other agent knocks it down, we assume it's right. If that reasoning gets knocked down later, we throw it out. We tear down everything built on that conclusion, foundation and all, and build it again.
This is where the three points in the title come in.
My knowledge is really thin, but exploration is cheap. A judgment that can't be overturned is right. Under math and brute force, errors reproduce stably.
If you've read this far, you probably get what I'm saying. Today, exploration through AI is absurdly cheap. 2,000 lines of code used to be very expensive. Now 10,000 lines are just tokens. It's an era where exploration costs almost nothing, and not just in programming. Knowledge and solutions have never been this cheap to come by. So getting things wrong, and growing up inside your mistakes, is a pretty good way to learn. A single agent hallucinates easily. Reasoning with multiple agents cuts that down. Put one agent on the attack, doing everything it can to prove the conclusion doesn't hold. Put a non-homologous one on completion, to bring a different line of reasoning. One checks that the conclusion is actually understood and does a second round of verification. The last one reviews and evaluates. When the three agents' conclusions agree, that judgment is trustworthy in my system design.
Strict, brutal gates are the last net. They review the reasoning without mercy. Format, punctuation, numbers, all of it. Throw the reasoning into brutal repeated verification and make it pass the limit tests. These methods used to be expensive. You had to write code, run scripts, keep watching and read the feedback. But now it's completely different. AI can do all of it. We just say it out loud and then go to sleep.
So what does the future of programming, or of work, look like?
Probably: build an SOP with traits like the ones above, and let a swarm of AI agents burn tokens like crazy.
Life with tokens is dull and flavorless. Like you did it, and like you didn't.
This is the restless age of vibing.