A generated title card reading 'LingSante-Pulse-1.0 vs Qwen 3.8', subtitled 'One encodes the trace. One answers the question.', above two rounded panels divided by a 'vs' disc. The left panel is headed LingSante-Pulse-1.0 with a pale blue 'MIT licence' badge and four grey rows: 16.7M parameters, 57 signal channels, 128 Hz, 0.25 s patches, embeddings only. The right panel is headed Qwen3.8-27B with a pale amber 'Apache 2.0' badge and four grey rows: 27.78B parameters, 262,144-token context, text, image and video in, 0.33 and 2.40 per 1M. A thin dotted arrow runs from left panel to right. A footer reads 'Pulse figures read from the repository; Qwen3.8 figures per Artificial Analysis and our catalogue.' The OrcaRouter logo is composited in a white strip along the bottom edge.
Guides & Insights

LingSante-Pulse-1.0 vs Qwen 3.8: One Encodes, One Answers

Author

jinhao.song

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

The matchup reads as lopsided until you notice the two models do not accept the same input. LingSante-Pulse-1.0 has 16.7 million parameters and cannot produce a sentence. Qwen3.8-27B has 27.78 billion and cannot accept a waveform. One turns an ECG lead, an airflow trace or a frontal EEG channel into a 256-number vector at quarter-second spacing; the other reads text, images and video and writes an answer. On a shared benchmark neither beats the other, because there is no shared task. In one pipeline the division of labour is immediate.

LingSante-Pulse-1.0 is inclusionAI's, and it appeared on Hugging Face at 08:39 UTC on 20 November 2026 with no announcement, no paper and no inference code. The lab has published nothing about it; the repository is the entire public record. That shapes what this page can claim. What follows about Pulse is read off seven files — the safetensors header is uncompressed, so the architecture is legible — and anything about how it behaves outside the authors' own harness is, right now, unknown to everyone outside Ant Group. The Qwen3.8 side is the opposite: shipped in August, priced, scored by a third party, already carrying traffic.

What is actually in the repository

Seven files: a README, an MIT licence, a 63.8 MiB F32 weights file, a config carrying SHA-256 digests for its three companion files, and two channel files. That is the release. There are no benchmarks, no training-data description, no downstream results and no inference code.

The card points you at a separate lingsante_pulse package. That package is not on PyPI — not under lingsante_pulse, not under lingsante-pulse, not under lingsante. The usage example itself says the model "downloads on first use," which is documentation written for a day that has not arrived.

Screenshot of the Hugging Face model page for inclusionAI/LingSante-Pulse-1.0 captured 20 November 2026 in English: the repository header with its like and follow counts, the 'Feature Extraction', 'Safetensors', 'PyTorch', 'physiological-signals' and 'time-series' tags, the MIT licence label, and the model card's opening text stating that a separate inference-code package must be installed before use, above the usage example that imports lingsante_pulse and downloads the model on first use.

What the tensor header does give you is a complete architecture, small enough to read in an afternoon:

• Size — LingSante-Pulse-1.0: 16,708,352 parameters in F32, twelve transformer blocks at width 256, 203 tensors. Qwen3.8-27B: 27.78 billion parameters, a 64-layer dense multimodal model.

• Input — Pulse: sample arrays shaped [T], [C,T] or [B,C,T], resampled to a fixed 128 Hz, with the physical identity of every channel declared alongside it. Qwen3.8-27B: text, images and video. No audio path, no raw time-series path.

• Output — Pulse: CLS and observed-valid PatchMean as [B, C*256], plus optional per-patch features and validity masks at 0.25-second spacing. Qwen3.8-27B: text.

• Scope — Pulse ships representations only. The card is explicit that "task-specific prediction heads are not included." You supply the classifier, the detector, the risk score.

• Context — Pulse has no token window in the language-model sense; it has a patch grid at 0.25 s per patch. Qwen3.8-27B accepts 262,144 tokens.

• Licence — Pulse: MIT. Qwen3.8-27B: Apache 2.0, weights downloadable and runnable.

Fifty-seven channels describe a sleep lab

The most informative files are not the weights. They are channels.json, which names and describes all fifty-seven signal identities the encoder accepts, and channels.npz, which holds a 384-dimensional vector per channel — 57 of them, built with BAAI/bge-small-en-v1.5 using CLS pooling and L2 normalisation. That width is exactly the input width of the text_adapter projection at [256, 384] in the weight file, which is the strongest hint in the release about how conditioning works: the channel name is embedded as text, projected down to the model's 256-wide residual stream, and fed to the twelve film_heads — each a [1024, 256] projection emitting a 1,024-value modulation vector. Nothing in the card explains what drives them, so that is a reading of the tensors, not a documented fact.

