Adnan KhanAdnanProduct & AI
San Francisco Bay Area
Get in touch

Source note3 min read

Pre-Compiled Pipeline Shards for Distributed LLM Inference on Intel AI PC Fleets

Source

arXiv

arxiv.org/abs/2608.19147v1

Read the source

Source

  • Source name: arXiv
  • Source kind: paper
  • Authors / organization: Tate Berenbaum, Muthaiah Venkatachalam
  • Venue: arXiv: cs.DC
  • Published: 2026-08-19
  • Collected: 2026-08-20
  • URL: http://arxiv.org/abs/2608.19147v1
  • PDF: https://arxiv.org/pdf/2608.19147v1
  • DOI: UNKNOWN
  • Registry group: academic_apis_and_preprints
  • Evidence role: canonical_academic_index
  • Language: en
  • Country / region: UNKNOWN

Plain-Language Brief

The authors present a method to distribute Large Language Model (LLM) inference across multiple Intel AI PCs using pre-compiled pipeline shards. This allows for efficient use of idle AI PCs with integrated GPUs and NPUs, even if they don't have enough memory to store large models like a 70B-parameter LLM. The method uses pipeline parallelism, where the model is split by layer into shards that are pre-compiled into OpenVINO graphs. Three techniques are used to make this fast: optimizing the speed of the unsplit model, leveraging speculative decoding on stateful OpenVINO models, and interleaving requests across stages. The method improves single-user throughput and can handle larger models that a single fleet member cannot hold.

What the Document Says

  • Modern Intel AI PCs have integrated GPUs and NPUs with unified memory of 16 GB or more, but they often spend time idle.
  • These AI PCs can serve models beyond their capability when working together over a network.
  • The authors use pipeline parallelism for this purpose: the model is split by layer into per-stage shards, each pre-compiled into an OpenVINO graph.
  • Three techniques make this fast enough: recovering the speed of the unsplit model, leveraging speculative decoding on stateful OpenVINO models, and interleaving requests across stages (micro-batching).
  • The method improves single-user throughput for an 8B INT4 LLM by 1.79x compared to the unsplit model on the same hardware.
  • The method also allows for serving a larger 70B model that no single fleet member can hold.
  • Code, raw benchmark logs, and reproduction scripts are available at a specific GitHub link.

Key Concepts Mentioned

  • Large Language Model (LLM)
  • Intel AI PC
  • Pipeline Parallelism
  • Pre-compiled Pipeline Shards
  • OpenVINO Graph
  • IndirectKVCache fusion
  • Speculative decoding
  • Stateful OpenVINO models
  • Micro-batching

Claims Made by the Document

  • Modern Intel AI PCs can serve models beyond their capability when working together.
  • The method improves single-user throughput for an 8B INT4 LLM by 1.79x compared to the unsplit model on the same hardware.

Evidence Used

  • The text describes how a few AIPCs working together can serve models beyond the capability of any single one.
  • The text mentions that a two-node Llama 3.1 8B INT4 pipeline serves two concurrent users at 1.79x the single-user throughput of the unsplit model on the same hardware.

Methods / Approach

  • Pipeline parallelism
  • Pre-compiling shards into OpenVINO graphs
  • Injecting a beam_idx Gather to trigger an optimization
  • Speculative decoding
  • Micro-batching

Limitations Stated by the Authors

UNKNOWN

Limitations Noted by the Agent

Agent interpretation — not from the source.

UNKNOWN

Open Questions

UNKNOWN

Notes for Future Q&A

May include interpretation. Labeled where it does.

UNKNOWN

Raw Abstract / Excerpt

Modern Intel AI PCs ship capable integrated GPUs and NPUs with 16+ GB of unified memory, and they spend considerable time idle. That is not enough memory to fit a large model such as a 70B-parameter LLM. We show that a handful of AIPCs, working together over an ordinary network, can serve models beyond the capability of any single one. We use pipeline parallelism: a model is split by layer into per-stage shards, each pre-compiled into an OpenVINO graph, so that every machine runs one shard and passes activations to the next. Three techniques make this fast enough to be useful. First, we recover the speed of the unsplit model: a naive per-stage export runs well below monolithic inference because it misses an OpenVINO GPU optimization, and injecting a beam_idx Gather into each shard triggers that optimization (the IndirectKVCache fusion) and brings the shards to parity. Second, we leverage speculative decoding on stateful OpenVINO models. Third, the pipeline serves several users at once by interleaving their requests across the stages, each request carrying its own cache (micro-batching). Together, a two-node Llama 3.1 8B INT4 pipeline serves two concurrent users at 1.79x the single-user throughput of the unsplit model on the same hardware, and the gap widens under simulated wide-area latency. The same design scales to a 70B model that no single fleet member can hold: a four-node deployment of Lunar Lake AI PCs on Intel Tiber Cloud serves a single user at interactive speed, with output token-for-token identical to the same four-node pipeline decoding without speculation. Code, raw benchmark logs, and reproduction scripts ship as a self-contained package at https://github.com/labscommunity/pipeline-sharded-inference-paper (in the top-level reproduction/ directory).