# Digital Pathology AI on NeuralMesh

Most teams learn AI capacity planning the hard way. Jessica Audette of Memorial Sloan Kettering draws on digital pathology to show you how to size compute and storage for the workloads you can predict, and the ones you can’t, so your infrastructure keeps up as demand shifts.

**Type:** White Paper

## Executive summary

Every second storage adds to a slide is a second a pathologist waits. A complete digital pathology AI pipeline ran on WEKA® NeuralMesh™ in AWS, with measurements captured at every stage: scanner-style ingest, tissue detection, foundation-model feature extraction, classifier training, and clinical inference with heatmap output. Every number in this paper comes from that recorded series, with each stage measured cold and warm, alone and under concurrent load. The results are organized as two deployment scenarios: a hospital running AI-assisted diagnostics on incoming slides, and a research lab building models on archived cohorts.

The pipeline spends most of its hours in GPUs and CPUs rather than storage. What it asks of storage is specific. Per-slide latency is how long a pathologist waits on a result. Visibility is how quickly a finished result appears in the viewer. Metadata rate is how fast an archive of thousands of slides can be opened and cataloged. Sustained ingest is scanners writing continuously, and workload isolation is all of it running at once without one job slowing another.

The headline results:

```json
{
  "_key": "c142e7447aa6",
  "_type": "richTableBlock",
  "headerRows": 1,
  "markDefs": null,
  "rows": [
    {
      "_key": "966bb3e0a14e",
      "_type": "row",
      "cells": [
        {
          "_key": "5f7bff1db7b0",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "d2469b6a3395",
              "_type": "block",
              "children": [
                {
                  "_key": "76b1907ba3a3",
                  "_type": "span",
                  "marks": [],
                  "text": "Result"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "17a35b969b4e",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "d4622ff66b94",
              "_type": "block",
              "children": [
                {
                  "_key": "15c4162cb32d",
                  "_type": "span",
                  "marks": [],
                  "text": "What it means"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "5d95140dd2f0",
      "_type": "row",
      "cells": [
        {
          "_key": "5052a6ea0936",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "deb33bb84d45",
              "_type": "block",
              "children": [
                {
                  "_key": "aebb4d7e3680",
                  "_type": "span",
                  "marks": [],
                  "text": "Full clinical mix, four hours: inference within 2.5% of stand-alone speed, median drift 0.05%"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "d81f7f52b5fc",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "688f400398e1",
              "_type": "block",
              "children": [
                {
                  "_key": "1d6775e5797d",
                  "_type": "span",
                  "marks": [],
                  "text": "The hospital's entire workload runs at once on shared storage without slowing the clinical loop"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "3b041f87cd97",
      "_type": "row",
      "cells": [
        {
          "_key": "67858bd66af2",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "805f41fe40f3",
              "_type": "block",
              "children": [
                {
                  "_key": "c45d489a9c55",
                  "_type": "span",
                  "marks": [],
                  "text": "Research mix: every workload kept at least ~89% of stand-alone throughput"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "34f5703f5602",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "cec499ac3f7f",
              "_type": "block",
              "children": [
                {
                  "_key": "231688c90a51",
                  "_type": "span",
                  "marks": [],
                  "text": "Extraction, training, ingest, and viewing coexist; the filesystem is never the contended resource"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "fc71ec8f60b4",
      "_type": "row",
      "cells": [
        {
          "_key": "2dab818f36a3",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "9bd20cf84d79",
              "_type": "block",
              "children": [
                {
                  "_key": "5f55d325ede6",
                  "_type": "span",
                  "marks": [],
                  "text": "Per-slide latency: ~36 s median (Virchow2), storage ~5% of it"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "93a1e23c017b",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "997a5204416b",
              "_type": "block",
              "children": [
                {
                  "_key": "164bcca6214e",
                  "_type": "span",
                  "marks": [],
                  "text": "The clinician-facing wait is compute; storage adds under two seconds"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "5e52e79c5be7",
      "_type": "row",
      "cells": [
        {
          "_key": "84debddcbf5a",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "79328388856b",
              "_type": "block",
              "children": [
                {
                  "_key": "b616536406ba",
                  "_type": "span",
                  "marks": [],
                  "text": "Result visibility: 0.61 ms mean, 1.07 ms at the 99th percentile"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "563d49c0a9d5",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "dafdb25ec510",
              "_type": "block",
              "children": [
                {
                  "_key": "46b09613387f",
                  "_type": "span",
                  "marks": [],
                  "text": "A finished result is on screen the moment inference ends"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "76b9839f3701",
      "_type": "row",
      "cells": [
        {
          "_key": "393330b615a7",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "30fec4e97033",
              "_type": "block",
              "children": [
                {
                  "_key": "c3a6c01698fd",
                  "_type": "span",
                  "marks": [],
                  "text": "Viewer reads: ~2 ms at the 99th percentile under full-rate ingest"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "982e6995d66c",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "e0cf9b90679f",
              "_type": "block",
              "children": [
                {
                  "_key": "098f2cbea8c5",
                  "_type": "span",
                  "marks": [],
                  "text": "Pathologists keep panning and zooming while scanners write"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "87f8a480aee6",
      "_type": "row",
      "cells": [
        {
          "_key": "9a7cf9582e2f",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "3abaf3189dad",
              "_type": "block",
              "children": [
                {
                  "_key": "dcfb11a8c918",
                  "_type": "span",
                  "marks": [],
                  "text": "Scanner pacing: 52 s mean arrival-to-result at one slide per minute"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "44bd01eaa4f5",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "94ed934b266c",
              "_type": "block",
              "children": [
                {
                  "_key": "7bff031df6e8",
                  "_type": "span",
                  "marks": [],
                  "text": "One GPU keeps pace with the scanner, with no queue buildup"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "be275604bb97",
      "_type": "row",
      "cells": [
        {
          "_key": "e3cc21c541a9",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "9463014c8bfa",
              "_type": "block",
              "children": [
                {
                  "_key": "1d17ebfc115b",
                  "_type": "span",
                  "marks": [],
                  "text": "Cohort to trained classifier: 3.5 to 4.1 h (1,064 slides)"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "b5eb27d16837",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "4205596c399a",
              "_type": "block",
              "children": [
                {
                  "_key": "22cefcffe7f5",
                  "_type": "span",
                  "marks": [],
                  "text": "A lab retrains a full cohort within an afternoon"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    }
  ]
}
```

