Salesforce's SOV-Transcribe-1 is now the best open speech recognition model

Salesforce has released SOV-Transcribe-1, a speech recognition model you can download. It ranks first among all open models on the independent AA-WER Index, ahead of Mistral and Nvidia. It's mainly aimed at government agencies and companies that can't send audio recordings to someone else's servers.

Model releases Try it yourself Nov 12, 2026 6 min read Source: Merkliste: cryptobriefing.com

What's going on

Salesforce is best known for customer relationship management (CRM) software, the programs companies use to manage contacts, sales and support requests. On November 12, 2026, the company unveiled an AI model for speech recognition: SOV-Transcribe-1. It turns spoken language into text (speech-to-text). The weights are available for download on Hugging Face. That means companies and government agencies can run the model on their own hardware instead of sending audio files to a cloud service.

What stands out is the ranking. In an independent comparison by the analysis firm Artificial Analysis, SOV-Transcribe-1 takes first place among all openly available speech recognition models. So a business software company has beaten several firms whose core business is building AI models.

The numbers: word error rate and rankings

Speech recognition is usually measured by word error rate (WER). It tells you what share of words were misrecognized, dropped or wrongly inserted. Lower is better. Roughly speaking, 2.3 percent means a little over two errors per 100 words.

On Artificial Analysis's AA-WER Index, SOV-Transcribe-1 hits a word error rate of 2.3 percent. That's seventh place out of 44 models tested. The only models ahead of it are proprietary systems, meaning models whose weights the makers don't release and that usually only run through a paid API. The strongest open competitors both score 2.8 percent: Voxtral Small from Mistral AI and Nemotron 3.5 Transcribe from Nvidia.

The index is built from several test sets. According to the report, SOV-Transcribe-1 posts top scores on two of them:

Test set	Content	WER SOV-Transcribe-1
AA-WER Index (overall)	Mix of several tests	2.3 %
Earnings22	Corporate earnings calls	4.1 %
VoxPopuli	Speeches from the European Parliament	1.5 %
AA-AgentTalk	Conversations in the style of voice assistants and agents	1.8 %

For comparison: Voxtral Small and Nemotron 3.5 Transcribe each sit at 2.8 percent on the overall index. The source doesn't give competitor scores for the individual test sets. Earnings22 is considered a tough test because it's full of jargon, company names, numbers and sometimes poor phone audio. That explains the higher error rate.

A big model, but only part of it works at once

SOV-Transcribe-1 has 26.6 billion parameters in total, but only 4.6 billion of them are active in each computation step. That's the signature of a Mixture-of-Experts (MoE) model: the model consists of many specialized subnetworks, the "experts", and a router sends each input to just a few of them. Think of a large company where not every employee works on every job. The source doesn't use the term explicitly, but the numbers clearly point that way.

The upside: the model runs at roughly the speed of a 4.6-billion-parameter model while carrying the knowledge of a much bigger one. The downside: all 26.6 billion parameters still have to sit in memory. According to the report, the model runs about 60 times faster on a server than "conventional systems". What exactly it was compared against isn't stated, so the claim is hard to put in context.

Background: sovereign AI for government

SOV-Transcribe-1 is part of Salesforce's Sovereign AI initiative. "Sovereign AI" refers to systems an organization runs entirely under its own control, without passing data to third parties. The model is tied to Missionforce, a Salesforce unit for secure, controllable AI for businesses and governments. Missionforce launched in September 2025, about a year before the model, and focuses on government agencies and national security.

This is where open weights make the most sense. Many agencies simply aren't allowed to send call recordings, interrogations or internal meetings to external cloud servers. For those organizations, a model that runs in their own sealed-off environment is often a requirement, not a matter of taste. The "SOV" in the name probably stands for "sovereign", though the source doesn't explicitly confirm that.

What you need to try it

