Summary

  • RFC 10036, published on the IETF Standards Track in August 2026, registers the Boolean Incremental HTTP field. ?1 asks supporting intermediaries to forward one message's content as it arrives; it does not command unknown intermediaries or prove end-to-end streaming.
  • A supporting intermediary should send the header section and continuously release content rather than wait for the complete message. It may still buffer headers, trailers and bounded amounts of content. If it understands the field and refuses outright, it must return an error instead of silently substituting full-message buffering.

Imagine a risk-feed endpoint that produces one event every second. The origin writes its response headers at 09:00:00 and its first event at 09:00:01. The first reverse proxy forwards both promptly. A security gateway then waits for the response to finish so it can inspect the complete body. The body is intentionally long-lived, so the client sees nothing. At 09:05 the origin, gateway and client can all report a healthy connection while the product has delivered no useful event.

The sender's header was true. The user's experience was also stalled. Those statements are compatible because the field expresses intent and each buffer retains practical control over release.

RFC 10036, published in August 2026, addresses this exact gap. HTTP Semantics permits recipients to process a message as portions arrive, but it also permits intermediaries to buffer or delay forwarding. That freedom is often useful for efficiency, availability, access control, content inspection or transformation. It becomes destructive when the application requires progress before the message is complete.

Server-Sent Events supplies the clean one-way example: a response can remain open while notifications arrive over time. A proxy that insists on the complete response can wait forever. The Chunked Oblivious HTTP Messages draft, which RFC 10036 cites as work in progress, shows the two-way problem: if a request and response are intended to make progress together, full buffering in either direction can prevent either side from proceeding.

RFC 10036 does not abolish intermediary discretion. It makes a previously hidden application requirement explicit and defines what an implementation that understands it should do.

One Boolean, four materially different states

Incremental is an Item under Structured Field Values for HTTP, and RFC 10036 accepts only a Boolean. The valid true form is:

Incremental: ?1

It asks intermediaries to forward the message incrementally. The valid false form is:

Incremental: ?0

It leaves the HTTP default in place, under which an intermediary might buffer the entire message; the explicit false value may give the intermediary more confidence in choosing that mode. An absent field makes no request under RFC 10036. A value of the wrong Structured Field type is ignored.

These four states must not be collapsed. True is not an end-to-end mode bit. False is not an order to buffer. Absence is not a negative acknowledgement. Invalid syntax is not evidence that the path rejected streaming. Each is only input to a recipient that may or may not know the field.

IANA now lists Incremental as a permanent HTTP field of Structured Type Item in the HTTP Field Name Registry. That registration protects a shared name and grammar. It says nothing about which products, routes or resources implement the behavior.

Direction belongs to the message, not the session

The field applies to each HTTP message. If an application needs a request body to flow progressively toward a server and an early response to flow progressively back, ?1 must appear on both messages. A true request does not authorize an intermediary to infer a true response. A response header cannot repair a request body that an earlier hop already stored in full.

This directionality is operationally important. Teams often record a trace-level label such as “streaming enabled” and then apply it to a whole exchange. The request and response can traverse different internal components, encounter different security rules and experience different backpressure. A retry may select a different edge or origin connection. Evidence has to retain direction, message identity, attempt and path.

RFC 10036 says a supporting intermediary receiving ?1 should not buffer the entire message before forwarding it. It should send the header section downstream and continuously forward content bytes as they arrive. Yet the field is about content. The intermediary may still collect the complete header section before sending it, and it may collect the complete trailer section. That distinction prevents “incremental” from becoming a vague promise that every octet crosses every boundary instantly.

The same request reaches HTTP APIs. Most expose some incremental transfer mechanism, but an implementation whose API tends to buffer should use the field to reduce or disable that behavior. Again, this is a local act. A library that exposes a streaming reader does not prove that an upstream WAF delivered progressively, and a non-buffering reverse proxy does not prove that the application framework consumes each chunk promptly.

An understood refusal must become visible

The strongest governance contribution in RFC 10036 is not the true bit. It is the rule against a particular ambiguity. If an intermediary understands the field and decides outright not to forward the body incrementally, it must generate an error response rather than accept the message, hold all content and forward it later as though the request had been honored.

That rule creates a boundary between non-adoption and contradiction. An unaware intermediary can still ignore an unknown field and buffer. A supporting intermediary can comply. An understanding intermediary can refuse. What it cannot do is knowingly replace the requested mode with complete buffering while presenting ordinary success.

For a permanent security conflict, the RFC recommends 501 Not Implemented with the incremental_refused error in Proxy-Status. A gateway that must see the complete body before it can decide whether the content is safe cannot simultaneously release that content downstream. The correct outcome is an explicit incompatibility, not a hidden latency trap.

