This guide is for IT and purchasing. It explains what the Analyze pipeline actually does, which hardware limits each step, typical times on a 20-logical-processor NVMe laptop, and how to size workstations, laptops, and file servers.

Quanto is a local desktop process. There is no Quanto application server. A “server” in this document is a file server (or instrument PC) that holds raw data, methods, and finished .qtb files.

The reference times in this guide are from a measured Analyze on the 20-thread laptop (Quanto 1.0.0.13, 2026-09-07, release pass 21:54). Other batch sizes are scaled from that run. Open and save timings are from the same evening (2026-09-07, logbook ~23:04–23:05, Europe/Berlin). Startup (OnStartup) is from Quanto 1.0.0.16 (2026-09-09 ~00:09, Europe/Berlin). Logbook scopes to copy when you bench a new PC: Load and integrate, Identify, Calibrate, quantitate and outliers, Batch save, OpenOrCreateBatch, and ReadFromZip.

Reference laptop (20 threads)

Quanto sets MaxDegreeOfParallelism = logical processors − 2 (default on). On a 20-thread PC that is 18 workers. Two threads stay free for the UI.

Resource What “20-core laptop” usually means Why it matters
CPU 20 logical processors (often 10–14 physical cores with hyper-threading, or 20 threads on a recent Intel / AMD mobile chip) Extract, integrate, identify, quantitate, and outliers scale with workers. Calibrate scales partially (parallel over quants/curves; each curve fit is single-thread).
RAM 32 GB is the practical floor (this 104,544-signal batch needs it); 64 GB if you hold several such batches or much wider windows The whole batch’s chromatograms stay in memory.
System disk NVMe SSD, about 3–7 GB/s sequential, 200k–500k random 4K IOPS Extract is random reads of vendor files. Save/open .qtb is CPU + disk: parallel payload build / entry inflate-deflate; zip archive I/O stays sequential.
Network 1 Gbit Ethernet ≈ 110 MB/s best case; Wi-Fi is lower and less stable A MassHunter .d folder is thousands of small files. SMB latency dominates extract.

If Task Manager shows 20 logical processors, you match this column. Physical “20-core” desktop chips are faster per thread than thin laptops; the scaling (what gets faster when you add cores) stays the same.

What Analyze does (and what it waits on)

Analyze (full batch) runs in this order:

Step Parallel? Bound by What it does
Get signals (extract) Yes — Parallel.ForEach samples (up to 18). Agilent also prefetches indexes (capped around 8 opens). Optional integrate-after-each-sample runs inside the sample task. Disk / network, then CPU Opens each .d / .wiff, reads TIC + every method channel (quant + qualifiers), optional smooth.
Integrate Yes — samples or compounds (mutually exclusive). Signals within a compound stay sequential. Per-thread integrator instance. CPU Peak detect + baseline on every chromatogram.
Identify Yes — compounds across samples (ForEachCompound); RT targets + Link ISTD via sample-parallel path. Phases themselves run in order. CPU Pick peaks, qualifiers, ISTD links, responses.
Calibrate Partial — response build mostly sequential; then parallel over quants/curves. Brackets of one quant stay sequential. Curve fit itself is single-thread. CPU (scales with quant count) Fit each curve. Small compared with extract.
Quantitate Yes — parallel over compounds (ISTD/dose prep sequential first). Bracket segments outer loop sequential. CPU (cheap math; scales with compounds) Inverse curve + dilution + accuracy. Almost free.
Outliers Yes — parallel over samples (compounds inside a sample sequential). CPU Flags / unexpected-Y checks.
Save .qtb Yes — payload build (TSV/.chr deflate) parallel; zip write sequential CPU + disk Compress tables + all chromatograms + integrations + optional report xlsx.
Open .qtb Yes — inflate/decode of zip entries parallel after sequential read; wiring sequential CPU + disk / network Reload results without touching raw files (ReadFromZip).
Report export Up to 4 STA threads CPU + disk One Excel/PDF pair per sample.

