Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Building vertical AI notetakers: What sales, recruitment, healthcare and financial advice tools need to get right
We're all familiar with the horizontal players in the AI notetaker market. Granola, Fireflies, Fathom, and others. But, because we've mapped this market, we know the vertical players, too. There are more of them than ever, and if you ask us, they’re some of the most exciting products in this market. That’s because they solve one specific problem, for one specific profession, very well.
AI notetaker market 2026: funding, acquisitions and what comes next
AI notetakers are one of the most interesting categories in software right now. To map it, we evaluated hundreds of vendors' products and surveyed 2,000+ end users about the tools they’re currently using.
How the AI meeting assistant market has evolved, and where it’s headed next
More than $1 billion in venture funding has gone into meeting assistant tools over the last three years. The result is a crowded market where 97% of users trust AI-generated meeting notes, yet only 41% use their assistant to trigger a workflow. That gap says a lot about where this market stands in 2026: capturing a meeting is mostly solved, and almost everything that comes after it is still up for grabs.
Automatic Speech Recognition (ASR): how speech-to-text models work and which one to use
Published on Oct 16, 2026
by Ani Ghazaryan
Every time you dictate a text, ask Alexa for the weather or get an auto-generated summary after a meeting, a model somewhere is listening and writing down what you said. That model is doing automatic speech recognition (ASR). It’s quietly become one of the most important layers in modern software. When ASR gets a word wrong, every system downstream inherits the mistake. For product teams and engineers shipping voice features, that makes it the layer everything else rests on.
This guide explains how speech recognition works, where it’s used today, the five model families competing to power it, where they break and how to choose one. The findings come from our own engineering team: in late 2025, Bruno Hays, our Speech Engineering Lead, evaluated each approach firsthand to choose the architecture for our next model.
TL;DR
Automatic speech recognition systems convert spoken audio into written text. Every modern system runs the same six steps, from capturing audio to post-processing the transcript. Models differ mostly in how they encode audio and decode it into words.
There are five ASR architecture families: encoder-decoder (Whisper), CTC (Wav2Vec2), encoder-transducer (Parakeet TDT), and speech LLMs with continuous input (Voxtral) or discrete input (Moshi).
ASR is close to solved on clean audio, where the providers on our benchmark land between 3.8% and 8.2% WER on Common Voice. On conversational phone speech, Switchboard, the same field ranges from 33.9% to 55.2%. Crosstalk, 8kHz telephony, accents, code-switching and jargon are where models separate.
No model is best for every job. In our testing, the top families performed similarly and differed mainly in how they were trained. So choose on accuracy on your own audio first, then latency, language coverage and cost.
What is automatic speech recognition (ASR)?
Automatic speech recognition is technology that converts spoken language into written text. It is a branch of artificial intelligence that grew out of computer science and computational linguistics. And today's automatic speech recognition systems are built with machine learning, almost entirely deep learning. An ASR model takes a recording or a live audio stream as input and returns a transcript, usually with punctuation, word timestamps and, when you ask for it, labels for who said what.
You use ASR every time you give voice commands to voice assistants and virtual assistants like Google Assistant. In fact, you use ASR when dictating commands on our own GladiaFlow, the Wispr Flow alternative. ASR powers every voice AI application: voice agents for automated customer service, meeting assistants that handle note taking and CRM entries, real-time subtitles on media platforms, and analytics in call centers.
With such a wide palette of real-life use cases, accuracy matters the most in ASR, as it sits at the start of the pipeline, and no prompt engineering can recover a word the transcript never captured. The industry standard accuracy measure is word error rate (WER), the share of words a model gets wrong against a human-checked reference. At 10% WER, a 1,000-word call carries about 100 errors. You’ll see more of WER in the ASR context, as you read on.
ASR vs STT: is there a difference?
In practice, ASR and STT (speech-to-text) mean the same thing and are used interchangeably. What is STT, really? It's the task of turning spoken audio into written text, which is exactly what ASR describes.
Where people do draw a line is the audience. ASR is the research and engineering term used in papers and on leaderboards. STT is the product term: vendors, like ourselves, sell a speech-to-text API, not an "ASR API". Some vendors also use STT for the model plus everything wrapped around it in production, such as timestamps, diarization, etc.
A few other terms get mixed up with ASR, worth clarifying in advance: Text-to-speech (TTS) runs the other way, turning written text into spoken words. Natural language processing (NLP) works on the text after ASR has produced it (similar to when an LLM summarizes a call). Speaker recognition and voice biometrics identify who is speaking, while ASR identifies what they said.
How does automatic speech recognition technology work?
Every modern ASR system runs the same six steps, from raw audio to finished transcript. What differs between models is mostly steps four and five: how the encoder represents the audio, and how the decoder and language model turn that representation into words.
How speech recognition works: the six stages from captured audio to formatted text.
Capture and digitize the audio
A microphone turns sound waves into an audio signal, which is sampled into a sequence of numbers that becomes the model's audio input. Most ASR models expect mono audio at 16kHz, meaning 16,000 samples per second. Stereo recordings are mixed down or, for calls with one speaker per channel, transcribed channel by channel.
The sample rate is set at the source. Phone lines carry 8kHz narrowband audio, half the rate most models are trained on, which is one reason call transcripts are harder to get right.
Pre-process the signal
Before any model sees the audio, the pipeline cleans it up. Voice activity detection (VAD), a small model that flags which parts of the signal contain speech, trims silence and non-speech. That saves compute and gives the decoder fewer chances to invent words during silence. Long recordings are cut into chunks (Whisper works on 30-second windows), and volume is normalized so quiet and loud speakers reach the model at similar levels.
Extract acoustic features
Feature extraction then turns the waveform into a log-Mel spectrogram, a picture of which frequencies carry energy at each moment.
The audio is cut into short overlapping windows, typically 25 milliseconds wide and spaced 10 milliseconds apart, as in the Whisper paper. Each window becomes a vector of energies across frequency bands spaced on the Mel scale, which mirrors how human hearing separates pitches.
Unlike a text model, which needs an embedding table to turn each word piece into a vector, an audio model gets vectors for free: spectrogram slices act directly as embeddings, the numerical representations a neural network works with.
Encode the audio: the "ears"
The encoder is the part of the model that listens, and the first place a model has to recognize speech rather than noise. A stack of Transformer or Conformer blocks (Conformers add convolution layers to capture local sound patterns) turns the sequence of spectrogram slices into a sequence of richer embeddings.
The mechanism is attention: each slice gathers context from its neighbors, so a sound is interpreted in light of what surrounds it. Stacked blocks build higher-level representations, from raw acoustic patterns towards something close to phonemes.
Conceptually, the encoder hears sounds, not words. For a famous spy introducing himself, its output might read like "maaaï neme iz bonde" (Yes, that’s James Bond. No, the encoder doesn’t know that yet. And if you heard that in a British accent, you’re already a better decoder).
Decode with a language model: the "brain"
Now, the decoder turns the encoder's embeddings into text tokens that form full sentences, usually sub-words produced by BPE (byte pair encoding), an algorithm that splits words at frequent boundaries such as prefixes and suffixes. The language model scores word sequences rather than individual words, so it knows "my name is Bond" is far more likely than "maaaï neme iz bonde", and the output becomes "My name is Bond."
How the encoder and the language model interact is exactly what separates the five architecture families covered below.
Post-process the transcript
Raw model output often lacks punctuation and spells numbers out. Post-processing turns raw output into the final transcription that reads like written language. It adds punctuation and casing and applies inverse text normalization, which converts spoken forms into written ones: "twenty dollars" becomes "$20".
This is also where optional layers run: word-level timestamps, speaker diarization to label who said what, and PII redaction to remove names, card numbers and other sensitive data before the transcript is stored.
Legacy vs end-to-end ASR
Legacy ASR systems used a traditional hybrid approach built from three separately trained statistical models: an acoustic model, usually a hidden Markov model (HMM) with a Gaussian mixture model (GMM); a lexicon, a pronunciation dictionary encoded as a finite-state transducer (FST) that maps "SPEECH" to "S P IY CH"; and an n-gram language model scoring likely word sequences.
The lexicon was the bottleneck: phoneticians had to build one by hand for every language, which is why legacy systems supported few languages well. The end-to-end approach replaces the stack with neural networks trained as one model on pairs of audio and transcripts, so adding a language becomes a data problem rather than a linguistics project.
Hybrid vs End-to-End ASR Comparison
Family
Example models
Streamable?
Main trade-off
Encoder-decoder
Whisper, Canary
Not natively; needs chunking workarounds
Strong language modeling, but sequential decoding and full-window input
CTC
Wav2Vec2
Yes, with a streaming encoder
Simple and parallel, but weak without an external language model
Encoder-transducer
Parakeet TDT, Nemotron Speech Streaming
Yes, by design
Low latency, harder to batch
Speech LLM, continuous input
Voxtral, Qwen Audio
Depends on the encoder
Reuses a strong pre-trained LLM; output depends on prompting
Speech LLM, discrete input
Moshi, Kimi-Audio
Yes, in speech-to-speech systems
Understands and generates speech; heavier to run
One of Bruno's key observations is that the encoder-decoder and the continuous speech LLM are mathematically equivalent. One gives the decoder access to audio through cross-attention, the other through self-attention, and in practice both reach very similar scores on leaderboards. The real difference is training: encoder-decoders train the encoder and decoder together on audio, while speech LLMs train them separately and then teach them to work together.
Wav2Vec2, released by Meta (then Facebook) in 2020, applied BERT's training trick to audio: hide random slices of the signal and train the model to predict what is missing. That self-supervised pre training needs no transcripts, and it made pre-trained models the norm: through transfer learning and fine-tuning on a little labeled data, typically with a CTC head, one encoder becomes an ASR model for a new language or domain.
Follow-up models HuBERT and WavLM pushed the idea further. In November 2025, Meta released Omnilingual ASR, which scales this pretraining to 7 billion parameters and covers more than 1,600 languages, over 500 of which no ASR system had served before.
Whisper (OpenAI)
OpenAI released Whisper in 2022 as a family of standard encoder-decoder models. The architecture wasn't new; the training data was. Whisper was trained on 680,000 hours of weakly supervised multilingual audio, transcripts gathered from the internet rather than produced by careful human annotation.
As Bruno points out, the reason comes down to data. CTC needs tightly standardized transcripts, while an encoder-decoder tolerates messy ones, such as "$" in one file and "dollars" in the next. The cleanup effort that produces 1,000 usable hours for CTC can produce a million hours for an encoder-decoder. That scale gave Whisper multilingual accuracy and speech translation that no open model matched at the time, and it is still the baseline new models are measured against.
Kyutai STT
Kyutai STT is built on delayed streams modeling, a technique Kyutai first developed for its Moshi voice assistant and describes in its paper. The model processes audio and text as parallel, time-aligned streams, with the text delayed a few frames behind the audio so the model gets a little lookahead before committing to a word.
The 1B English and French model runs with a 500-millisecond delay and a semantic VAD that predicts when a speaker has finished a thought rather than paused for breath. Kyutai's "flush trick" then processes the buffered audio at roughly four times real time once speech ends, so the last words arrive in about 125 milliseconds instead of 500. Because the design batches well, Kyutai reports 400 concurrent real-time streams on a single H100.
NVIDIA Nemotron Speech Streaming En 0.6B
This one’s a 600-million-parameter English model that pairs a cache-aware FastConformer encoder with a transducer decoder. Most streaming encoders reprocess overlapping chunks of audio as new frames arrive; the cache-aware design reuses earlier computation, so each new chunk only adds the work it needs.
The latency-accuracy trade-off is set at inference time, without retraining: 80 or 160-millisecond chunks for voice agents, up to 1.12 seconds for accuracy. On NVIDIA's model card (as of October 2026), average WER on the Hugging Face leaderboard datasets moves from 8.43% at 80 milliseconds to 6.93% at 1.12 seconds. These are self-reported numbers, not comparable with our benchmark figures. In June 2026, NVIDIA extended the approach to 40 language-locales with Nemotron 3.5 ASR Streaming.
Gladia Solaria-1 and Solaria-3
Our own models are managed APIs built for two different jobs. Solaria-1 is the breadth model covering 100+ languages along with regional accents, code-switching within a conversation and real-time transcription with partial results in under 103 milliseconds.
Solaria-3 is tuned for real-world business audio in English, French, German, Spanish and Italian. On our internal dataset of real customer recordings, it reaches 9.6% WER on English, first among the providers we test, and it also ranks first on Switchboard and Earnings22. However, like any model, Solaria-3 has its limits: it is async only for now, takes one language per request with no code-switching, and trails Solaria-1 on clean read speech (36% higher WER on Multilingual LibriSpeech) and formal speech (32% higher on VoxPopuli). For those jobs, Solaria-1 is the better pick.
Where automatic speech recognition systems fail
On clean audio with one speaker, most commercial ASR systems perform about the same. On real-world audio, the gap widens fast. You can see it on our open benchmark, which runs the same files through every provider’s API with default settings.
ASR Benchmark WER Comparison
Dataset
Audio type
WER range across providers tested
VoxPopuli
Formal speeches, European Parliament
1.7% to 3.2%
Common Voice 24
Clean read speech, multilingual
3.8% to 8.2%
Earnings22 (cleaned)
Financial earnings calls
6.4% to 12.0%
Real customer audio
English production recordings
9.6% to 12.9%
Switchboard
Conversational telephone speech
33.9% to 55.2%
Crosstalk and overlapping speakers
When two people talk at once, ASR models tend to merge their words or attribute them to the wrong person. The transcript loses who said what, which is what a QA reviewer needs most. Labeling speakers is a separate step called speaker diarization, which runs on top of ASR and is measured with diarization error rate (DER), the share of speech time assigned to the wrong speaker. Diarization gets much harder when people talk over each other, which is why meetings are so tough. On the meeting recordings in the DIHARD III dataset, our own system, the top performer on our benchmark, still assigns 29.9% of speech time to the wrong speaker. On broadcast audio, where people take turns, that drops to 9.4%.
Telephony audio (8kHz)
Phone networks carry audio sampled at 8kHz, which can only represent frequencies up to 4kHz, and much of what separates sounds like “s” and “f” sits above that line. Models trained on 16kHz audio expect that information, and upsampling can’t restore it because it was never recorded. The words hit hardest are often the ones that matter most, like names, account numbers and amounts, so a single misheard digit can break a CRM record or a call summary. The result shows in the Switchboard row above; we cover the mechanics in why 8kHz narrowband calls break generic STT.
Accents and dialects
WER climbs on different accents and speaking styles that are underrepresented in a model’s training data, because the subtle differences in speech patterns are exactly what the model hasn’t learned. A single published average hides that: a model can score well overall while performing far worse for a large share of your users. In practice, that means some customers get accurate transcripts and summaries while others get broken ones, often without anyone noticing until they complain. Split your test set by accent or region and compute WER for each group.
Code-switching
Many speakers switch languages mid-sentence, for example between English and Spanish. A model that detects the language once and decodes everything after it in that language will drop or garble the switched words. The problem is common in places where mixing is the norm, like Hinglish in India, Taglish in the Philippines or French and Arabic in North Africa, yet most training data is monolingual, so models rarely see mixed sentences. It also shows up in single-language conversations, where English product names and tech terms land in the middle of French or German speech. Handling it takes detection per utterance, as our explainer on code-switching in speech recognition shows.
Domain vocabulary
Names, drug names, product codes and other specific words are rare in training data, so models replace them with similar-sounding common words. WER hides the damage because it counts every word equally, so a transcript can score well overall while getting most of the important terms wrong. To catch this, measure accuracy on the key terms separately from overall WER. Custom vocabulary and prompting help by telling the model which terms to expect, though overly long term lists can backfire, with the model inserting those terms where they weren’t said.
Hallucinations
Generative decoders, used by encoder-decoders and speech LLMs, can write text that differs from the actual words spoken, especially during silence or heavy noise. Because invented text reads fluently, it is harder to spot than a garbled word. On a degraded phone clip, for example, a model can output a full, grammatical sentence that nobody said. VAD helps by keeping silence away from the decoder.
In real-world applications, all of these errors flow straight into whatever reads the transcript next, whether that’s an LLM writing a summary or an agent deciding what to say.
Which ASR model should you use?
There is no single best ASR model. The right one depends on five questions about your product, and the first one matters most.
Accuracy on your own audio
WER depends heavily on who is speaking and how the audio was recorded, so a leaderboard rank tells you little about your calls. Benchmark two or three candidates on a sample of your real recordings with human-checked reference transcripts, and normalize both sides the same way before computing WER, or formatting differences will count as errors. Our docs walk through a five-step benchmarking method.
Running a file through a candidate takes a few lines. Here's how to transcribe audio from a file with a pre-recorded request against Gladia's v2 API, following the quickstart:
import os
import time
import requests
API_URL = "https://api.gladia.io/v2"HEADERS = {"x-gladia-key": os.environ["GLADIA_API_KEY"]}
# 1. Upload a local file and get back a hosted audio_url
with open("call.wav", "rb") as f:
upload = requests.post(f"{API_URL}/upload", headers=HEADERS, files={"audio": f})
upload.raise_for_status()
audio_url = upload.json()["audio_url"]
# 2. Create the transcription job
job = requests.post(
f"{API_URL}/pre-recorded",
headers=HEADERS,
json={
"audio_url": audio_url,
"model": "solaria-3",
"language_config": {"languages": ["en"]},
},
)
job.raise_for_status()
job_id = job.json()["id"]
# 3. Poll until the job is done or fails
while True:
res = requests.get(f"{API_URL}/pre-recorded/{job_id}", headers=HEADERS)
res.raise_for_status()
data = res.json()
if data["status"] "done":
print(data["result"]["transcription"]["full_transcript"])
break
if data["status"] "error":
raise RuntimeError(f"Transcription failed with code {data.get('error_code')}")
time.sleep(3)
Swap "solaria-3" for "solaria-1" to compare our two models. For a quick, brand-blind first look, the blind STT comparison tool hides provider names until you've voted. Give it a shot and let us know about your results.
Real-time or async
Latency needs decide the architecture before accuracy does. A voice agent needs low latency: it has to transcribe speech while the caller is still talking, which points to streaming designs such as transducers. A post-call summary can wait: async processing lets the model see the whole recording, which usually buys accuracy. On Gladia, that maps to real-time transcription with Solaria-1 for live use cases and async transcription with either model for recordings.
Languages, accents and code-switching
Check accuracy for each language you need, not the headline count. Even within one model the spread is wide: on Multilingual LibriSpeech, Solaria-1 scores 4.0% WER in Spanish and 9.9% in Italian. If your users switch languages mid-conversation, confirm the model supports code-switching at all, as that will be the backbone of your output results.
Operating environment and audio properties
Background noise and microphone quality change results more than most teams expect, so it’s important you test with audio from your users' real environments. Check the technical properties too: sample rate (8kHz telephony or 16kHz and above), number of channels, file format and duration, and confirm supported formats and limits before you commit.
Deployment and cost
Self-hosting an open model such as Whisper removes per-hour fees, but you take on GPUs, scaling, and the extra models you’ll need for diarization. Commercial ASR systems sold as managed APIs typically price per hour of audio, so compare that total against self-hosting to see which is more cost-effective at your volume. As of October 2026, Gladia’s async pricing starts at $0.18 per hour with Solaria-3 and $0.30 per hour with Solaria-1, with volume discounts applied automatically as usage grows. Real-time starts at $0.75 per hour. Diarization, custom vocabulary, and enhanced punctuation are included at no extra cost, so speaker separation doesn’t become another model to host and maintain.
Moving off an in-house setup can also pay off in speed: when Aircall replaced its own transcription engine, processing time per call dropped from up to 30 minutes to about 1.5 minutes, and the team now runs more than a million transcriptions a week without managing the infrastructure behind them.
Compliance is another cost that’s easy to overlook when self-hosting, since audits, certifications, and data residency all become your team’s responsibility. With a managed API, much of that work is already done. Gladia is GDPR and HIPAA compliant, ISO 27001 certified, and SOC 2 Type 2 certified, with EU and US hosting so you can keep audio data in the region your customers or regulators require.
Where ASR is heading
None of the five families is going away. Bruno's read is that the competition has moved from architecture to three trade-offs every team is trying to break:
Streaming without losing batch accuracy: Real-time models still trail models that see the whole recording.
Language breadth without per-language loss: Adding languages to one model tends to cost accuracy in some of them.
Lower latency without more infrastructure: Cutting delay usually means more compute per stream.
Pick the model on your audio, not on the leaderboard
Automatic speech recognition is close to solved on clean audio and still open on the audio most products handle: phone calls, crosstalk, accents and jargon. Since the leading families score alike, what separates models in production is their training data and how they hold up on recordings like yours.
So shortlist on latency and language needs, then let your own audio decide. Test Gladia on your recordings with 50€ in free credits, and follow the docs to run your first transcription in a few minutes.
An ASR model is a neural network that turns audio into text. Modern ASR models pair an audio encoder, which turns sound into embeddings, with a language model that turns those embeddings into words. They fall into five families: encoder-decoder, CTC, encoder-transducer, and speech LLMs with continuous or discrete input.
How does ASR work?
ASR works in six steps. The system captures and digitizes the audio, removes silence, converts the waveform into a log-Mel spectrogram, encodes it into embeddings, and decodes those into words using a language model. A final step adds punctuation and formatting.
What are the main ASR model architectures?
The five main ASR architectures are encoder-decoder models such as Whisper, CTC models such as Wav2Vec2, encoder-transducers such as Parakeet TDT, and speech LLMs with continuous input (Voxtral) or discrete input (Moshi). They differ in how the encoder and language model interact, which decides whether a model can stream.
Is Whisper an ASR model?
Yes. Whisper is an encoder-decoder ASR model that OpenAI released in 2022, trained on 680,000 hours of weakly supervised multilingual audio. Whisper showed that encoder-decoder models can learn from much larger and messier datasets than CTC models, and it remains the baseline most new ASR models are compared against.
How accurate is speech recognition?
Speech recognition accuracy is measured with word error rate (WER). On clean read speech, leading ASR models reach low single-digit WER, between 3.8% and 8.2% on Common Voice in Gladia's benchmark. On conversational phone audio such as Switchboard, the same providers range from 33.9% to 55.2%.
How do ASR and LLMs work together?
In most voice products, ASR transcribes the audio and an LLM then reads the transcript to summarize it, extract fields or decide a reply. Any ASR error passes straight into the LLM's output, as covered in why speech-to-text accuracy matters upstream of your LLM. Gladia's Audio-to-LLM runs your prompts on the transcript in the same request. Speech LLMs combine both roles by connecting an audio encoder directly to a language model.
What is the best ASR model?
No ASR model is best for every use case. The right model depends on accuracy on your own audio, real-time or batch needs, language coverage and cost. Benchmark two or three candidates on your real recordings, or start with a blind comparison tool that hides provider names until you've judged the transcripts.
Key terms glossary
WER (word error rate): the share of words a transcript gets wrong against a human-checked reference. Lower is better.
DER (diarization error rate): the share of speech time assigned to the wrong speaker, the standard metric for speaker diarization.
Diarization: labeling who spoke when in a multi-speaker recording.
Code-switching: changing language mid-conversation or mid-sentence.
Encoder: the part of an ASR model that turns audio features into embeddings, usually built from Transformer or Conformer blocks.
Encoder-decoder: an architecture where a separate decoder generates text token by token, reading the audio through cross-attention. Used by Whisper and Canary.
CTC (connectionist temporal classification): an architecture where the encoder outputs a letter or token probability for every audio slice, with repeats and blanks collapsed afterwards.
Encoder-transducer: an architecture where a joiner reads encoder embeddings one at a time and asks a predictor network what to emit next. Streamable by design.
Embeddings: vectors that represent sounds, words or concepts in a form a neural network can process.
Text tokens / BPE: sub-word units a model reads and writes; byte pair encoding (BPE) is the algorithm most tokenizers use to create them.
Log-Mel spectrogram: a representation of audio as energy across frequency bands over time, with bands spaced to mirror human hearing.
VAD (voice activity detection): a model that flags which parts of a recording contain speech.
Inverse text normalization: converting spoken forms into written ones, such as "twenty dollars" into "$20".
HMM (hidden Markov model): a statistical model used in legacy acoustic models to represent how sounds change over time.
GMM (Gaussian mixture model): a statistical model paired with HMMs in legacy automatic speech recognition to model the distribution of acoustic features.
FST (finite-state transducer): a structure used in legacy lexicons to encode valid pronunciations.
Lexicon model: a pronunciation dictionary mapping words to their sounds, used in legacy automatic speech recognition.
Seq2seq (sequence-to-sequence): a neural architecture that maps one sequence (audio) to another (text) in a single network.
LSTM (long short-term memory): a type of recurrent neural network that keeps context over long sequences, widely used in automatic speech recognition before Transformers.
Contact us
Your request has been registered
A problem occurred while submitting the form.
Read more
Speech-To-Text
Building vertical AI notetakers: Sales, recruitment, healthcare and financial advice tools
Speech-To-Text
AI notetaker market 2026: funding, acquisitions and what comes next
Speech-To-Text
The AI meeting assistant market evolution
From audio to knowledge
Subscribe to receive latest news, product updates and curated AI content.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
