Zero-Prefill Keep-Alive

The challenge

Standard keep-alive patterns prefill a session with speculative data so the connection looks busy. The prefill cost shows up at scale and the speculative data often has to be discarded on the first real exchange.

My role

I am drafting a publication on a transport pattern that keeps the connection useful without the prefill cost — the connection stays alive, the audit chain stays clean, and no speculative data is shipped over the wire.

What I did

1. 01

   Connection-state primitive instead of prefill packets

   Why: The keep-alive is encoded in a connection-state primitive rather than in speculative data. The receiver knows the connection is alive because the primitive says so; no payload needs to ship.

   Trade-off: The pattern requires both ends to opt in. A server that does not implement the primitive falls back to standard keep-alive with the prefill cost it already pays.

2. 02

   Audit chain stays honest

   Why: No speculative data over the wire means no speculative data to invalidate when the first real exchange happens. The audit chain does not need a 'discard the prefilled bytes' step.

   Trade-off: The honest audit chain is more verbose than the dishonest one. Worth it for an operator who values reproducibility over hand-waving.

What changed

• Prefill bytes shipped per keep-alive

  Before: Variable, speculative

  After: Zero — connection-state primitive only

• Discard step in the audit chain

  Before: Required — discard prefilled bytes on first real exchange

  After: Not required

Trade-offs

This is a draft; the public gist is pending. The reference demo lives in the operator's local transport harness until the publication is ready to ship.

What I learned

A keep-alive pattern that ships speculative data is not a keep-alive — it is a polite lie that compounds over the lifetime of the connection.

Stack

• networking
• transport
• keep-alive
• operations