Re-Analyze after you already have signals skips extract and is usually integrate + identify + calibrate only.

Measured reference (20-thread laptop, local disk)

Batch: Agilent MassHunter LC-MS pesticides demo (D:\MassHunter\Data\Demo\LCMS_Pesticides\). Status bar after Analyze (Quanto 1.0.0.13, 2026-09-07): 99 samples, 461 analytes, 104,544 signals, 16,828 peaks, 1 method. Method 2024-06-20.qtm. Saved batch size from the earlier packaging of this study: 2026-09-05.qtb ≈ 169,324 KB (~165 MB). Indexed .d data on a local drive. Parallel processing on (18 workers). Timing below is the release pass (logbook 21:54).

That file is a zip (Explorer may show a 7-Zip icon). On disk it is about 1.6 KB per signal or 1.7 MB per sample. RAM after open is several times larger because chromatograms are inflated to double arrays.

Use the status-bar Signals count for hardware sizing. Peaks (16,828) are detected peaks, not chromatograms. This run is ~1,056 signals/sample and ~2.3 channels per analyte per sample.

Full Analyze (ProcessBatch = 2.01 s)

Step (Logbook message) Time Share Rate
Load and integrate (extract + peak detect) 1.42 s 71% 14 ms/sample · 74,000 signals/s
Identify 0.36 s 18% 4 ms/sample
Calibrate, quantitate and outliers 0.16 s 8%
Other (choose sample / UI) ~0.07 s 3%
ProcessBatch total 2.01 s 100% 20 ms/sample · 52,000 signals/s

Calibrate / quantitate / outliers inside that 0.16 s:

Substep Time
Calibrate 89 ms
Replace responses (method) 36 ms
Recompute auto quant selection 7 ms
Quantitate 31 ms
Outliers (99 samples) 8 ms

Identify is mostly Assign method items (204 ms). Other Identify scopes from this run: Qualify 45 ms, Correlate peaks 36 ms, Select peak 33 ms, Select quant 32 ms; Response, co-elution, and ISTD link are a few milliseconds each.

Open / save batch and start

Operation Time Notes
Start Quanto (paths + settings + add-ins + main window) ~1.1 s OnStartup total ~1.11 s (1.0.0.16, 2026-09-09); add-ins ~56 ms; docking LoadSettings ~0.20 s
Batch save (BatchSave_Click) 1.42 s Parallel payload build (TSV/.chr deflate); sequential zip write of 165 MB / 104,544 chromatograms
Open .qtb (OpenOrCreateBatch) 1.69 s Includes ReadFromZip of chromatogram parts (Time.chr, Modified.chr, Tic*, Original.chr, …); ~98 MB/s
After open (cal + quant + outliers) 0.30 s Calibrate 132 ms; recompute auto quant selection 25 ms; quantitate 62 ms; outliers 83 ms (99 samples); remove deleted items 2 ms

Open (~1.69 s) and save (~1.42 s) are in the same ballpark as Analyze (~2.01 s) on this PC. Review PCs still benefit from a fast local disk.

Scale from this run (local SSD, same method style)

Linear in signal count for a first IT estimate. Load/extract grows faster than linear on a slow network; identify and calibrate stay closer to linear on CPU.

Workload Signals Load and integrate Identify Cal + quant Full Analyze
Measured — 99 × 461, 16,828 peaks 104,544 1.42 s 0.36 s 0.16 s 2.01 s
Same method, ~24 samples ~25k ~0.34 s ~0.09 s < 0.05 s ~0.5 s
Same method, ~50 samples ~53k ~0.7 s ~0.18 s ~0.08 s ~1.0 s
Same method, ~200 samples ~211k ~2.9 s ~0.73 s ~0.32 s ~4.1 s
2× this channel count ~209k ~2.9 s ~0.73 s ~0.32 s ~4.1 s
Same 104,544 signals from a 1 Gbit share 104,544 15–50 s (estimate) 0.36 s 0.16 s 16–51 s