These are qualification results, and they pass. Every step a hospital or research lab would run completed with measured headroom, alone and under contention, at production-shaped rates on a single client. For a team asking whether NeuralMesh supports digital pathology, the answer here is measured, and it's yes. Scope is stated at the end of the paper.

## Test environment and methodology

Storage is on the critical path here for concrete reasons. A single slide is a gigapixel image, cohorts run to terabytes, and the pipeline's stages hit the filesystem in every pattern there is: large sequential writes during ingest, metadata storms during cataloging, small random reads during viewing and training, and hundreds of thousands of files in an embedding archive, with all of it concurrent in production. The tests below measure each pattern alone and then together.

### Pipeline and datasets

Two public cohorts drove every test: TCGA breast-cancer slides (1,133 whole-slide images) and CAMELYON16 lymph-node slides (399), totaling 1.79 TiB as transferred. A whole-slide image is one scanned glass slide at microscope resolution, on the order of 100,000 by 100,000 pixels, stored compressed at roughly a gigabyte per slide in these cohorts.

The pipeline has five stages.

1. Tissue detection reads a slide's low-resolution levels and lists the tiles that contain tissue, since most of a slide is empty glass.
2. Tiling cuts those regions into 256-by-256-pixel tiles.
3. Feature extraction runs a pathology foundation model (Virchow2 and GigaPath in this paper) over the tiles and reduces each slide to a single embedding file of roughly 40 to 70 MB.
4. Classifier training fits a compact diagnostic model on those embeddings.
5. Inference runs the whole chain on one slide (detection, extraction, and classification) and writes a heatmap image marking suspicious regions.

The two deployments compose these stages differently:

