The Wiring Diagram Gets Wires

I wrote the first version of Everyone Eats around a simple question:

What if hunger isn't primarily a food problem?

Not everywhere. War is real. Drought is real. Crop failure, displacement, poverty and political violence are real.

But in a wealthy city surrounded by food?

We grow food. We throw food away. People still go hungry.

That starts looking less like scarcity and more like architecture.

The original diagram

Hyperlocal production. Adaptive distribution. Personalized nutrition when people choose it. Waste elimination. Economic restructuring.

Five layers. But there was a problem hiding in the middle of the diagram.

How do they actually talk to each other?

A farm knows it has forty pounds of tomatoes. A school knows it needs lunch ingredients tomorrow. A food pantry knows what disappeared fastest this week. A restaurant has twelve pounds of produce that won't survive another service. A neighborhood refrigerator has six empty shelves.

Everybody knows something. Nobody speaks the same language.

And if the solution is one giant company sitting in the middle of all of them, owning the database, deciding who gets access and eventually charging rent on the network — we haven't solved the problem.

We've built another landlord.

The AI isn't the product

Everyone Eats v2.1 changes the center of the architecture. The important thing isn't an app. It isn't a dashboard. It isn't an AI model.

It's a protocol. A common language through which independent participants can describe what they have, what they need, what happened and what failed.

Not because everything in life should become a database object. Because if we're going to claim a system works, we should be able to see where it doesn't.

No invisible optimization. No magical AI. No success metric that quietly changes after the experiment begins.

Open. Federated. Contestable. Forkable.

One way to build this is Facebook: everybody joins one platform. The platform owns the relationships, sets the rules, and eventually the network itself becomes the moat.

The other is email. Gmail doesn't have to own Proton Mail for them to communicate. Nobody needs permission from Microsoft to invent another mail client. The protocol is more important than any participant.

Everyone Eats should work like the second one.

A city should be able to replace a vendor without replacing the network. A nonprofit should be able to build its own interface. A farmer shouldn't need to surrender customer relationships. And no person should need a wearable, an AI assistant or a smartphone to eat.

A pilot that cannot fail cannot be trusted

The earlier versions had a lot of beautiful numbers. A projection becomes dangerous when typography makes it look like an observation.

So v2.1 separates them. Some numbers are evidence. Some are assumptions. Some are targets. Some are questions.

The financial model exposes the assumptions instead of burying them. The pilot has to be capable of telling us no: the coordination savings aren't large enough; food doesn't arrive reliably enough; administrative burden exceeds the benefit; coverage becomes less equitable; the protocol creates more complexity than it removes.

Then we change it. Or kill it.

Then put one rack in the garage

Everyone Eats has a physical child now. Its name is Neon Eden.

Not a citywide hunger operating system. Not two thousand vertical farms. Not a hundred-million-dollar infrastructure project.

A garage in Appleton. Racks. Lights. Microgreens. A 10-to-14-day biological loop. That's it.

The current plan begins with roughly $5,050 in Phase 1 hardware, a zero-lease facility, explicit regulatory and food-safety gates, and a production model that has to survive contact with actual customers before it earns the right to expand.

There is already local competition. Good. There are licensing questions. Good. They're gates.

Neon Eden is Node 01. One tiny production node underneath a much larger idea. The architecture doesn't get to claim the node as proof. The node gets to test the architecture.

What exactly would the computers say to each other Tuesday morning?

That is progress. There is now a protocol specification. Canonical objects. An API surface. Transaction states. Audit rules. A pilot design. A financial model whose assumptions are supposed to be attacked. And explicit conditions under which the experiment should stop.

It is still a proposal. It is still unfinished. Large parts may be wrong.

Good. Now they're specific enough to be wrong in useful ways.

The next version shouldn't primarily add prose. It should run. A simulated supply offer. A real demand request. A match. A transfer. A receipt. An audit trail. One transaction moving all the way through the protocol. Then another. Then break it. Then learn.

The original idea was: Everyone Eats. Not charity. Infrastructure. I still believe that's the destination. But infrastructure isn't a manifesto.

Eventually, the wires have to carry something.