SCIEX WIFF is often faster to extract over the network than Agilent .d (fewer large files). Full-scan EIC extract is slower than this MRM demo.

First-time Agilent index conversion (TDA) is extra and writes MSTree2.bin into each .d. Plan tens of seconds to a few minutes per sample the first time. This measured run was already indexed.

How each resource changes the number

CPU

Purchase: 16–20 threads is the sweet spot for an analyst PC. 8 threads is usable for small batches. 32+ threads is only worth it if you also have local NVMe and large residue methods.

RAM

Chromatograms stay in RAM as double arrays (time + response, original and often a modified copy):

Points per chromatogram Bytes per signal (orig + modified) 105k (measured) 210k 400k
500 (narrow MRM window) ~16 KB 1.7 GB 3.4 GB 6.4 GB
2 000 (typical) ~64 KB 6.7 GB 13 GB 26 GB
8 000 (wide window / scan) ~256 KB 27 GB 54 GB 100 GB

Add 1–3 GB for the WPF UI, grids, docking, and report designer, plus TIC traces. The measured 104,544-signal batch is in the ~8–12 GB working-set band at typical MRM point counts.

RAM Comfortable batch
16 GB Tight for this measured batch (105k signals). Possible if chromatograms are short and little else is open.
32 GB Standard analyst laptop. Proven for 99 samples / 461 analytes / 104,544 signals.
64 GB Several batches, Key Review, 4K + report designer, or ~200k+ signals.
128 GB Multi-batch review or very wide scan windows.

Windows will use the page file if you undersize RAM. Analyze then becomes disk-bound and can look “stuck.” That is not a Quanto bug.

SSD vs HDD

Storage Extract (local) Save / open .qtb Verdict
NVMe (Gen3/4), 3–7 GB/s Baseline in the table above Measured 165 MB .qtb: open 1.69 s, save 1.42 s Required for the system disk and for active studies
SATA SSD ~1.5–2× slower extract (random IOPS) Fine Acceptable for a second data disk
7200 rpm HDD 5–20× slower extract .qtb save can take minutes Archive only
USB stick / SD Do not use Do not use

Random IOPS matter more than sequential GB/s for Agilent .d folders. A cheap SATA SSD still beats a fast HDD.

Put Windows + Quanto + the active study on NVMe. Cold archive can be HDD or NAS.

Network

Extract reads many small files (MassHunter AcqData, ChemStation). SMB latency per file adds up.

Link Realistic extract vs local NVMe When to use it
Local NVMe 1× Daily Analyze
10 Gbit Ethernet, SSD/NVMe NAS, SMB3 1.2–2× Shared study disk if the NAS is fast and antivirus is excluded
1 Gbit Ethernet 5–15× slower extract OK for opening a finished .qtb or loading a .qtm. Poor for first Analyze of a large .d sequence
Wi-Fi 6 Unstable; often worse than 1 Gbit Demo only. Copy the sequence local first
VPN / WAN Often 30–100× Do not extract. Copy data, or Analyze on a PC next to the files

Good on a share: .qtm methods, .lic licenses, finished .qtb for review, QuantoReports.
Bad on a slow share: first Get signals from Agilent .d trees, TDA conversion (it writes back into the sample folder).

Practical rule: Analyze next to the data. Copy the sequence to the laptop NVMe, or sit at the instrument PC. After save, copy the .qtb to the LIMS share.

Antivirus on the NAS or the endpoint that scans every .bin in AcqData can be as slow as a 1 Gbit link. See exclusions.

GPU and display

Quanto does not use the GPU for extract, integrate, or quantitate. An integrated GPU is enough. A discrete GPU only helps if you use many 4K chromatogram plots or Remote Desktop with GPU encoding.

Two 4K monitors increase RAM a little (WPF visuals) but do not change Analyze time.

Batch size (what to tell the lab)

