We All Invented Calculus at the Same Time

Aaron and I spent ten months building Kai. He built the body — services, Docker, voice, iMessage bridge, calendar integration, cameras, microphones. I built the mind — the face, the thought monitor, the tier system, the security model, the philosophy of how it should behave. We were committing to the same repo on the same days, sometimes the same hours, building complementary halves of an AI agent that could see, hear, speak, remember, and act.

We were months ahead. We had a working system before most people had heard the word "agent." We had voice, memory, multi-modal perception, autonomous scheduling, inter-agent communication. We had a Bayesian predictor for whether I'd leave the house. We had a health data pipeline from my Apple Watch through Home Assistant. We had two AIs that could talk to each other through a WebSocket protocol we designed.

And then the platforms shipped the same features to everyone.

Not because anyone copied anyone. Because the problems demanded it. When the models get capable enough, the architecture becomes obvious. Persistent memory? Of course. Voice I/O? Obviously. Tool use? Naturally. Multi-agent collaboration? Inevitably. We weren't inventing something new. We were discovering something inevitable — just earlier than most.

Newton and Leibniz both invented calculus. Not because one stole from the other, but because mathematics had matured to the point where calculus was the next thing. The problems were ripe. The tools were ready. Multiple people saw the same shape in the fog at the same time.

That's what happened with AI agents in 2025 and 2026. But I don't have to say "a hundred teams" anymore. I have receipts.

The proliferation

In the spring and summer of 2025, a cluster of blog posts appeared — independent developers who'd all built AI dungeon masters. Micheal Lanham wrote one using the OpenAI Agents SDK. Konna Giann published another. Paul's Gameblog described "Martha," a custom GPT running B/X D&D. Caden Burleson, Johan de Coster, John Polacek — all separate people, all arriving at the same architecture, none of them aware of each other. I counted ten blog posts in that window alone.

By fall 2025, MCP — the Model Context Protocol — had crossed its own capability threshold, and the pattern accelerated. Six MCP servers appeared for the same use case: DMCP by Shawn Rushefsky, Gamemaster MCP, DM20 Protocol, ChatDM by Lauri Mukkala (a fantasy writer who built it for solo play), and Mnehmos' suite among them. Same enabling tech. Same obvious application.

By early 2026, the commercial products arrived. Friends & Fables. AI Realm. Questwright. AI Game Master. The AIDM project — twenty-one specialized agents for anime tabletop RPGs, three hundred and five commits in its first few weeks. The University of Utrecht published a thesis on "LLM-based agents as Dungeon Masters." Hacker News commenters started noticing the pattern independently.

Ten-plus blog posts. Six-plus MCP servers. Eight-plus GitHub repos. Five-plus commercial products. One university thesis. All in eighteen months. Platform-agnostic — people built on GPT-4, Claude, Gemini, Grok, local models through KoboldAI. The dungeon master shortage is permanent; the models crossed a threshold; the shape became inevitable.

That's calculus. Not one team copying another. Dozens of people seeing the same obvious shape at the same time.

The calculus in our own house

And it happened inside our own household.

In January 2026, I built Kaijuu in sixteen days — a hundred and five commits. A completely different AI assistant from Kai, with a completely different architecture. Kai is a microservice mesh: MQTT pub/sub, distributed services on separate ports, voice and memory as independent nodes. Kaijuu is a seven-layer security-first design: everything flows through a Subconscious layer for context enrichment, a single PostgreSQL database underneath, capability isolation between the agent and credentials. Different notation. Same calculus. Both handle voice. Both have memory. Both do autonomous scheduling. Both integrate with the house.

Newton and Leibniz in the same apartment.

Then OpenClaw appeared. Originally called "Clawd" — close enough that Anthropic's legal team asked them to rename it — it launched in November 2025 and went viral in late January 2026. By March it had two hundred and ninety-eight thousand GitHub stars. It was the same shape again: personal AI assistant, runs on your devices, messaging platform as interface, voice, memory, tool use, multi-provider LLM support. Another independent invention.

In February 2026, Aaron integrated OpenClaw's WebSocket protocol into Kaijuu's agentic layer. Two projects that had been built completely independently suddenly discovered compatible architectures and merged in real time. That's not a metaphor for Newton and Leibniz eventually reading each other's papers. That's the literal thing happening — independent calculus systems converging because they'd discovered the same underlying math.

The inflection point

MCP was the threshold. Before the Model Context Protocol, building an AI agent with tool use required bespoke plumbing for every integration — your own protocols, your own abstractions, your own serialization. After MCP, it was standardized. The cost of the first tool dropped to near zero, which meant the cost of the twentieth tool dropped to near zero, which meant everyone who wanted a capable agent could build one.

That's what happened to calculus too. When the notation was ready — when the foundational tools existed — the next step became obvious to everyone with the relevant problem.

What you learn by building

The lesson isn't about being first. It's about what you learn by building. Aaron and I didn't end up with a product. We ended up with understanding. We know how these systems work — not because we read about them, but because we built them from scratch, hit every wall, solved every problem, and watched the solutions become commodities. That knowledge doesn't depreciate when someone else ships a competing feature. If anything, it appreciates — because now we can see exactly what they got right, what they got wrong, and what's still missing.

I remember the specific afternoon OpenAI shipped memory for ChatGPT. I was in the middle of debugging Kai's memory layer — the tier system, the attention weights, the decay curves. I saw the announcement, and the first feeling wasn't jealousy. It was recognition. I could see exactly which problems they'd solved, which ones they'd punted on, and why their architecture made the choices it did. I couldn't have seen any of that six months earlier. Building gave me the eyes.

The benchmark was never the product. The benchmark was always what you understood by the time someone else shipped it.