Open Foundation, Proprietary Application

Related: when the extraction question turns into a lawsuit, see Same Movie, Different Cast on Apple v. OpenAI's trade-secret fight.

There's a complaint circulating in developer circles about what someone called the extraction layer: DARPA funded the internet, universities trained the researchers, public grants paid for the transformer architecture that powers every AI product currently printing money — and private companies wrapped it in authentication, added a terms of service, and charge the public a subscription fee to access what the public already paid to create.

The complaint is legitimate. The framing of the choice it implies is not.

The article I read on this positions it as a binary: join the extraction layer or build deliberately against it. The author admits they're still figuring out which choice to make. I'm not. I play both angles, and I think it's the right move.

What the Binary Misses

The extraction critique treats "private" and "open" as mutually exclusive stances. They aren't. They operate at different layers of the stack, and the mistake is conflating them.

Infrastructure wants to be open. The closer an idea is to foundational — protocol-level, architectural, the kind of thing that becomes more valuable the more people use it — the more it belongs in the commons. Not because of altruism. Because that's how infrastructure works. TCP/IP is valuable because everyone runs it. The transformer architecture created more value by being published than it ever could have locked behind a patent.

Applications can be proprietary. The closer an idea is to specific implementation — how you route requests, how you structure the vault, how you wire 100 models together into a coherent system — the more it can and should remain yours. Not because it's a betrayal of the commons, but because the specific work of building something that actually runs in production is yours to own.

The people running the extraction layer haven't done something evil. They've done something incomplete: they've taken the open layer and built proprietary applications on top of it, but they've also tried to make the infrastructure itself proprietary. They've added friction to the protocol layer. They've built lock-in at the level that should be open.

That's the actual mistake. Not that they built a business. That they confused the layer.

How I Play It

I submitted a protocol to the IETF. AIGCSEP — a framework for how AI agents authenticate, communicate accountability, and operate under verifiable governance. That's infrastructure. It goes in the commons. The more people build on it, the more valuable it becomes for everyone, including me.

I also have proprietary ideas that build on that same structure. The specific routing logic in my AI stack. The vault architecture as implemented. The orchestration patterns I've developed over months of building real agent systems. Those are mine. They're built on open foundations — PyTorch, transformer models, cloud infrastructure descended from public research — but the specific work of assembling them into something that runs is a different thing.

These two positions don't contradict each other. They reinforce each other.

The open protocol creates trust and interoperability — other builders can build toward it, and the ecosystem it creates makes my proprietary applications more valuable, not less. The proprietary implementation funds the time I spend on the open work. Neither is parasitic on the other.

The Developer's Actual Choice

If you're building AI products right now, you are using public genius. PyTorch. The attention mechanism. The decades of publicly-funded research that made any of this possible. That's true. You didn't pay for most of what you're building on.

The question isn't whether to acknowledge that — you should — or whether to feel guilty about it — you shouldn't. The question is what you're adding and at what layer you're adding it.

If you're wrapping public research in auth and charging rent without adding anything at the infrastructure layer: that's the extraction layer, and the critique lands.

If you're building genuine application value on top of public foundations, sharing what belongs at the protocol level, and keeping what belongs at the implementation level: that's not extraction. That's how the stack is supposed to work.

The internet itself runs on this model. Open protocols, proprietary services. Linux runs on it. Open kernel, commercial distributions. The argument that you must choose between sharing everything and extracting everything is a false binary that ignores seventy years of evidence that the layered approach is what actually builds durable infrastructure.

Play both angles. Be deliberate about which layer you're on. That's the answer the extraction debate keeps missing.

— J.P. Howlett