None of that wiring is documented, so treat it as an inference from tensor shapes rather than a spec. What is documented is the name list, and read in order it stops being a generic biosignal vocabulary. Three EEG scalp leads "during sleep", two EOG leads "during sleep", a chin EMG and a leg EMG "during sleep", airflow, thoracic and abdominal effort, snore, SpO2. That is a polysomnography montage, in the order a sleep technician would name it. Then the vocabulary walks into a different room: airway pressure "measured by an anesthesia ventilator", end-tidal CO2, respiratory rate derived from a Dräger Primus and from a Solar8000 monitor, BIS EEG power in decibels from a forehead depth-of-anaesthesia monitor. Seventeen ECG derivations including a full precordial set, and sixteen monopolar EOG leads.

Two clinical settings, one vocabulary. The defensible inference — inference, because the card is silent — is that the encoder was trained across sleep studies and perioperative or intensive-care monitoring, and that its authors wanted one model that survives whichever montage a hospital already owns. That breadth is the real engineering claim in this release, and it is a claim a 16-million-parameter model can make and a 27-billion-parameter one cannot.

Why Qwen3.8-27B cannot read the input

This is the fact that reframes the whole comparison. Qwen3.8-27B is multimodal, but its modalities are text, image and video. There is no waveform input. You cannot hand it 1,280 samples of lead II at 128 Hz and ask what the rhythm is; a tokeniser has nothing to do with a float array. In our own catalogue the model is listed with text, image and video on the input side and text on the output side, and that is the whole of it.

So the honest answer to "can I just use a big model for this?" is: not on the raw signal. You have two workarounds. Derive features first — heart rate, RR intervals, spectral bands, a hand-built summary — or render the trace as an image and let the vision tower look at a picture of it. The second sometimes works, but it costs you what the signal contains: a plotted ECG loses amplitude calibration and the sub-millisecond timing a QRS duration depends on, and you pay vision tokens for the privilege. The first means you have already built the feature extractor, which is the job Pulse is offering to do across 57 channel types at once.

The arithmetic that decides the architecture

Suppose you ignore that and try to serialise the signal into Qwen3.8-27B's context anyway. Take one overnight polysomnography recording: eight hours, 57 channels, 128 Hz. That is 28,800 seconds and about 210 million raw samples.

• Patches. At 0.25 s per patch, one channel yields four patches a second. Fifty-seven channels yield 228 a second, and the full night about 6.57 million patch-channel pairs.

• Against the window. Qwen3.8-27B accepts 262,144 tokens. Even at one token per patch — a compression lossy enough to defeat the exercise — the night is roughly 25 times the window.

• Against the bill. At our listed input price of $0.33 per million tokens, one token per patch costs about $2.17 in input alone for a single night, before output, and the work has to be split across 25 calls whose results you then reconcile.

Pulse's summary output for the same recording is a different order of thing. Per ten-second window, CLS and PatchMean come back as 57 × 256 = 14,592 floats each, about 58 KB at F32; 2,880 windows for the night is roughly 168 MB. Keeping the per-patch token stream instead is far larger — about 6.7 GB for the night at F32 — which is why the summary path, not the token path, is the one that fits a pipeline.

A generated two-column scoreboard titled 'One night of monitoring by the numbers', with the same six row labels on both sides. The left column is headed LingSante-Pulse-1.0 and reads: Input: waveforms; Step size: 0.25 s patches; Output width: 256 numbers; One night stored: 168 MB; Window fit: fits easily; Hosted price: none. The right column is headed Qwen3.8-27B and reads: Input: text and images; Step size: one token per patch; Output width: text; One night stored: 6.7 GB; Window fit: 25 times over; Hosted price: 2.17 dollars input. A footer reads 'Arithmetic ours for eight hours at 57 channels and 128 Hz; Qwen3.8 price from our own catalogue.' The OrcaRouter logo is composited in a white strip along the bottom edge.

The comparison is therefore not "which model is better." The encoder compresses a night of monitoring into something a system can carry; the language model reasons over summaries. Conflating the two is how clinical AI projects end up paying per token for data they should have compressed once.

What Qwen3.8 is genuinely better at

Everything downstream of the embedding. Qwen3.8-27B is a strong general model by third-party measure: 20.1 on the Artificial Analysis Intelligence Index v5.0.1, 68.1 on their coding index, and 90.5 on GPQA Diamond. On Qwen's own card it posts 90.3 on LiveCodeBench v6, 84.3 on OSWorld-Verified and 79.0 on QwenSWEBench — vendor-reported, and not reproduced by us.

Those numbers are not the reason to care. The reason is that the interesting clinical questions are textual: given this patient's medication list, this embedding summary and these lab values, is this the interaction worth flagging, and what is the evidence? That is a language task, and it is the layer Qwen3.8 occupies.