The source says nothing about hardware, so the following figures are estimates. Because all 26.6 billion parameters have to be loaded, you'll need around 55 GB of VRAM at full precision (16-bit). That means a datacenter GPU or several cards. With 4-bit quantization (the model's numbers are stored more coarsely, which saves space at a small cost in accuracy), you'd need an estimated 18 GB of VRAM. That fits on a 24 GB card like an RTX 3090 or 4090. Whether such shrunk-down versions exist yet is unclear. Since only 4.6 billion parameters are active, it might also run reasonably well on an Apple Silicon Mac with plenty of memory (from about 32 GB of unified memory). That depends on whether common tools support the model. Depending on the format, plan for 20 to 60 GB of free disk space for the files. On a CPU alone without a GPU, the model is probably only practical for short recordings.

Still unknown: the license, the supported languages (including how well it handles languages other than English) and the exact name of the Hugging Face repository. Before using it at a company or agency, make sure to check the license terms on the model page.

The big picture

If you want or need to run speech recognition locally, SOV-Transcribe-1 is an interesting new option. According to the AA-WER Index, its 2.3 percent versus 2.8 percent puts it noticeably ahead of Mistral and Nvidia, and it isn't far behind the best proprietary systems. The fact that Salesforce of all companies has jumped to the top of the open models shows that speech recognition is now also a battleground for enterprise software vendors who woo customers with data sovereignty.

Plenty is still open, though. The main source is a brief report with no details on license, languages, hardware or training data. The 60x speed claim is nearly impossible to verify without a baseline. The benchmarks come from an independent analysis firm, but they mostly test English-language material. How well the model handles German dialects, technical jargon or noisy environments is something you'll have to test yourself. And at 26.6 billion parameters, it's far heavier than lean alternatives like Whisper variants, which run on almost any laptop.

Terms explained simply

Word error rate (WER): The share of words a speech recognition system gets wrong, misses or adds. The lower the number, the more accurate the transcript.
Speech-to-text: Technology that automatically converts spoken language into written text, for example for minutes or subtitles.
Open weights: You can download the fully trained model and run it yourself instead of only using it through an online service.
Mixture of Experts (MoE): An architecture where a model consists of many subnetworks and only a few of them work on each input. This makes large models faster.
AA-WER Index: A leaderboard from the analysis firm Artificial Analysis that compares speech recognition models by their word error rate across several test sets.
Sovereign AI: AI systems an organization runs entirely under its own control, without handing data to outside providers.
Earnings22: A test dataset of conference calls in which companies explain their quarterly results. It's considered difficult because of jargon and phone audio quality.

Sources

Merkliste: cryptobriefing.com cryptobriefing.com

#salesforce#speech recognition#open-weights#transcription#sovereign-ai

Read the original source

Try it yourself: SOV-Transcribe-1

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

SOV-Transcribe-1 turns audio recordings into text: meetings, interviews, phone calls, talks or voice memos. According to the independent AA-WER Index, it's currently the most accurate freely downloadable speech recognition model. On average it gets 2.3 percent of words wrong, while Mistral Voxtral Small and Nvidia Nemotron 3.5 Transcribe sit at 2.8 percent. It does especially well on parliamentary speeches (1.5 percent) and voice-assistant-style dialogue (1.8 percent), and it handles tricky conference calls decently too, at 4.1 percent errors. Because it runs locally, your recordings never leave your machine. The catch: at 26.6 billion parameters the model is big and needs a lot of memory, even though only 4.6 billion compute per step. Which languages it supports and how well it handles German hasn't been documented yet.

Who is it worth it for?

The model is worth it if you need to transcribe lots of recordings or confidential ones and have a GPU with plenty of memory – think journalists, researchers, law firms, medical practices or IT departments with data protection requirements. If you only occasionally want a voice memo typed up, or you have a regular laptop without a strong GPU, you're usually better off with smaller models like Whisper.

Ideas: What you can do with it

Meeting minutes without the cloud

Record team meetings and transcribe them locally. You can then have a language model summarize the text. Confidential content never leaves your machine.

