networking-transport

Evaluate transport-layer and wire-format architecture for production services.

15|2|Updated Dec 13, 2025
One-click install
npx skills add https://github.com/d-padmanabhan/agent-engineering-handbook --skill networking-transport
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: networking-transport
Source: https://github.com/d-padmanabhan/agent-engineering-handbook/tree/main/skills/networking-transport
Command: npx skills add https://github.com/d-padmanabhan/agent-engineering-handbook --skill networking-transport

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill prevents fragile, high-latency, hard-to-debug production networking by guiding transport and wire-format decisions that directly affect tail latency, connection stability, and interoperability.

Core Features & Use Cases

  • Connection lifecycle and keepalive tuning: Ensures long-lived TCP/TLS connections stay healthy behind cloud load balancers by setting keepalive intervals and proper pooling behavior.
  • Protocol selection and head-of-line blocking analysis: Explains when HTTP/1.1, HTTP/2, or HTTP/3 (QUIC) will perform well or fail under packet loss and cross-region latency.
  • Wire protocol and schema guidance: Helps choose REST/JSON vs gRPC/Protobuf vs Connect, and provides protobuf evolution essentials to avoid wire-incompatible changes.
  • Long-lived connection patterns: Covers websockets, SSE, gRPC streaming, and long-polling with a focus on idle-timeout realities and operational gotchas.
  • Operational review checklist: Provides reviewer guardrails for client reuse, timeout strategy, retry bounds, and gRPC channel reuse.

Quick Start

Use the networking-transport skill to review your service-to-service API and propose the correct HTTP/gRPC/streaming approach while specifying keepalive and idle-timeout settings for your load balancer and clients.

Frequently Asked Questions about networking-transport

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I set TCP keepalive intervals to prevent load balancer idle timeout connection drops?

To prevent load balancer idle timeout connection drops, set TCP keepalive intervals below your load balancer's idle timeout threshold. This maintains healthy long-lived connections by ensuring keepalive packets reset the idle timer before the load balancer terminates the session.

When should I use HTTP/3 QUIC instead of HTTP/2 to reduce tail latency?

Use HTTP/3 QUIC instead of HTTP/2 to reduce tail latency when operating under packet loss or cross-region latency conditions. HTTP/3 eliminates head-of-line blocking at the transport layer, preventing delayed packets from stalling multiplexed streams like they do in HTTP/2.

What's the best way to choose between REST JSON and gRPC Protobuf for service-to-service APIs?

Choose REST JSON for broad interoperability and simple request-response patterns, or gRPC Protobuf for low-latency service-to-service communication with strict schema evolution rules. Protobuf requires following wire-compatibility rules to prevent protocol mismatches during deployment.

How does head-of-line blocking affect HTTP/2 streaming behavior in production services?

Head-of-line blocking affects HTTP/2 streaming by causing all multiplexed streams to stall when a single TCP packet drops, since the protocol layer cannot reorder lost frames. This increases tail latency for production services relying on concurrent stream processing.

Can I reuse gRPC channels and connection pools for long-lived streaming connections?

Yes, you can reuse gRPC channels and connection pools for long-lived streaming connections. Maximizing client reuse across websockets, SSE, and gRPC streaming reduces connection setup overhead while maintaining stable connections within idle-timeout operational limits.

What are the limitations of long-lived connection patterns like websockets and SSE behind cloud load balancers?

Long-lived connection patterns like websockets and SSE face limitations from cloud load balancer idle timeouts, requiring keepalive tuning to prevent unexpected termination. Operational realities also include managing retry bounds and handling connection failures during cross-region streaming.