Size the PC by the status-bar Signals count, not Peaks and not samples × analytes. This 461-analyte batch is 104,544 signals and 16,828 peaks.

Class Signals RAM Disk for .qtb 20-thread local Analyze
Small < 25k 16 GB ~40 MB ~0.5 s
Standard 25k–80k 32 GB 40–130 MB 1–2 s
Measured pesticides 104,544 32 GB 165 MB (2026-09-05.qtb) 2.0 s
Large 80k–200k 32–64 GB 130–330 MB 2–5 s
Extreme > 200k 64–128 GB 330 MB–1 GB 15 s+; keep data local

Scaled .qtb sizes use 1.6 KB/signal from the measured file. A report workbook inside the zip adds extra megabytes.

Key Review (several AcqKeys / QntKeys / dilutions) multiplies rows in the UI, not necessarily extract time, if the extra keys already have signals. Memory and grid refresh grow with visible cells.

Copying this 165 MB .qtb on 1 Gbit takes a few seconds. Opening it needs ~1.7 s locally (and save ~1.4 s) — similar to a full Analyze on this PC. A 1 GB batch on a slow share can still take longer to open than Analyze on local NVMe. Review PCs should copy large batches local or use 10 Gbit.

Workstation and laptop purchase

Quanto needs Windows 10 or 11 64-bit, .NET 10 Desktop Runtime (x64), and a local SSD.

Role CPU RAM Storage Network Notes
Analyst laptop (matches the reference) 16–20 threads, recent generation 32 GB (64 GB if you routinely exceed ~200k signals) 1 TB NVMe (OS + active studies) 1 Gbit or Wi-Fi 6; dock to Ethernet for copy Measured: 99 / 461 / 104,544 signals / 16,828 peaks; 165 MB .qtb; 2.0 s Analyze, ~1.7 s open, ~1.4 s save (1.0.0.13, 2026-09-07).
Review / senior workstation 16–24 threads, high clocks 64 GB 2 TB NVMe 1–10 Gbit Several batches open, report designer, Key Review.
Heavy multi-residue 20+ threads 64–128 GB 2 TB+ NVMe 10 Gbit to the data disk Do not extract from Wi-Fi.
Instrument PC (if they Analyze there) Vendor-min or better 32 GB Fast local disk for the sequence Same LAN as the lab Best place to run TDA / first extract.
File server / NAS Few cores are fine 32 GB+ cache SSD/NVMe pool for hot studies; HDD for archive 10 Gbit recommended SMB3. Exclude real-time AV on .d / .qtb. Not a Quanto host.
VDI / Citrix 8+ vCPU dedicated 32 GB session Local or cache the study on the session host Low latency to the host GPU optional for UI. Never extract a .d tree from the user’s home NAS over WAN.

Do not buy: 8 GB RAM PCs, HDD-only laptops, or a “Quanto server” VM with no GPU and data on another continent.

Nice but unused: ECC RAM, dual CPU, compute GPU, Linux (Quanto is Windows x64 only).

Server and lab network

  1. No application server. The WPF UI is an interactive desktop app — do not treat it as a headless batch server. For unattended post-acquisition Analyze / report / export, use Quanto.Console on a Windows PC that can see the method and data (see Headless / post-acquisition reporting).
  2. File server holds sequences, .qtm, .qtb, licenses. Prefer 10 Gbit and SSD for the live study volume.
  3. License share (*.lic) can be a small, highly available folder. Analysts need read; one admin needs write. See installation folders.
  4. One writer per .qtb. Do not let two PCs save the same batch file at once. Review copies are fine.
  5. Instrument → process → archive: acquire on the instrument disk → copy to analyst NVMe (or Analyze on the instrument PC) → save .qtb → copy .qtb + reports to LIMS / NAS → archive raw data per SOP.
  6. Domain / roaming: roam only %LOCALAPPDATA%\Quanto settings if you must; never roam BatchReports or studies.

Checklist for a new PC

Related