The north star, in plain words

This explains the north star for people who don't work in AI: what ownership would mean, how the software would work, and how much is built.

The short version

What I'm building

Turn the AI you rent from a few big companies into AI you own: it runs on machines you control, learns from your own work with your permission, and keeps working even if those companies cut you off.

A hosted AI service sends your questions to a provider's computers and brings the answers back. Access depends on that service's price and rules. I want people to have a useful alternative they can keep running themselves.

The problem

What a provider controls

Depending on a few AI providers gives those providers substantial control over your work:

• You depend on them. Your memory, your reasoning help, your everyday tools are all borrowed, from a company you can't really afford to leave. The rent never ends.
• They can watch you. The same system that helps you is the one that sees everything you ask it. And as AI helpers move onto your computer, reading your screen and your files to do tasks for you, "everything you ask" is becoming "everything you do."
• They decide who's in. They set the price, the rules, and who gets to keep using it, including for the work you helped make it good at.

My larger worry is that AI could reduce how much powerful people need everyone else's labor. That need has been a source of bargaining power. I want capable AI to be more widely owned.

What I'm building instead

The rented AI becomes the teacher; the AI you own becomes the worker

AI you own. "Own" means four plain things: it runs on machines you control, it got smarter by learning from your own work, it keeps going when you're cut off from the big AI companies, and over time it handles more of what you used to rent.

It comes together in two pieces.

The first piece runs AI on machines you control. It works on Apple silicon today. Workstations, office racks, and servers you administer are part of the broader ambition. A small model is less capable than the biggest rented one; the question is whether it can handle enough of your recurring tasks to be useful.

The second piece is the learning loop, still in build. You would keep using rented AI for difficult tasks. Software on your machines would retain a private, encrypted record with your permission, then use it to teach a smaller model the work you do regularly.

The smaller model would take over tasks after passing a quality check. The measure of progress is how much of your real work it can handle without calling the rented service.

The test that keeps it honest

Unplug from the big AI companies

Unplug from the big AI companies. If your own machines still do the share of your real work you said they would, as well as you said they would, then you own something. If they can't, you're still just renting with extra steps.

Measure that share across the full set of machines you've chosen and control. The task and quality bar must be declared before the test. The company exists to make that share grow.

What exists today

What's running and what's still early

• Running now: the software that runs AI models on your own Mac, and the software that sits between you and the rented AI. More of the system is already written and waiting on release.
• Just proved: two real Macs, on a real network, each learned from its own work and then traded what they learned. Three rounds in a row, both ended up with byte-for-byte identical results. Small task, published with its failures. That was two machines, not a group. A whole group learning together is what I'm building next, and I won't claim it until it runs. A public page tracks which claims are measured and which are still pending.
• Building now: the learning part, where the record of your own work teaches a model that belongs to you. Then the group version, so people who trust each other can pool the effort without handing over the work itself.
• Sharing is a dial, not a switch: you decide how much leaves, from nothing to everything, and the answer can be different for different work and for every connection. Out of the box, everything is set to share as little as possible while still doing the job. The dial works both ways: you also choose what your machines accept from others, and what comes in gets checked before it's mixed into your model. One honest note: sharing what a model learned is not the same as sharing nothing (even that can hint at the work underneath), which is why the public ledger says which settings have actually been tested.
• A guard at the door (in build): before anything leaves your machine, a model on your own machine can spot things you may not want to send (medical details, passwords, a client's secrets) and ask first. That check has to run on your machine; sending your data to a cloud service to ask "is this too private to send?" would be the leak itself. It helps you catch mistakes; it isn't a guarantee.
• Open on purpose: the building blocks published so far are open code. The standing rule is that anything we ship stays something you can inspect, run yourself, and walk away with. You should never need my permission to keep what you have.

Owning your machines reduces dependence on an AI provider. It does not remove every way someone could watch you or cut off a resource you need.

What's next

One narrow task, then a paying customer

Next is the whole loop, end to end, on one everyday task: keep the record, teach the model on my own machines, measure it against the rented one, unplug from the companies, publish the numbers. Then the same loop runs on a customer's work. That's where the first revenue comes from: they pay to run AI on their own hardware, with a record of everything it did. Two steps, in that order, and no bigger claims until they're done. If the numbers come out bad, I'll publish that too.

Who it's for

Anyone who wants it

Anyone should be able to run the software without needing my approval. I keep a log of features and deals rejected because they would compromise that rule. It is empty as of this account; future entries should make the tradeoffs visible.