Transcribe interviews for research

Journalists and students can turn interview recordings into raw transcripts. Instead of typing for hours, you just fix names and quotes.

Subtitles for videos

Extract your video's audio track, transcribe it and build subtitles from the result. That helps with accessibility and makes videos understandable with the sound off.

Make voice memos searchable

Regularly convert your collected voice memos to text and store them in your notes app. That way you can find ideas and reminders later by searching.

Analyze conference calls

Companies can transcribe customer calls or analyst conferences in-house and search them for keywords without handing the recordings to outside services.

Size26.6 B parameters

Download53 GB (about 71 min at 100 Mbit/s)

Licenseapache-2.0

TypeSpeech recognition (speech to text)

Hugging Facesalesforce-sovereign-intelligence/SOV-Transcribe-1

What your computer needs

Graphics card (NVIDIA) at least 65 GB VRAMThe developer doesn't state a minimum. The figure is calculated: 53.3 GB of weights in BF16 × 1.2 + 1 GB comes to about 65 GB. In practice, that means an 80 GB datacenter GPU or several cards combined. More memory lets you process longer recordings (up to 30 minutes) and multiple files in one go.

Mac (Apple Silicon M1–M5) from 96 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it

Storage approx. 55 GB freeModel download plus programs

The source mentions only one variant, with 26.6 billion parameters (4.6 billion active). As a rough guide: at full precision (16-bit) it needs about 55 GB of VRAM, so a server GPU or several cards. At 8-bit it's around 28 GB, and at 4-bit an estimated 18 GB, which fits on a 24 GB card. Whether ready-made quantized versions exist is still open. Check Hugging Face for community variants.

All 26.6 billion parameters have to fit in memory, even though only 4.6 billion are active per step. Memory requirements are based on the total size.
Rough estimate: about 55 GB of VRAM at 16-bit and about 18 GB at 4-bit. There are no official hardware specs yet.
A 24 GB card like the RTX 3090 or 4090 is the realistic entry point for home users, provided a quantized version exists.
Apple Silicon Macs with lots of unified memory (from about 32 GB) are an option if the software supports the model.
Long recordings need extra memory. If necessary, split very long files into chunks.
Depending on the format, plan for about 20 to 60 GB of free disk space for the model files.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

This model runs with its developers' own program (NVIDIA-NeMo/Skills on GitHub). The commands below come from the Model Card and the developers' instructions.

Windows 10 / 11

Windows 10 / 11: not officially tested. The source doesn't mention Windows. vLLM is meant for Linux, so here you'll go through Transformers instead. You need an NVIDIA card with around 65 GB of VRAM. The alternative is WSL2 (Linux running inside Windows), where you follow the Linux instructions.

Check the requirements. Install Python 3 (tick "Add to PATH" during installation) and a current NVIDIA driver. You need a GPU with around 65 GB of VRAM and a good 55 GB of free disk space. Check this in PowerShell.
```
python --version
nvidia-smi
```
Create a working folder and environment. The virtual environment keeps this project's packages separate from everything else. If PowerShell blocks activation, run Set-ExecutionPolicy -Scope CurrentUser RemoteSigned once first. If it works, you'll see (.venv) at the start of the line.
```
mkdir sov-transcribe; cd sov-transcribe
python -m venv .venv
.venv\Scripts\Activate.ps1
```
Install packages. This installs Transformers (the Hugging Face library), PyTorch, librosa (reads audio files) and accelerate. Make sure PyTorch is installed with CUDA support, i.e. for NVIDIA GPUs. On Windows you'll often end up with the slow CPU-only version otherwise. Instructions are on pytorch.org.
```
pip install "transformers>=5.19,<5.23" torch librosa accelerate huggingface_hub
```
Download the model. This downloads about 53 GB in 16 parts. Depending on your connection, it can take a while.
```
hf download salesforce-sovereign-intelligence/SOV-Transcribe-1
```
Prepare a recording. Put a voice recording named meeting.wav in the sov-transcribe folder, for example a voice memo from your phone. The model understands German and English, among other languages. A recording can be up to 30 minutes long.