The IANA HTTP Proxy-Status registry records incremental_refused with recommended status 501 and specifies that only an intermediary generates that response. The label locates a class of decision; it does not mean the origin rejected the application request.

Capacity creates a different refusal. Long-running incremental exchanges consume connections, request slots, memory and scheduling attention. An intermediary may apply a tighter concurrency ceiling to them so ordinary traffic retains capacity. When that ceiling is reached, RFC 10036 recommends 429 Too Many Requests, as defined by RFC 6585, with the connection_limit_reached Proxy-Status error. Security incompatibility and temporary scarcity should not share one undifferentiated failure counter.

Small buffers remain legitimate—and measurable

Incremental forwarding is not a command to turn every arriving byte into a separate packet. An attacker could exploit immediate forwarding to force work on a flood of tiny writes. Even a benign application can impose excessive framing, scheduling and network overhead if every small fragment is flushed independently.

RFC 10036 therefore permits a small amount of buffering. An intermediary can hold content until a byte threshold or a time threshold is reached. The limit cannot be indefinite, and the trade-off must remain visible: larger batches improve efficiency but increase application latency.

This is why “first byte arrived” is an incomplete service objective. A proxy may release the first fragment promptly, then accumulate later fragments for seconds. A client may receive regular bytes that do not yet form one useful event. A response may complete successfully after violating every interactive latency promise the application depends on.

Measure header completion, first content byte, periodic byte progress, the longest inter-byte gap, first complete application event, trailer arrival and message completion. Record them at more than one boundary. The origin's write timestamp, the edge's send timestamp and the client's consume timestamp answer different questions.

Proxy-Status is a witness, not a packet capture

RFC 9209 lets intermediaries describe their response handling through Proxy-Status. Members are ordered from the intermediary closest to the origin toward the one closest to the user agent. Errors can identify a generated response, and a streaming intermediary can sometimes add later information in a trailer.

The facility is deliberately bounded. Intermediaries choose when to emit it, may withhold details to protect topology, and are not required to disclose every parameter. RFC 9209 also warns that its contents are not verified. An intermediary can describe an action that its running system did not in fact perform.

Treat a specific incremental_refused report as useful evidence of an explicit decision. Do not treat an absent report as proof of support. An unaware hop will not generate the new error. A policy may suppress Proxy-Status. A trailer may be discarded. A misleading field may survive while the data path behaves differently.

The decisive evidence is reconciliation: the field received, parser result, policy decision, buffer thresholds, bytes received, bytes emitted and downstream observation on a common trace and clock.

The header cannot choose the architecture

RFC 10036 says the field can facilitate a bidirectional byte channel when it appears in both request and response, including forwarding an early response before the request is complete. It also says that Extended CONNECT for HTTP/2 and Extended CONNECT for HTTP/3 are generally more consistent with HTTP's architecture for bidirectional protocols.

That advice prevents a useful field from becoming a universal tunnel claim. A progressively consumed representation, an event feed and a true duplex protocol have different failure and lifecycle needs. If the product needs independent messages in both directions, long-lived flow control, explicit protocol selection and tunnel semantics, forcing the design through two incrementally forwarded message bodies may preserve an attractive URL while obscuring the actual contract.

Prior knowledge or a probe can establish support for a specific resource and path. Neither creates a timeless global capability. Routes change, inspection policies change, software versions change and capacity changes. A canary that worked yesterday is a baseline for comparison, not inherited authority over today's bytes.

The RFC Editor's errata query for RFC 10036 showed no matching report when checked on 30 August 2026. That is a dated observation about the record, not a guarantee that future corrections will never appear.

One trace must join intention to delivery

A defensible incremental-delivery record starts with the application resource and direction. Retain request identity, attempt, HTTP version, connection identity, route and retry path; the exact field value received and forwarded; parse result; support and security-policy version; capacity admission; byte and time flush thresholds; header-complete time; first and periodic body-byte receive/send times at each boundary; longest gap; first useful application event; trailers, completion, cancellation and reset; status and Proxy-Status; and a control without the field or with ?0.

Probe both normal and hostile shapes: one byte at a time, slow periodic events, bursts, backpressure, a body that never completes, a security rule that requires whole-content inspection, concurrency exhaustion, cancellation, retry and a path change. A system that passes only a fast laboratory stream has not demonstrated the operational property.

Heng Lu's Running-Code Primacy places authority in this executed sequence, not in publication or configuration alone. His Minimum Initial Specification, Localized Future Decision, and Voluntary Adoption explains the virtue of RFC 10036's restraint: one common signal carries what must be shared, while security policy, capacity and architecture remain with participants running code. His distinction between technical and practical control explains why the sender can express a technically valid preference without controlling independent buffers in practice.

RFC 10036 gives the path a better question. It does not answer the question on the path's behalf.