There is telling evidence that inclusionAI reads the stack the same way. The lab's LingSante MedGuard technical report, arXiv 2611.25509, dated 19 November 2026, describes a medical guardrail built by distilling a teacher into 4B, 9B and 27B students — and names Qwen3.8-Max as the model that runs the synthesis pipeline: matching each patient record to an applicable formula, generating the question and reference derivation, verifying the steps, and categorising student failures across five rounds of retraining. That report says nothing about LingSante-Pulse-1.0, which appears in no paper at all. But it does establish that in this lab's own LingSante line the reasoning layer is a Qwen3.8 model, with specialist layers arranged around it. The encoder and the reasoner are separate purchases, made by the same team.

Who should pick which

If you have waveform data — polysomnography, intraoperative monitoring, telemetry, wearable ECG — and no feature extractor you trust, Pulse is the thing to evaluate, with one hard caveat: you cannot run it today. "Evaluate" currently means reimplementing the forward pass from 203 tensor names: twelve blocks at width 256, a fused QKV at [768, 256], a gated MLP at [2048, 256] into [256, 1024], a 32-sample patch projection, a 384-to-256 text adapter, and twelve FiLM heads at [1024, 256]. For someone fluent in PyTorch that is a day's work. It is not a supported integration, and a day spent on it is a day not spent on your endpoint.

If your problem is text — triage notes, guideline retrieval, medication review, summarising a chart — Qwen3.8-27B is available now, open-weight, and priced at $0.33 and $2.40 per million input and output tokens on our catalogue, with a measured p50 of about 2.3 seconds and roughly 76 output tokens per second across the last seven days of playground traffic. Within the family, Qwen3.8-Flash is the cheaper pick at $0.15 and $0.47 with a 1M-token window, and Qwen3.8-Max the stronger one at $2 and $6 with an Intelligence Index of 33.7.

If you are building the whole pipeline you need both, and the pragmatic order is to get the reasoning layer working first against embeddings you already produce, then treat Pulse as an upgrade you swap in when it runs. That ordering also means the encoder's arrival is not a migration: the interface it feeds is stable either way.

Where OrcaRouter fits, and where it does not

The reasoning half of this pipeline is what we serve. Qwen3.8-27B, Qwen3.8-Flash and Qwen3.8-Max sit behind one API key at provider list price with no markup added, so a vendor price change lands the same day rather than at your next billing cycle. If you are still deciding which Qwen3.8 size carries chart summarisation, the routing DSL lets you send bulk traffic to Flash and escalate to Max on a rule instead of a rewrite, and automatic failover keeps one degraded provider from taking the whole path down — which matters more than usual when a stalled request is a stalled clinical decision.

The encoder half is not ours and cannot be. LingSante-Pulse-1.0 is a set of self-hosted weights with no inference code and no hosted endpoint anywhere, so there is nothing for a router to route, and no price to pass through. Claiming otherwise would misdescribe what you get. What is true is that the boundary between the two halves is a plain array of numbers, which is the easiest interface in this system to keep stable.

What would change this verdict

Four things, in ascending order of how much they would tell you.

A PyPI release of lingsante_pulse would make the model callable and turn the card's example from documentation into a test. That is the smallest and most probable next step, and the one that flips Pulse from an artefact into a dependency.

A frozen-feature linear probe on two public datasets — one sleep, one cardiac — would answer the question the repository cannot: whether those 256 numbers carry clinical information or only variance. Nobody has published one, and a probe is cheap enough that a single graduate student could settle it in a week.

A statement of the training corpora would let you judge domain match before spending time on integration. The channel list implies sleep and anaesthesia data; the card does not confirm it, and "works on the montage it saw" is a much weaker claim than "works on the montage in your building."

And an independent head-to-head would help — but not against Qwen3.8. The comparison that would actually inform a purchase is Pulse against a supervised baseline trained on your own data. That is the test a buyer needs, and it is the one no page can run for you.

For now the split is clean. LingSante-Pulse-1.0 is a 67 MB promise with a legible architecture and no way to run it. Qwen3.8-27B is a working model with a published price and a public score. Anyone choosing between them today is not choosing a model — they are choosing which half of a pipeline to build first, and the answer is the half they can actually call.

Screenshot of OrcaRouter's catalogue page for Qwen3.8 27B captured 20 November 2026 in English: the qwen/qwen3.8-27b breadcrumb, input listed as text, image and video with text output, the Apache-2.0 description of a 27B dense multimodal model with a 256K-token context window, zero data retention availability, and the pricing and performance strip showing $0.33 input, $2.40 output, 2.34 s median latency, 10.00 s p95 and 114.6M tokens of traffic.

Compared in this article1

Detected from this article · Benchmarks: Artificial Analysis · updated daily