```json
{
  "_key": "b5f4350c0715",
  "_type": "richTableBlock",
  "headerRows": 1,
  "markDefs": null,
  "rows": [
    {
      "_key": "d842f109b243",
      "_type": "row",
      "cells": [
        {
          "_key": "b29dd42fa8f8",
          "_type": "richTableCell",
          "content": []
        },
        {
          "_key": "f22451658874",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "2de737852dc6",
              "_type": "block",
              "children": [
                {
                  "_key": "ce1bb4934351",
                  "_type": "span",
                  "marks": [],
                  "text": "Hospital"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "914d0c167df0",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "4fe978994339",
              "_type": "block",
              "children": [
                {
                  "_key": "2aecb21db934",
                  "_type": "span",
                  "marks": [],
                  "text": "Research lab"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "56cb6c2118e0",
      "_type": "row",
      "cells": [
        {
          "_key": "c51d685da755",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "53e62edf3ec4",
              "_type": "block",
              "children": [
                {
                  "_key": "92aba832c8d0",
                  "_type": "span",
                  "marks": [],
                  "text": "What runs"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "09d4872257da",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "8a83f2fa1a6d",
              "_type": "block",
              "children": [
                {
                  "_key": "a99b4e55f66e",
                  "_type": "span",
                  "marks": [],
                  "text": "The inference chain on each incoming slide, with scanner ingest and pathologist viewing alongside"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "97f62040e692",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "36306c447d70",
              "_type": "block",
              "children": [
                {
                  "_key": "0ada2449e36e",
                  "_type": "span",
                  "marks": [],
                  "text": "One-time cohort preparation (transfer, catalog, detect, extract), then weeks of classifier training"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    },
    {
      "_key": "8064503a77b1",
      "_type": "row",
      "cells": [
        {
          "_key": "4f29f7e63be8",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "d0004aa007ab",
              "_type": "block",
              "children": [
                {
                  "_key": "0ba9df5c3908",
                  "_type": "span",
                  "marks": [],
                  "text": "What was measured for it"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "0e2d0846a7e1",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "1f0bf903bff2",
              "_type": "block",
              "children": [
                {
                  "_key": "63571833a3ef",
                  "_type": "span",
                  "marks": [],
                  "text": "Per-slide latency, result visibility, isolation under concurrent load"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        },
        {
          "_key": "95bdff8e1d74",
          "_type": "richTableCell",
          "content": [
            {
              "_key": "837531ed37ff",
              "_type": "block",
              "children": [
                {
                  "_key": "1bb17f3e763a",
                  "_type": "span",
                  "marks": [],
                  "text": "Preparation wallclocks, training throughput, behavior at archive scale"
                }
              ],
              "markDefs": [],
              "style": "normal"
            }
          ]
        }
      ]
    }
  ]
}
```

### Unit of analysis

All measurements come from one client machine, a single GPU server, working against the eight-node NeuralMesh cluster. This is deliberate. The workstation or inference node is the unit a deployment scales, so every claim in this paper is a per-client claim, quoted beside that client's measured ceilings. The series didn't measure multi-client, cluster-wide aggregate numbers, and this paper doesn't claim them.

### Hardware configuration

Client: one EC2 g6e.24xlarge (4 NVIDIA L40S GPUs, 96 vCPUs, 768 GiB RAM, 200 Gbps network). Storage: NeuralMesh 5.1.27 on 8 i8ge.6xlarge instances, 120 TB raw, 67.46 TB usable under 5+2 erasure coding with a hot spare, 300 Gbps aggregate sustained network. The client mount reserved four frontend cores (about 8% of physical cores); CPU readings count only the remaining cores. The deployment is a realistic production configuration.

### Raw capability ceilings (synthetic)

Every real workload arrives wrapped in its own software (copy tools, decoders, model forwards), and this series repeatedly measured that software, not the filesystem, as the limiter. The raw ceilings therefore come from fio, the standard synthetic I/O tool, driving direct I/O with no application in the way: 8.48 GiB/s sequential write, a read plateau near 11.0 GiB/s, and 519,000 / 625,000 random write / read operations per second at 4 KB. These are the synthetic ceilings, and every percentage-of-ceiling figure in this paper is measured against them.