Create the script. Save this code with a text editor as demo.py in the sov-transcribe folder. The script loads the model, reads meeting.wav and prints the transcript.

import librosa
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "salesforce-sovereign-intelligence/SOV-Transcribe-1"
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForMultimodalLM.from_pretrained(model_id, trust_remote_code=True, device_map="auto")

audio = [librosa.load("meeting.wav", sr=16000, mono=True)[0]]
inputs = processor.apply_transcription_request(audio).to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, max_new_tokens=8192)
print(processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)[0])

Generate your first transcript. Run the script. Loading the model takes a few minutes. After that, the transcript appears in the window.
```
python demo.py
```
Result. The transcript of your recording meeting.wav appears as text in the terminal.

macOS

macOS: not officially tested. The source doesn't mention macOS, and vLLM doesn't run with GPU acceleration there. With Transformers it might work on an Apple Silicon Mac with a lot of memory (64 GB or more), but probably slowly. The better choice is a rented Linux cloud machine with a big NVIDIA card.

Check the requirements. You need a Mac with an Apple chip (M1 or newer) and ideally 64 GB of memory or more. You also need Python 3 and a good 55 GB of free disk space. Install the Xcode command line tools if you don't have them yet.
```
xcode-select --install
python3 --version
```
Create a working folder and environment. The virtual environment keeps this project's packages separate from the system. When it's active, you'll see (.venv) at the start of the line.
```
mkdir sov-transcribe && cd sov-transcribe
python3 -m venv .venv
source .venv/bin/activate
```
Install packages. This installs Transformers, PyTorch, librosa for reading audio and accelerate. The huggingface_hub package provides the hf download command.
```
pip install "transformers>=5.19,<5.23" torch librosa accelerate huggingface_hub
```
Download the model. This downloads about 53 GB. Allow plenty of time.
```
hf download salesforce-sovereign-intelligence/SOV-Transcribe-1
```
Prepare a recording. Put a voice recording named meeting.wav in the sov-transcribe folder. Recording with the Voice Memos app and exporting it as a file works fine. If needed, convert the file to WAV with an audio program.

Create the script. Save this code as demo.py in the sov-transcribe folder. It loads the model, reads meeting.wav and prints the text.

import librosa
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "salesforce-sovereign-intelligence/SOV-Transcribe-1"
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForMultimodalLM.from_pretrained(model_id, trust_remote_code=True, device_map="auto")

audio = [librosa.load("meeting.wav", sr=16000, mono=True)[0]]
inputs = processor.apply_transcription_request(audio).to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, max_new_tokens=8192)
print(processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)[0])

Generate your first transcript. Run the script. If it completes, the transcript appears in the terminal. If it crashes with a memory error, your Mac doesn't have enough memory.
```
python3 demo.py
```
Result. The transcript of your recording meeting.wav appears as text in the terminal.

Linux

Linux: supported. Linux with an NVIDIA GPU is the main route. The developer recommends vLLM (a fast program for running AI models) via a bundled plugin. With less than about 65 GB of VRAM it won't work, and your only option is a rented cloud machine with a big GPU.

