HTTP/2 Streaming

Multiplexing is the foundational feature that allows multiple independent request/response streams to be interleaved and transmitted concurrently over a single TCP connection. This eliminates the head-of-line blocking problem inherent in HTTP/1.1, where a slow response could delay all subsequent requests on the same connection.

• Each stream is identified by a unique integer ID.
• Frames from different streams can be mixed on the wire.
• This enables efficient use of network resources and reduces latency for applications making many parallel API calls, such as an AI agent fetching data from multiple services simultaneously.

Unlike HTTP/1.1's strict request-response cycle, HTTP/2 streams are bidirectional. Once a stream is initiated by a client request, the server can push additional data frames on that same stream without a new client request. This is distinct from Server Push, which initiates new streams.

• Enables server-sent events and real-time updates within an existing context.
• Critical for gRPC, which uses HTTP/2 as its transport to support true bidirectional RPC streaming.
• Allows an AI agent to maintain a persistent, stateful dialogue with a backend service, receiving incremental results or status updates.

HTTP/2 allows clients to assign weights and dependencies between streams, signaling to the server how to prioritize resource allocation (e.g., bandwidth, CPU).

• A stream can be declared as dependent on the completion of another stream.
• Each stream is assigned a weight between 1 and 256.
• This enables intelligent resource management; for example, an AI agent could prioritize fetching critical authentication tokens (high priority) before loading large, secondary data assets (low priority).

Flow control in HTTP/2 operates at the stream and connection levels, preventing a sender from overwhelming a receiver with data. It uses a credit-based window update mechanism.

• Each stream has a configurable receive window.
• Receivers advertise their window size; senders cannot exceed it.
• This is essential for managing memory and processing load, especially when an AI agent connects to a resource-constrained edge device or when handling large, streaming API responses.

HTTP/2 uses the HPACK compression format to significantly reduce the overhead of HTTP headers, which are often repetitive (e.g., Authorization, Content-Type).

• HPACK uses static and dynamic table-based compression.
• Previously sent header fields are stored and referenced by an index.
• This reduces latency and bandwidth, which is crucial for AI agents making frequent, small API calls where header size can be a large proportion of the total request.

HTTP/2 introduces a binary framing layer between the socket interface and the higher-level HTTP API. Communication is broken down into small, manageable frames (HEADERS, DATA, SETTINGS, etc.).

• Frames have a standard structure: Length, Type, Flags, Stream Identifier, and Payload.
• This binary protocol is more efficient to parse than HTTP/1.1's text-based protocol and less prone to errors.
• It provides the mechanical basis for multiplexing, prioritization, and flow control, forming the reliable transport for Model Context Protocol (MCP) and other AI-agent communication.

A web standard allowing a server to push real-time updates to a client over a single, long-lived HTTP/1.1 or HTTP/2 connection. Unlike WebSockets, SSE is a one-way channel from server to client, using a simple text-based event stream format. HTTP/2 improves SSE by allowing multiple concurrent streams over one connection.

• Text-Based Protocol: Data is sent as a stream of UTF-8 encoded event messages.
• Automatic Reconnection: Built-in client mechanism to reconnect if the stream is closed.
• Common Use Case: Ideal for live notifications, dashboard updates, and progress events where only server-to-client push is required.

A network address (URI) that accepts WebSocket connections, enabling full-duplex, persistent communication channels between a client and server. While WebSocket establishes its own protocol over a single TCP socket, it can be negotiated and proxied over HTTP/2. It is an alternative to HTTP/2 streaming for true bidirectional, message-oriented communication.

• Full-Duplex: Simultaneous two-way communication.
• Message-Based: Data is framed as discrete messages, not a continuous byte stream.
• Handshake: Initiated via an HTTP/1.1 Upgrade request to switch protocols.

The core feature of HTTP/2 that allows multiple independent streams of data (requests and responses) to be interleaved and transmitted concurrently over a single TCP connection. This eliminates head-of-line blocking at the application layer, where a single slow request does not block others.

• Stream Identification: Each stream has a unique integer ID and can carry bidirectional data.
• Frame-Based: Communication is broken into small, interleaved frames (HEADERS, DATA).
• Performance Impact: Drastically reduces latency and connection overhead compared to HTTP/1.1, where multiple parallel connections were required.

A critical resilience design pattern for clients, including those using HTTP/2 streaming. It monitors for failures and, when a threshold is exceeded, "trips" to fail-fast and prevent cascading failures. This allows the downstream service time to recover.

• Three States: Closed (normal operation), Open (failing fast), Half-Open (probing for recovery).
• Application to Streaming: A breaker can trip if a streaming connection repeatedly fails or times out, stopping further connection attempts.
• Integration: Often implemented in API client libraries and service mesh sidecars to protect systems.

A software component that translates requests and responses between different API protocols or data formats. An adapter might sit between an AI agent expecting HTTP/2 streaming and a legacy service that only supports HTTP/1.1 or a queue-based system.

• Protocol Translation: Converts between gRPC/HTTP2, REST, GraphQL, or WebSocket.
• Data Transformation: Maps between JSON, Protobuf, XML, or Avro schemas.
• Key Role in Integration: Enables interoperability in heterogeneous environments, acting as a bridge for AI agents to connect to any external system.