### Provisioning headroom

The storage cluster sustains 300 Gbps of network capability against the client's 200 Gbps NIC. The heaviest demand any test generated, real or synthetic, was about 94 Gbps of reads and about 106 Gbps of writes on the wire, leaving the cluster roughly three times headroom over peak read demand and close to three times over peak write. A separate calibration confirmed the ~11 GiB/s read plateau is a limit of the client stack, not of the storage cluster.

### Cache state and variance

Each test recorded its cache state rather than assuming it, and every corpus requiring cold reads exceeded client RAM and server cache combined. The same two small reference tests were rerun at nine points across the series to establish the run-to-run noise band; headline figures ran three times and are quoted as medians with spread; multi-hour runs were checked first half against second half.

## Clinical workload: AI-assisted diagnostics

The clinical metrics are per-slide latency, time to visibility, and behavior under concurrent load. Each step below reports its own measurement; the section ends with everything running at once.


![Clinical Workload Diagram](https://cdn.sanity.io/images/ult5g8gw/production/ce68d69f9c4ad590717b10dfef5273a4ceefa28d-2880x1053.png)


Figure 1. The hospital workflow: each incoming slide runs the inference chain while ingest and viewing continue on the same storage.

### Bulk slide ingest

The test copied the 1,133-slide library (1.1 TiB) into NeuralMesh as parallel large writes over POSIX. One stream ran 706 MiB/s; four streams saturated the copy at about 2,400 MiB/s, flat through 64 streams, completing the library in under eight minutes. That plateau is about 44% of the raw write ceiling at the same block size; the recorded limiter is the copy tooling (per-file checksums, metadata, one stream per file), not the filesystem.

### Scanner-paced arrival to result

A synthetic scanner emitted one slide every 60 seconds into the inference loop. Mean arrival-to-visible-result was 52.0 seconds (114 at the 99th percentile), with inter-slide queueing about 5 ms, so one GPU keeps pace with a scanner delivering a new slide every minute.

### Per-slide latency

The inference chain ran at a median of about 36 seconds per slide with Virchow2 and 43.5 with GigaPath. Feature extraction dominates; tissue detection took about 45 ms and the heatmap write about 1.7 seconds. Storage's share of the total is roughly 5%, mostly the heatmap write. Cold reads versus warm made no measurable difference to the median (36.37 versus 36.16 seconds on one read backend, 36.15 versus 36.65 on the other). The filesystem served cold reads fast enough that the difference disappears inside the compute. The 99th percentile (100 to 122 seconds) tracks the largest slides' tile counts, not storage.

### Result write and visibility

The pipeline wrote heatmaps in three formats: a 425 KB overlay image (median write 69 ms), a 6.4 MB pyramidal TIFF (1.65 s), and a 50.7 MB full-resolution pyramid (38.1 s median). Filesystem write rates sat far below ceiling for all three; per-slide write time is a property of the renderer producing the pixels. Visibility, the delay between a result being written and other software being able to open it, was measured separately. A writer wrote a heatmap-sized file, flushed it to storage, and renamed it into its final name (the standard safe-publish pattern) while a second process tried to read it every millisecond. The result became readable 0.61 ms after the rename on average, 1.07 ms at the 99th percentile, against a 1 ms measurement floor. The test file matched the measured mid-format heatmap in size and tile layout; its content was synthetic because visibility depends on file size and structure, not pixel values.

### Concurrent viewing under ingest

Pathologist viewing is, at the storage layer, a stream of small random reads (panning and zooming across a slide). A load generator reproduced that pattern, because the test needs the read load swept from light to heavy against a fixed full-rate ingest, which a person driving a real viewer can't do repeatably. The viewer-pattern reads held about 2 ms at the 99th percentile while ingest wrote at full rate. Ingest held its solo 2,400 MiB/s through moderate concurrent reading and degraded only at the top of the sweep, giving up 21% under the heaviest small-read load and 28% when large-block readers pulled 6.2 GiB/s, at which point the client moved about 9.3 GiB/s combined.

### Concurrency scaling

The inference chain ran with 1, 4, 16, and 64 slides in flight. Four in flight, one per GPU, is the deployment point, with a median of 35.6 seconds, GPUs at 93.8%, and a 99th percentile of 93.3 seconds. Beyond that the GPUs are deliberately oversubscribed and latency grows as queueing, reaching a median of 155 seconds at 16 in flight with the GPUs at 98.7%. This test was designed as the storage-and-queueing stress; measured, filesystem reads peaked near 198 MiB/s, under 2% of the read ceiling. The latency growth is GPU queueing, with the filesystem serving every read behind the service-level figure at a small fraction of its ceiling.

### Full clinical mix and endurance

Inference, ingest, a heatmap viewer, and a slide viewer ran together for 30 minutes and then four hours. Median inference latency was 36.50 and 36.52 seconds respectively, within about 2.5% of the uncontended baseline, while ingest wrote 2.4 GiB/s throughout; the four-hour run processed 1,490 slides and its median sat 0.05% from the 30-minute run's. Repeating the concurrent test on the second cohort (CAMELYON16) gave a median of 37.7 seconds, ratio 1.06 to the matched breast-cancer run. At the inference layer the pipeline is format-agnostic, and the second cohort's wider tile-count tail appears only at the 99th percentile.

## Research workload: model development

The research sequence is the one-time preparation pass, then training. This section follows it in order and ends with the shared-cluster mix.


![Research workload diagram](https://cdn.sanity.io/images/ult5g8gw/production/0bd6ff107fc7981fc55951fad37795a55beeb59f-2880x1053.png)


Figure 2. The research lab workflow: heavy preparation runs once per cohort; training against the embeddings repeats for weeks.

### Cohort preparation

S3 transfer: 1.79 TiB landed in 65 minutes at the best setting. The limiter was the S3 fetch side throughout, with filesystem writes far below ceiling and higher sync-tool concurrency slowing the transfer.

Cataloging (header reads, metadata-only): 858 slides per second cold and 1,825 warm at the 64-worker saturation point, a full pass in one to two seconds. The cold-to-warm gap is client-side caches serving repeat opens.

Tissue detection: the full cohort in 105 seconds at 64 workers (10.77 slides per second), application CPU at 82 to 87%, filesystem operations to 18,100 per second; compute-leaning by design, with storage lightly loaded.

### Tile read paths

Tiles can be pre-cut once, read on the fly from compressed slides, or read toward GPU memory from an uncompressed copy. Pre-extraction peaked at 7,716 tiles per second, dominated by JPEG encode. On-the-fly reading peaked at 22,047 tiles per second with a batched reader against 12,895 per-tile, about 1.7x, with decode CPU shaping both curves and filesystem reads at 1.7 to 2.0 GiB/s. The GPU path requires conversion first, which took 15.7 hours at four parallel converters for the 1,064-slide working set, 5.90 TB written, decode-bound with filesystem writes near 0.1 GB/s. During conversion, strided reads of the compressed slides pulled 1.2 to 1.7x more bytes over the wire than the application consumed, a workload-specific read amplification confirmed by later calibration; it produced no user-visible effect in any mix. Once converted, the GPU path read 5.62 GB/s sustained from a single process, about 49% of the matched ceiling, the deepest sustained read of any real pipeline step. (This instance class offers no true GPU-direct storage path; the GPU path here is the standard compatibility route through host memory, and that is what these figures measure.) The wallclock arithmetic settles the choice. Conversion alone takes roughly four times the entire standard-path pipeline (3.5 to 4.1 hours end to end), and repays only across many re-extraction passes.

### Feature extraction

On four GPUs, Virchow2 sustained 971 tiles per second and GigaPath 800, GPU utilization 95 to 98%, repeats within 1.7%. Filesystem reads peaked near 2% of the matched ceiling, so what these runs demonstrate is the storage keeping the extractors fed. The GPU-versus-CPU read-path gap narrowed to 1.10 to 1.13x here, from 1.55x in the tile-streaming stress test below. The heavier the model, the less the read path matters.

### Classifier training

Training reads embedding files in parallel through a standard PyTorch loader; throughput saturates at 16 workers (39 slides per second for Virchow2, 33 for GigaPath). Each per-model corpus is 60 to 72 GB and fits in host RAM, so after the first pass, which read from storage at 1.6 to 1.8 GB/s, later epochs are served from memory. These are training-throughput numbers, not storage bandwidth. Real corpora are therefore too small to show how this read pattern behaves at scale, so the same pattern was replayed synthetically against a 6.08 TB library of files with sizes copied from the real embedding distribution, read randomly by parallel workers, with a 3.0 TiB slice verified cold, larger than every cache in the system combined. This simulates the storage load a far larger embedding archive would generate. Cold, the filesystem served 128 files per second, 6.4 GB/s, at 64 workers, about 58% of the raw read ceiling. Past that point, more workers bought queueing rather than throughput. The rate plateaued while per-file 99th-percentile latency climbed from 1.0 to 11 seconds at 256 workers. The practical guidance is to size loader concurrency to that knee.

### Concurrent mixed load and endurance

Ingest, extraction, training, and a viewer ran in every combination, ending in a four-hour endurance window, each workload scored on the share of its stand-alone throughput it retained. Extraction showed no slowdown in any mix (measured 100 to 102%, within run-to-run variance). Training kept 92.6% at worst and 98.3% in the endurance window, with the recorded contention in host CPU. The viewer's worst case was 89.1% during live ingest, 96.5% in endurance. Ingest never degraded. No workload gave up more than about 11%, the filesystem was never the contended resource, and extraction's four-hour halves agreed within 2.1%. The same runs produced one cost observation. Under 5+2 erasure coding, bulk writes cost about 1.46x their application bytes on the wire, and a small-buffer writer measured about 2.6x, roughly 1.8 times the bulk per-byte cost, with no effect on any workload's retention.

### Tile-streaming training (synthetic stress)

Most pathology pipelines in the field still train the classic way, a supervised model reading tiles straight from storage. This pipeline trains on embeddings instead, so this series ran the classic pattern as a synthetic stress, a ResNet-class model streaming tiles across one, two, and four GPUs, instrumented to separate data-loading time from compute. Throughput scaled from 1,038 to 3,695 samples per second (92.4% and 89.0% scaling efficiency). Data-loading's 99th percentile equaled its median at every GPU count, meaning the filesystem kept every GPU fed with no storage tail. The CPU-decode read path ran 1.55x slower at every count, the entire gap in data-loading (the gap persisted even with the working set cached in RAM, placing it in decode, not storage).

## Scope of these results

All results are per-client measurements from one recorded configuration, taken between Aug. 15 and 23, 2026. The test cohorts are research-cohort scale, 1,532 slides and 1.79 TiB, not a hospital archive. Intensity claims rest on what was measured at intensity on this one client: scanner-cadence slide delivery, sustained 2.4 GiB/s ingest, four hours of the full concurrent mix, and archive-scale reads probed through the beyond-cache synthetic library. Not measured and not claimed: multi-client aggregates or scaling of any kind; SMB ingest (all file access was Linux POSIX; NeuralMesh has native SMB support, but no number here is an SMB number); and any other filesystem or storage service, so the paper contains no comparisons, stated or implied. Cache states are as recorded. Headline figures are medians of repeated runs where noted, single measurements elsewhere. No GPU-direct storage path was available on this instance class, so every GPU-path figure is the standard compatibility route.

## Conclusion

This paper set out to answer whether NeuralMesh supports the digital pathology AI pipeline, end to end, as a hospital or a research lab would run it. Within the scope above, the measured answer is yes. The clinical loop delivered about 36-second median per-slide latency with storage near 5% of it, results readable within a millisecond of being written, and four hours of the full concurrent workload with 0.05% median drift. The research sequence took the 1,064-slide cohort from raw slides to a trained classifier in under 4.2 hours, and in every concurrent mix the filesystem was never the contended resource. Every step ran far inside the measured ceilings. NeuralMesh carried the complete digital pathology workload, the hospital use case and the research use case alike, separately and simultaneously, with headroom at every step.