Check the requirements. You need Python 3 with pip, a current NVIDIA driver and a GPU with around 65 GB of VRAM (video memory). You also need a good 55 GB of free disk space for the model. nvidia-smi shows your GPU and how much memory it has.
```
python3 --version
nvidia-smi
```
Create a working folder and environment. A virtual environment (venv) is a separate space for Python packages, so nothing gets tangled up with your system. When the environment is active, you'll see (.venv) at the start of the line.
```
mkdir sov-transcribe && cd sov-transcribe
python3 -m venv .venv
source .venv/bin/activate
```
Install the download tool. The huggingface_hub package provides the hf command, which you use to download files from Hugging Face.
```
pip install huggingface_hub
```
Fetch and install the vLLM plugin. The first command downloads only the vllm_plugin folder from the model repo. The second installs the plugin and pulls in vLLM 0.32.0 along with it. This takes a few minutes.
```
hf download salesforce-sovereign-intelligence/SOV-Transcribe-1 --include "vllm_plugin/*" --local-dir SOV-Transcribe-1
pip install ./SOV-Transcribe-1/vllm_plugin
```
Download the model. Now come the actual model files, about 53 GB in 16 parts. If you skip this step, vLLM downloads the files itself on first launch.
```
hf download salesforce-sovereign-intelligence/SOV-Transcribe-1
```
Prepare a recording. Put a voice recording named meeting.wav in the sov-transcribe folder. It can be, for example, a voice memo from your phone that you've saved as WAV with an audio program. German and English, among others, are supported. By default, the server accepts up to 10 minutes per file.
Start the server. This command loads the model onto the GPU and starts a local server. It takes a few minutes. It's ready when the terminal says it's running on port 8000. Leave the window open.
```
vllm serve salesforce-sovereign-intelligence/SOV-Transcribe-1 --max-model-len 32768
```
Generate your first transcript. Open a second terminal and switch to the sov-transcribe folder. This command sends meeting.wav to the server. After a short wait, the transcript appears as text.
```
cd sov-transcribe
curl http://localhost:8000/v1/audio/transcriptions -F model=salesforce-sovereign-intelligence/SOV-Transcribe-1 -F file=@meeting.wav -F temperature=0
```
Result. The transcript of your recording meeting.wav appears as text in the terminal.

What to do after your first result

A prompt lets you control what the text looks like. In Transformers you use apply_transcription_request(audio, prompt="..."), with the server you use -F prompt="...". That way you can get, for example, a verbatim transcript or a cleaned-up one with punctuation.
You can give the model names, technical terms or the topic of the recording up front (context biasing). It will then recognize difficult words better.
By default, the vLLM server accepts up to 600 seconds of audio per request. For up to 30 minutes, set the variable VLLM_MAX_AUDIO_DECODE_DURATION_S to 1800 before starting it.
The add-on model salesforce-sovereign-intelligence/SOV-Transcribe-1-DFlash makes output about 2 to 3 times faster when you process one recording at a time. You plug it into vLLM via speculative_config and into Transformers via assistant_model.

Try it

A 30-second phone voice memo in German or another non-English language, e.g. "Dentist tomorrow at ten, then groceries: milk, bread, coffee." This tells you whether your language is supported at all.

A clip from an English-language podcast to test accuracy on natural speech and interruptions.

A recording packed with numbers and company names, e.g. "Revenue rose 4.7 percent in the third quarter to 12.3 billion euros." This shows how well it handles figures and jargon.

A phone or video call recording with two or three speakers to test poor audio quality and speaker changes.

A speech with a regional dialect or heavy accent to find the model's limits.

Tips for better results

Use recordings that are as clean as possible, with no background music. Even the best model benefits hugely from good audio.
Split hours-long recordings into chunks of a few minutes. That saves memory and makes errors easier to spot.
Always double-check numbers, names and technical terms in the transcript – according to the Earnings22 results, that's where most errors happen.
If your tool allows it, set the language explicitly instead of relying on auto-detection.
Compare the output with a smaller model like Whisper. That shows you whether the extra hardware effort pays off for your recordings.

If something goes wrong

The source doesn't name the license. Read it on the Hugging Face page before any commercial or government use, and accept it there if required.

It's unclear which languages the model supports. Test your language with a short recording first before processing large batches.

Tools like Transformers or llama.cpp often only support new model architectures after an update. Keep your software up to date.

Speech recognition models usually expect a specific audio format (often 16 kHz mono). If you get errors, convert files first, e.g. with ffmpeg.

If you don't have enough VRAM, loading fails with an out-of-memory error. Then your only options are a quantized version or a bigger GPU.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: apache-2.0.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.