What does distributed systems have to do with AI?

We just launched Swytch 1.4 today … and I can’t begin to say how relieving that is. We’ve been quiet for just over a month now, and that’s terrifying when you’re starting out. From the outside, it looks like momentum has stalled.

That’s not the case here. If anything, momentum has been so high it’s been hard to keep up day-to-day. Swytch 1.4 enables search indices. And if you know databases/search indices at all … you might not think that is much of a big deal. Plenty of databases have search capabilities, and an index is literally why you have a database in the first place.

Right?

Yeah, you’re right. Absolutely and incredibly right. So, what makes Swytch special? It comes down to one of the hardest parts of distributed systems: you don’t know what you don’t know.

To Know or Not to Know

In normal distributed systems, you have a leader (most of the time) or you give up consistency guarantees to give up leaders. Swytch has no leader, and it’s serializable. It upends 40 years of distributed systems to pull it off. That means we have problems the world has never seen before and requires new solutions to “already solved” problems.

One of those problems is the index itself. An index works like the one at the back of a book: you’re looking for “cats,” and the index tells you every page that mentions them. Simple enough when one person has the whole book. A leaderless system is more like the book has been torn apart and scattered across an entire building, a few pages per person. You still need an index. But who maintains it?

Say someone writes a new page about “cats vs. ninjas.” In a leader-based system, the leader updates the index and tells everyone. Without a leader, the usual answer is to broadcast: either shout the update to the whole building or shout the question every time you search. Why? Because you have no other way to know your information is stale. You don’t know what you don’t know.

That’s the problem we had to solve.

And solve it we did.

A vacation that changed everything

The math that pulls it off is — honestly — a bit wild. We’ll share it properly when the paper is ready. But the more interesting story is what happened when I stopped thinking about it.

I took a deliberate “stop working on Swytch” vacation. I’d been working on Swytch over nights and weekends for half a decade, and now that it was my full-time job, I was pushing 80+ hours a week. It wasn’t healthy. So I stepped away and since I’d also been tinkering with Collibri (an MoE AI project), I decided to spin up a BabyLLM to see what had changed in neural networks since the last time I’d worked on them, 20-some years ago.

The answer: not a lot, and everything. It’s got more standardized, if anything. And the attention stuff is really wild and makes a lot of sense once you grok it.

But it was while I was implementing BabyLLM and training it for the first time that I realized the math I’d worked on for Swytch was nearly the same. Sure, different terms and different subjects; but the exact same otherwise.

If it had the exact same solution … would it allow learning during the forward pass?

Yes. Yes it did.

The Kestrel Project

Thus began the Kestrel project, which we’re telling the world about for the first time. This is an R&D project turned commercial, so you’ll have to wait for the paper before we share the math. But here’s the whole reason we’re here: the same math that powers Swytch’s leaderless indexing also enables modifying an LLM’s weights during the forward pass.

That’s not retrieval. It’s not a bigger context window. The model itself changes as it reads — every piece of knowledge becomes part of the weights, not something stuffed into a prompt. And just like Swytch, those weight updates can be merged across instances.

In practice, that means an AI that can read your entire codebase and have all of it reflected in how it thinks — not what it retrieves. There’s no context window to overflow, and what it learned last week is still in the weights, not in a chat log it summarizes and forgets. Multiple people can talk to the same model, and the learned knowledge merges naturally. Selectively.

We call these “brains.” Your personal brain holds what you’ve learned. Share a conversation with your team, and the team brain learns it too. That rolls up to a division brain, and so on. Not summarized. Merged. The CEO’s brain carries the same knowledge as the IC who learned it, plus everything HR learned, plus recruiting, plus engineering.

This thing is genuinely terrifying to think through until you remember the limits. Strong, mathematical limits. Catastrophic forgetting applies here: as it learns, it forgets something. Maybe a Roman Emperor, maybe the cast of Glee. Knowledge that isn’t being used fades, much like it does in a human. So no, we’re not claiming AGI. Not even close.

It also unlocks something we didn’t expect: targeted, semantic anti-learning. If knowledge lives in the weights, you can remove it from the weights. Not filter it, not refuse to talk about it… make it genuinely inaccessible. The model retains the surrounding skills, but the specific knowledge is gone. Not improbable to access. Impossible.

We’re working on turning this into a product, and if you’re interested in gaining early access, go sign up .