FrogNet is a self-forming mesh infrastructure that allows full web applications to operate across any available transport, including environments where the Internet is unavailable. This paper describes the layer that makes that possible.
The Packet Problem
The Internet moves packets. Routers look at addresses and forward them. They don't understand what they're carrying. A packet full of sensor data looks exactly the same to the network as a packet full of cat pictures.
That was intentional. The original Internet prioritized simplicity — routers were meant to be fast, dumb devices whose only job was to forward packets. For most applications, this works fine.
But for systems operating across constrained links, it creates a problem that becomes the dominant constraint on the entire system.
The Redundancy Nobody Talks About
Most modern applications transmit the same structured data over and over again.
A temperature sensor sends a JSON message every thirty seconds. It looks something like this:
{"sensor": "temperature", "location": "node7", "value": 21.4, "timestamp": 1712345678}
Thirty seconds later:
{"sensor": "temperature", "location": "node7", "value": 21.5, "timestamp": 1712345708}
Almost the entire message is identical. Two fields changed. Everything else — the field names, the structure, the sensor identifier, the location — is the same as it was thirty seconds ago and will be the same thirty seconds from now.
Traditional networking transmits the entire message every time. Every thirty seconds. The full payload. Plus HTTP headers, status codes, content-type declarations, connection management. All of it.
On a gigabit link, nobody cares. The inefficiency is invisible.
On a 4800-baud radio channel with 20% packet loss, that inefficiency is the reason the system doesn't work. It's not that the radio can't carry the data. It's that we're sending a hundred times more data than we need to.
What I Built
FrogNet puts a semantic layer between the application and the transport.
Instead of treating every message as an opaque blob of bytes, the system learns the structure of what's flowing through it. It watches real traffic — JSON, XML, HTML, CSV, whatever the application produces — and builds templates automatically. No schema files. No configuration. It just watches and learns.
The first time a message type appears, the full payload crosses the wire.
After that, only the fields that actually changed get transmitted. The system sends a bitmap identifying which fields are different, followed by the new values. Nothing else.
If nothing changed at all, the system sends a single token that says "same as last time." Twenty bytes. That's it.
A 10KB sensor response drops to about 50 bytes when a few fields change. In steady state, repeated exchanges collapse to micro-tokens as small as 16 bytes. The 93.8% bandwidth savings I measured on the production testbed is not a theoretical number. It's what the system actually does with real traffic.
Why This Changes Everything
This isn't generic compression. I'm not running gzip on the wire. The network understands the structure of what it's carrying.
That distinction matters because it changes what's possible across constrained links. Not incrementally — fundamentally.
A web dashboard that would choke a radio link with raw HTTP updates in real time when only the changed values cross the wire. A sensor network that would need broadband infrastructure to function runs fine over a link that barely qualifies as data. A distributed application that would stall on a satellite connection stays responsive because it's transmitting a few dozen bytes instead of ten thousand.
The system adapts to whatever bandwidth exists instead of demanding that the bandwidth meet the application's expectations.
The Missing Piece
Traditional networks are deliberately unaware of the data they carry. That was the right design for the original Internet, and it still is for the transport layer.
FrogNet doesn't replace that. It sits above it.
The transport layer still moves packets. The semantic layer decides how much information actually needs to be in those packets.
The original Internet routed packets. FrogNet routes meaning.
That's the piece that was missing. That's what lets modern software architectures operate in environments where traditional networking assumptions stopped being true a long time ago.