diff --git a/examples/python/parakeet.py b/examples/python/parakeet.py
new file mode 100644
index 0000000000..be3b7dc264
--- /dev/null
+++ b/examples/python/parakeet.py
@@ -0,0 +1,99 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""
+Parakeet TDT speech recognition
+
+  python parakeet.py --model_path <model_dir> --audio_file <audio>
+
+The model loads the audio in one shot and decodes it with the standard
+Generator loop.
+"""
+
+import argparse
+import os
+import time
+import wave
+
+import onnxruntime_genai as og
+
+
+def _audio_duration_seconds(path: str) -> float:
+    try:
+        with wave.open(path, "rb") as wf:
+            frames = wf.getnframes()
+            rate = wf.getframerate()
+            if rate > 0:
+                return frames / float(rate)
+    except wave.Error:
+        # Not a valid/parsable WAV stream; fall back to soundfile below.
+        pass
+    try:
+        import soundfile as sf  # type: ignore
+        info = sf.info(path)
+        return float(info.frames) / float(info.samplerate)
+    except Exception:
+        # soundfile missing or file unreadable; duration is non-essential
+        # for this sample, so return 0.0 rather than failing the run.
+        return 0.0
+
+
+def run(args: argparse.Namespace) -> None:
+    print("Loading model...")
+    config = og.Config(args.model_path)
+    if args.execution_provider != "follow_config":
+        config.clear_providers()
+        if args.execution_provider != "cpu":
+            print(f"Setting model to {args.execution_provider}")
+            config.append_provider(args.execution_provider)
+    model = og.Model(config)
+    processor = model.create_multimodal_processor()
+
+    if not os.path.exists(args.audio_file):
+        raise FileNotFoundError(f"Audio file not found: {args.audio_file}")
+
+    print(f"Loading audio: {args.audio_file}")
+    audios = og.Audios.open(args.audio_file)
+    audio_seconds = _audio_duration_seconds(args.audio_file)
+
+    print("Processing audio...")
+    t0 = time.perf_counter()
+    inputs = processor("", audios=audios)
+
+    params = og.GeneratorParams(model)
+
+    generator = og.Generator(model, params)
+    generator.set_inputs(inputs)
+
+    while not generator.is_done():
+        generator.generate_next_token()
+    elapsed = time.perf_counter() - t0
+
+    transcription = processor.decode(generator.get_sequence(0))
+
+    print()
+    print("Transcription:")
+    print(f"    {transcription.strip()}")
+
+    print()
+    if audio_seconds > 0:
+        rtfx = audio_seconds / elapsed if elapsed > 0 else float("inf")
+        print(f"Audio duration: {audio_seconds:.2f}s | Inference: {elapsed:.2f}s | RTFx: {rtfx:.2f}x")
+    else:
+        print(f"Inference: {elapsed:.2f}s")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-m", "--model_path", type=str, required=True, help="Path to the Parakeet model directory")
+    parser.add_argument("-a", "--audio_file", type=str, required=True, help="Path to the audio file (WAV/MP3/...)")
+    parser.add_argument(
+        "-e",
+        "--execution_provider",
+        type=str,
+        required=False,
+        default="follow_config",
+        choices=["cpu", "cuda", "follow_config"],
+        help="Execution provider. Defaults to follow_config.",
+    )
+    args = parser.parse_args()
+    run(args)
diff --git a/src/config.cpp b/src/config.cpp
index 9fc7f3605b..0964377300 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -340,6 +340,8 @@ struct DecoderInputs_Element : JSON::Element {
       v_.lstm_hidden_state = JSON::Get<std::string_view>(value);
     } else if (name == "lstm_cell_state") {
       v_.lstm_cell_state = JSON::Get<std::string_view>(value);
+    } else if (name == "targets_length") {
+      v_.targets_length = JSON::Get<std::string_view>(value);
     } else {
       throw JSON::unknown_value_error{};
     }
@@ -373,6 +375,8 @@ struct DecoderOutputs_Element : JSON::Element {
       v_.lstm_hidden_state = JSON::Get<std::string_view>(value);
     } else if (name == "lstm_cell_state") {
       v_.lstm_cell_state = JSON::Get<std::string_view>(value);
+    } else if (name == "outputs_length") {
+      v_.outputs_length = JSON::Get<std::string_view>(value);
     } else {
       throw JSON::unknown_value_error{};
     }
@@ -1129,6 +1133,8 @@ struct Model_Element : JSON::Element {
       v_.preemph = static_cast<float>(JSON::Get<double>(value));
     } else if (name == "log_eps") {
       v_.log_eps = static_cast<float>(JSON::Get<double>(value));
+    } else if (name == "norm_eps") {
+      v_.norm_eps = static_cast<float>(JSON::Get<double>(value));
     } else if (name == "subsampling_factor") {
       v_.subsampling_factor = static_cast<int>(JSON::Get<double>(value));
     } else if (name == "left_context") {
@@ -1145,6 +1151,10 @@ struct Model_Element : JSON::Element {
       v_.blank_id = static_cast<int>(JSON::Get<double>(value));
     } else if (name == "max_symbols_per_step") {
       v_.max_symbols_per_step = static_cast<int>(JSON::Get<double>(value));
+    } else if (name == "left_context_samples") {
+      v_.left_context_samples = static_cast<int>(JSON::Get<double>(value));
+    } else if (name == "right_context_samples") {
+      v_.right_context_samples = static_cast<int>(JSON::Get<double>(value));
     } else {
       throw JSON::unknown_value_error{};
     }
@@ -1153,6 +1163,8 @@ struct Model_Element : JSON::Element {
   Element& OnArray(std::string_view name) override {
     if (name == "eos_token_id")
       return eos_token_id_;
+    if (name == "tdt_durations")
+      return tdt_durations_;
     throw JSON::unknown_value_error{};
   }
 
@@ -1186,6 +1198,7 @@ struct Model_Element : JSON::Element {
   Encoder_Element encoder_{v_.encoder};
   Decoder_Element decoder_{v_.decoder};
   Int_Array_Element eos_token_id_{v_.eos_token_id};
+  Int_Array_Element tdt_durations_{v_.tdt_durations};
   Vision_Element vision_{v_.vision};
   Embedding_Element embedding_{v_.embedding};
   Speech_Element speech_{v_.speech};
diff --git a/src/config.h b/src/config.h
index 155970ba22..88abd6dc1f 100644
--- a/src/config.h
+++ b/src/config.h
@@ -145,6 +145,7 @@ struct Config {
     int win_length{};
     float preemph{};
     float log_eps{};
+    float norm_eps{};
     int subsampling_factor{};
     int left_context{};
     int conv_context{};
@@ -154,6 +155,11 @@ struct Config {
     int blank_id{};
     int max_symbols_per_step{};
 
+    // Parakeet TDT (Token-and-Duration Transducer) parameters
+    int left_context_samples{};
+    int right_context_samples{};
+    std::vector<int> tdt_durations;  // e.g., {0, 1, 2, 3, 4}
+
     struct Encoder {
       std::string filename;
       std::optional<SessionOptions> session_options;
@@ -346,6 +352,9 @@ struct Config {
         std::string targets;
         std::string lstm_hidden_state;
         std::string lstm_cell_state;
+
+        // Parakeet TDT decoder (prediction network) extra inputs
+        std::string targets_length;
       } inputs;
 
       struct Outputs {
@@ -361,6 +370,9 @@ struct Config {
         std::string outputs;
         std::string lstm_hidden_state;
         std::string lstm_cell_state;
+
+        // Parakeet TDT decoder (prediction network) extra outputs
+        std::string outputs_length;
       } outputs;
 
       struct PipelineModel {
diff --git a/src/generators.cpp b/src/generators.cpp
index 319f65d97c..af70c4e9b7 100644
--- a/src/generators.cpp
+++ b/src/generators.cpp
@@ -6,6 +6,7 @@
 #include "generators.h"
 #include "models/streaming_processor.h"
 #include "models/nemotron_speech.h"
+#include "models/parakeet.h"
 #include "sequences.h"
 #include "models/env_utils.h"
 #include "models/model.h"
@@ -365,11 +366,11 @@ std::unique_ptr<Search> CreateSearch(const GeneratorParams& params) {
 }
 
 Generator::Generator(const Model& model, const GeneratorParams& params) : model_{model.shared_from_this()} {
-  // RNNT models don't use the traditional search/logits pipeline,
+  // RNNT and TDT models don't use the traditional search/logits pipeline,
   // so skip the standard validations and just create the state.
-  if (ModelType::IsRNNT(model.config_->model.type)) {
+  if (ModelType::IsTransducer(model.config_->model.type)) {
     state_ = model.CreateState({}, params);
-    is_nemotron_speech_model_ = dynamic_cast<NemotronSpeechState*>(state_.get()) != nullptr;
+    transducer_state_ = dynamic_cast<TransducerState*>(state_.get());
     return;
   }
 
@@ -569,18 +570,18 @@ void Generator::SetRuntimeOption(const char* key, const char* value) {
 }
 
 size_t Generator::TokenCount() const {
-  if (is_nemotron_speech_model_)
-    return static_cast<NemotronSpeechState*>(state_.get())->TokenCount();
+  if (transducer_state_)
+    return transducer_state_->TokenCount();
   return static_cast<size_t>(search_->GetSequenceLength());
 }
 
 bool Generator::IsDone() {
   ThrowErrorIfSessionTerminated(state_->session_terminated_);
 
-  if (is_nemotron_speech_model_) {
+  if (transducer_state_) {
     // Pending mel input means we haven't started processing this chunk yet
     if (!extra_inputs_.empty()) return false;
-    return static_cast<NemotronSpeechState*>(state_.get())->IsChunkDone();
+    return transducer_state_->IsChunkDone();
   }
 
   if (computed_logits_) {
@@ -613,11 +614,12 @@ void Generator::GenerateNextToken() {
 
   ThrowErrorIfSessionTerminated(state_->session_terminated_);
 
-  // RNNT models: yield one token per call from the decoder state machine
-  if (is_nemotron_speech_model_) {
+  // Transducer models (RNNT, TDT): yield one token per call by stepping
+  // the encoder/decoder/joiner loop directly.
+  if (transducer_state_) {
     state_->SetExtraInputs(extra_inputs_);
     extra_inputs_.clear();
-    static_cast<NemotronSpeechState*>(state_.get())->StepToken();
+    transducer_state_->StepToken();
     return;
   }
 
diff --git a/src/generators.h b/src/generators.h
index 9c15b0bf23..89eebffb7b 100644
--- a/src/generators.h
+++ b/src/generators.h
@@ -40,6 +40,7 @@ void ThrowErrorIfSessionTerminated(bool is_session_terminated);
 namespace Generators {
 struct Model;
 struct State;
+struct TransducerState;
 struct Search;
 struct Tokenizer;
 struct ConstrainedLogitsProcessor;
@@ -132,7 +133,8 @@ struct Generator : LeakChecked<Generator> {
   Action last_action_{standard};
 
   // Pre-computed per-token decisions: avoid repeated checks each token
-  bool is_nemotron_speech_model_{};
+  // Non-null when the model is a transducer (RNNT, TDT); points into state_.
+  TransducerState* transducer_state_{nullptr};
   int phi3_rope_threshold_{};  // 0 means no ROPE rewind needed
   enum class SamplingMethod { kGreedy,
                               kTopK,
diff --git a/src/models/model.cpp b/src/models/model.cpp
index 8a4c248cf5..39a11a3d63 100644
--- a/src/models/model.cpp
+++ b/src/models/model.cpp
@@ -16,6 +16,8 @@
 #include "gpt.h"
 #include "decoder_only.h"
 #include "whisper.h"
+#include "parakeet.h"
+#include "parakeet_processor.h"
 #include "nemotron_speech.h"
 #include "multi_modal.h"
 #include "lfm2.h"
@@ -830,6 +832,8 @@ std::shared_ptr<Model> CreateModel(OrtEnv& ort_env, std::unique_ptr<Config> conf
     return std::make_shared<DecoderOnly_Model>(std::move(config), ort_env);
   if (ModelType::IsRNNT(config->model.type))
     return std::make_shared<NemotronSpeechModel>(std::move(config), ort_env);
+  if (ModelType::IsTDT(config->model.type))
+    return std::make_shared<ParakeetTdtModel>(std::move(config), ort_env);
   if (ModelType::IsALM(config->model.type))
     return std::make_shared<WhisperModel>(std::move(config), ort_env);
   if (ModelType::IsVLM(config->model.type))
@@ -936,6 +940,7 @@ MultiModalProcessor::MultiModalProcessor(Config& config, const SessionInfo& sess
       processor_factory_{
           {"phi3v", Processor::Create<PhiImageProcessor>},
           {"whisper", Processor::Create<WhisperProcessor>},
+          {"parakeet_tdt", Processor::Create<ParakeetTdtProcessor>},
           {"phi4mm", Processor::Create<PhiMultiModalProcessor>},
           {"gemma3", Processor::Create<GemmaImageProcessor>},
           {"gemma4", Processor::Create<Gemma4MultiModalProcessor>},
diff --git a/src/models/model.h b/src/models/model.h
index cd47f37112..9b43311366 100644
--- a/src/models/model.h
+++ b/src/models/model.h
@@ -9,6 +9,7 @@
 #include "utils.h"
 #include "phi_image_processor.h"
 #include "whisper_processor.h"
+#include "parakeet_processor.h"
 #include "phi_multimodal_processor.h"
 #include "gemma_image_processor.h"
 #include "gemma4_multimodal_processor.h"
diff --git a/src/models/model_type.h b/src/models/model_type.h
index 51efb901c3..a77146bdd0 100644
--- a/src/models/model_type.h
+++ b/src/models/model_type.h
@@ -47,6 +47,17 @@ struct ModelType {
     return std::find(rnnt_types.begin(), rnnt_types.end(), model_type) != rnnt_types.end();
   }
 
+  inline static bool IsTDT(const std::string& model_type) {
+    static constexpr std::array<std::string_view, 1> TDT = {"parakeet_tdt"};
+    return std::find(TDT.begin(), TDT.end(), model_type) != TDT.end();
+  }
+
+  // Transducer models (RNNT, TDT) bypass the standard search/logits pipeline
+  // and drive a custom encoder/decoder/joiner loop via TransducerState.
+  inline static bool IsTransducer(const std::string& model_type) {
+    return IsRNNT(model_type) || IsTDT(model_type);
+  }
+
   inline static bool IsMMM(const std::string& model_type) {
     // Multi-modal model (MMM)
     static constexpr std::array<std::string_view, 2> MMM = {"gemma4", "phi4mm"};
diff --git a/src/models/nemotron_speech.cpp b/src/models/nemotron_speech.cpp
index 879999f40a..110f106d8c 100644
--- a/src/models/nemotron_speech.cpp
+++ b/src/models/nemotron_speech.cpp
@@ -338,9 +338,11 @@ DeviceSpan<float> NemotronJoinerSubState::Run(int /*total_length*/, DeviceSpan<i
 
 NemotronSpeechState::NemotronSpeechState(const NemotronSpeechModel& model,
                                          const GeneratorParams& params)
-    : State{params, model},
+    : TransducerState{params, model},
       nemotron_model_{model} {
   nemotron_config_ = model.nemotron_config_;
+  // Until audio is fed via SetExtraInputs/SetInputs, the stream is idle.
+  chunk_done_ = true;
 
   encoder_state_ = std::make_unique<NemotronEncoderSubState>(model, params);
   prediction_state_ = std::make_unique<NemotronPredictionSubState>(model, params);
@@ -447,7 +449,7 @@ void NemotronSpeechState::RunEncoder() {
   current_mel_.reset();
 }
 
-std::span<const int32_t> NemotronSpeechState::StepToken() {
+void NemotronSpeechState::StepToken() {
   if (need_encoder_run_) {
     RunEncoder();
     need_encoder_run_ = false;
@@ -540,13 +542,12 @@ std::span<const int32_t> NemotronSpeechState::StepToken() {
     }
 
     last_tokens_.push_back(static_cast<int32_t>(best_token));
-    token_count_++;
-    return last_tokens_;
+    all_tokens_.push_back(static_cast<int32_t>(best_token));
+    return;
   }
 
   // Exhausted all time steps
   chunk_done_ = true;
-  return last_tokens_;
 }
 
 }  // namespace Generators
diff --git a/src/models/nemotron_speech.h b/src/models/nemotron_speech.h
index 8b58454586..87ab70a24c 100644
--- a/src/models/nemotron_speech.h
+++ b/src/models/nemotron_speech.h
@@ -6,6 +6,7 @@
 
 #include "model.h"
 #include "audio_features.h"
+#include "transducer_state.h"
 
 namespace Generators {
 
@@ -182,7 +183,7 @@ struct NemotronJoinerSubState : State {
 };
 
 /// Orchestrator state for the full RNNT pipeline.
-struct NemotronSpeechState : State {
+struct NemotronSpeechState : TransducerState {
   NemotronSpeechState(const NemotronSpeechModel& model, const GeneratorParams& params);
   ~NemotronSpeechState() override;
 
@@ -191,10 +192,7 @@ struct NemotronSpeechState : State {
 
   void SetExtraInputs(const std::vector<ExtraInput>& extra_inputs) override;
 
-  std::span<const int32_t> StepToken();
-  bool IsChunkDone() const { return chunk_done_; }
-  std::span<const int32_t> GetStepTokens() const { return last_tokens_; }
-  size_t TokenCount() const { return token_count_; }
+  void StepToken() override;
   void ResetStreamingState();
 
   OrtValue* GetInput(const char* name) override;
@@ -222,9 +220,6 @@ struct NemotronSpeechState : State {
   int64_t time_step_{0};
   int symbol_step_{0};
   bool need_encoder_run_{false};
-  bool chunk_done_{true};
-  std::vector<int32_t> last_tokens_;
-  size_t token_count_{};  // Total tokens emitted across all chunks
 
   void RunEncoder();
 };
diff --git a/src/models/parakeet.cpp b/src/models/parakeet.cpp
new file mode 100644
index 0000000000..8c68b52169
--- /dev/null
+++ b/src/models/parakeet.cpp
@@ -0,0 +1,600 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+//
+// Parakeet TDT speech recognition model
+//
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <stdexcept>
+
+#include "../generators.h"
+#include "parakeet.h"
+
+namespace Generators {
+
+void ParakeetTdtConfig::PopulateFromConfig(const Config& config) {
+  const auto& enc = config.model.encoder;
+  const auto& dec = config.model.decoder;
+  const auto& m = config.model;
+  const auto& jo = config.model.joiner;
+
+  hidden_dim = enc.hidden_size;
+  num_encoder_layers = enc.num_hidden_layers;
+
+  decoder_lstm_dim = dec.hidden_size;
+  decoder_lstm_layers = dec.num_hidden_layers;
+
+  subsampling_factor = m.subsampling_factor;
+  sample_rate = m.sample_rate;
+  chunk_samples = m.chunk_samples;
+  blank_id = m.blank_id;
+  max_symbols_per_step = m.max_symbols_per_step;
+  left_context_samples = m.left_context_samples;
+  right_context_samples = m.right_context_samples;
+
+  tdt_durations = m.tdt_durations;
+
+  enc_in_audio = enc.inputs.audio_features;
+  enc_out_encoded = enc.outputs.encoder_outputs;
+  enc_in_length = enc.inputs.input_lengths;
+  enc_out_length = enc.outputs.output_lengths;
+
+  join_in_encoder = jo.inputs.encoder_outputs;
+  join_in_decoder = jo.inputs.decoder_outputs;
+  join_out_logits = jo.outputs.logits;
+
+  dec_in_targets = dec.inputs.targets;
+  dec_in_targets_length = dec.inputs.targets_length;
+  dec_in_lstm_hidden_state = dec.inputs.lstm_hidden_state;
+  dec_in_lstm_cell_state = dec.inputs.lstm_cell_state;
+  dec_out_outputs = dec.outputs.outputs;
+  dec_out_outputs_length = dec.outputs.outputs_length;
+  dec_out_lstm_hidden_state = dec.outputs.lstm_hidden_state;
+  dec_out_lstm_cell_state = dec.outputs.lstm_cell_state;
+}
+
+ParakeetTdtModel::ParakeetTdtModel(std::unique_ptr<Config> config, OrtEnv& ort_env)
+    : Model{std::move(config)} {
+  parakeet_config_.PopulateFromConfig(*config_);
+
+  // Generation termination relies on the standard search path comparing the
+  // last emitted token against config.model.eos_token_id. ParakeetTdtState
+  // returns blank_id when finished_, so blank_id must be one of the
+  // configured EOS ids or generator loops will hang.
+  const auto& eos_ids = config_->model.eos_token_id;
+  if (std::find(eos_ids.begin(), eos_ids.end(), parakeet_config_.blank_id) == eos_ids.end()) {
+    throw std::runtime_error(
+        "Parakeet TDT: model.blank_id (" + std::to_string(parakeet_config_.blank_id) +
+        ") must be present in model.eos_token_id so generation terminates correctly.");
+  }
+
+  encoder_session_options_ = OrtSessionOptions::Create();
+  decoder_session_options_ = OrtSessionOptions::Create();
+  joiner_session_options_ = OrtSessionOptions::Create();
+
+  if (config_->model.encoder.session_options.has_value()) {
+    CreateSessionOptionsFromConfig(config_->model.encoder.session_options.value(),
+                                   *encoder_session_options_, true);
+  } else {
+    CreateSessionOptionsFromConfig(config_->model.decoder.session_options,
+                                   *encoder_session_options_, true);
+  }
+  CreateSessionOptionsFromConfig(config_->model.decoder.session_options,
+                                 *decoder_session_options_, true);
+  if (config_->model.joiner.session_options.has_value()) {
+    CreateSessionOptionsFromConfig(config_->model.joiner.session_options.value(),
+                                   *joiner_session_options_, true);
+  } else {
+    CreateSessionOptionsFromConfig(config_->model.decoder.session_options,
+                                   *joiner_session_options_, true);
+  }
+
+  std::string encoder_filename = config_->model.encoder.filename;
+
+  std::string decoder_filename = config_->model.decoder.filename;
+
+  std::string joiner_filename = config_->model.joiner.filename;
+
+  session_encoder_ = CreateSession(ort_env, encoder_filename, encoder_session_options_.get());
+  session_decoder_ = CreateSession(ort_env, decoder_filename, decoder_session_options_.get());
+  session_joiner_ = CreateSession(ort_env, joiner_filename, joiner_session_options_.get());
+
+  session_info_.Add(*session_encoder_);
+  session_info_.Add(*session_decoder_);
+  session_info_.Add(*session_joiner_);
+}
+
+std::unique_ptr<State> ParakeetTdtModel::CreateState(DeviceSpan<int32_t> /*sequence_lengths*/,
+                                                     const GeneratorParams& params) const {
+  return std::make_unique<ParakeetTdtState>(*this, params);
+}
+
+ParakeetEncoderSubState::ParakeetEncoderSubState(const ParakeetTdtModel& model,
+                                                 const GeneratorParams& params)
+    : State{params, model},
+      model_{model},
+      cfg_{model.parakeet_config_} {
+  auto& cpu_allocator = model_.allocator_cpu_;
+
+  // signal_length is a tiny scalar input updated per chunk; allocate once.
+  auto len_shape = std::array<int64_t, 1>{1};
+  signal_length_ = OrtValue::CreateTensor(cpu_allocator, len_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64);
+
+  mel_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.enc_in_audio.c_str());
+  inputs_.push_back(nullptr);
+
+  length_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.enc_in_length.c_str());
+  inputs_.push_back(signal_length_.get());
+
+  output_names_.push_back(cfg_.enc_out_encoded.c_str());
+  outputs_.push_back(nullptr);
+  output_names_.push_back(cfg_.enc_out_length.c_str());
+  outputs_.push_back(nullptr);
+
+  if (model_.config_->model.encoder.run_options.has_value()) {
+    State::SetRunOptions(model_.config_->model.encoder.run_options.value());
+  }
+}
+
+void ParakeetEncoderSubState::SetInputs(OrtValue* mel_tensor, int64_t num_mel_frames) {
+  inputs_[mel_input_idx_] = mel_tensor;
+  *signal_length_->GetTensorMutableData<int64_t>() = num_mel_frames;
+}
+
+DeviceSpan<float> ParakeetEncoderSubState::Run(int /*total_length*/,
+                                               DeviceSpan<int32_t>& /*next_tokens*/,
+                                               DeviceSpan<int32_t> /*next_indices*/) {
+  State::Run(*model_.session_encoder_);
+  return {};
+}
+
+ParakeetDecoderSubState::ParakeetDecoderSubState(const ParakeetTdtModel& model,
+                                                 const GeneratorParams& params)
+    : State{params, model},
+      model_{model},
+      cfg_{model.parakeet_config_} {
+  auto& cpu_allocator = model_.allocator_cpu_;
+
+  auto targets_shape = std::array<int64_t, 2>{1, 1};
+  targets_ = OrtValue::CreateTensor(cpu_allocator, targets_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64);
+  *targets_->GetTensorMutableData<int64_t>() = 0;
+
+  auto tgt_len_shape = std::array<int64_t, 1>{1};
+  targets_length_ = OrtValue::CreateTensor(cpu_allocator, tgt_len_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64);
+  *targets_length_->GetTensorMutableData<int64_t>() = 1;
+
+  ResetLstmState();
+
+  targets_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.dec_in_targets.c_str());
+  inputs_.push_back(targets_.get());
+
+  targets_length_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.dec_in_targets_length.c_str());
+  inputs_.push_back(targets_length_.get());
+
+  state_h_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.dec_in_lstm_hidden_state.c_str());
+  inputs_.push_back(state_h_.get());
+
+  state_c_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.dec_in_lstm_cell_state.c_str());
+  inputs_.push_back(state_c_.get());
+
+  output_names_.push_back(cfg_.dec_out_outputs.c_str());
+  outputs_.push_back(nullptr);
+  output_names_.push_back(cfg_.dec_out_outputs_length.c_str());
+  outputs_.push_back(nullptr);
+  output_names_.push_back(cfg_.dec_out_lstm_hidden_state.c_str());
+  outputs_.push_back(nullptr);
+  output_names_.push_back(cfg_.dec_out_lstm_cell_state.c_str());
+  outputs_.push_back(nullptr);
+
+  if (model_.config_->model.decoder.run_options.has_value()) {
+    State::SetRunOptions(model_.config_->model.decoder.run_options.value());
+  }
+}
+
+void ParakeetDecoderSubState::ResetLstmState() {
+  auto& cpu_allocator = model_.allocator_cpu_;
+  auto state_shape = std::array<int64_t, 3>{cfg_.decoder_lstm_layers, 1, cfg_.decoder_lstm_dim};
+  state_h_ = OrtValue::CreateTensor(cpu_allocator, state_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
+  std::memset(state_h_->GetTensorMutableData<float>(), 0,
+              static_cast<size_t>(cfg_.decoder_lstm_layers) * cfg_.decoder_lstm_dim * sizeof(float));
+  state_c_ = OrtValue::CreateTensor(cpu_allocator, state_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
+  std::memset(state_c_->GetTensorMutableData<float>(), 0,
+              static_cast<size_t>(cfg_.decoder_lstm_layers) * cfg_.decoder_lstm_dim * sizeof(float));
+  // input slots may not exist yet during ctor; if they do, refresh them.
+  if (inputs_.size() > state_c_input_idx_) {
+    inputs_[state_h_input_idx_] = state_h_.get();
+    inputs_[state_c_input_idx_] = state_c_.get();
+  }
+}
+
+void ParakeetDecoderSubState::StepWithToken(int32_t token_id) {
+  *targets_->GetTensorMutableData<int64_t>() = token_id;
+
+  DeviceSpan<int32_t> dummy_tokens;
+  State::Run(*model_.session_decoder_);
+
+  state_h_.reset(outputs_[2]);
+  outputs_[2] = nullptr;
+  state_c_.reset(outputs_[3]);
+  outputs_[3] = nullptr;
+  inputs_[state_h_input_idx_] = state_h_.get();
+  inputs_[state_c_input_idx_] = state_c_.get();
+}
+
+std::unique_ptr<OrtValue> ParakeetDecoderSubState::TakeDecoderOutput() {
+  std::unique_ptr<OrtValue> out(outputs_[0]);
+  outputs_[0] = nullptr;
+  if (outputs_[1] != nullptr) {
+    std::unique_ptr<OrtValue> _(outputs_[1]);
+    outputs_[1] = nullptr;
+  }
+  return out;
+}
+
+DeviceSpan<float> ParakeetDecoderSubState::Run(int /*total_length*/,
+                                               DeviceSpan<int32_t>& /*next_tokens*/,
+                                               DeviceSpan<int32_t> /*next_indices*/) {
+  State::Run(*model_.session_decoder_);
+  return {};
+}
+
+ParakeetJoinerSubState::ParakeetJoinerSubState(const ParakeetTdtModel& model,
+                                               const GeneratorParams& params)
+    : State{params, model},
+      model_{model},
+      cfg_{model.parakeet_config_} {
+  encoder_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.join_in_encoder.c_str());
+  inputs_.push_back(nullptr);
+
+  decoder_input_idx_ = inputs_.size();
+  input_names_.push_back(cfg_.join_in_decoder.c_str());
+  inputs_.push_back(nullptr);
+
+  output_names_.push_back(cfg_.join_out_logits.c_str());
+  outputs_.push_back(nullptr);
+
+  if (model_.config_->model.joiner.run_options.has_value()) {
+    State::SetRunOptions(model_.config_->model.joiner.run_options.value());
+  }
+}
+
+void ParakeetJoinerSubState::SetInputFrames(OrtValue* encoder_frame, OrtValue* decoder_frame) {
+  inputs_[encoder_input_idx_] = encoder_frame;
+  inputs_[decoder_input_idx_] = decoder_frame;
+}
+
+DeviceSpan<float> ParakeetJoinerSubState::Run(int /*total_length*/,
+                                              DeviceSpan<int32_t>& /*next_tokens*/,
+                                              DeviceSpan<int32_t> /*next_indices*/) {
+  State::Run(*model_.session_joiner_);
+  return {};
+}
+
+ParakeetTdtState::ParakeetTdtState(const ParakeetTdtModel& model, const GeneratorParams& params)
+    : TransducerState{params, model},
+      model_{model},
+      cfg_{model.parakeet_config_} {
+  encoder_state_ = std::make_unique<ParakeetEncoderSubState>(model, params);
+  decoder_state_ = std::make_unique<ParakeetDecoderSubState>(model, params);
+  joiner_state_ = std::make_unique<ParakeetJoinerSubState>(model, params);
+}
+
+void ParakeetTdtState::InitializeDecoderState() {
+  decoder_state_->StepWithToken(static_cast<int32_t>(cfg_.blank_id));
+  decoder_output_ = decoder_state_->TakeDecoderOutput();
+}
+
+void ParakeetTdtState::EncodeNextChunk() {
+  const auto& m = model_.config_->model;
+  const int hop = m.hop_length;
+  const int sub = cfg_.subsampling_factor;
+  const int num_mels = m.num_mels;
+  const size_t chunk_sz = static_cast<size_t>(cfg_.chunk_samples);
+  const size_t left_samples = static_cast<size_t>(cfg_.left_context_samples);
+  const size_t right_samples = static_cast<size_t>(cfg_.right_context_samples);
+
+  // Window in audio-sample space (preserved so the mel-frame slice matches
+  // what we'd get if the encoder were fed the same audio range directly).
+  size_t chunk_start = next_chunk_start_;
+  size_t chunk_end = std::min(chunk_start + chunk_sz, total_audio_);
+  bool is_last = (chunk_end >= total_audio_);
+  size_t win_left = (chunk_start > left_samples) ? (chunk_start - left_samples) : 0;
+  size_t win_right = std::min(chunk_end + right_samples, total_audio_);
+
+  // Convert window + chunk boundaries from sample-space to mel-frame space.
+  const int64_t win_left_mel = static_cast<int64_t>(win_left / hop);
+  const int64_t win_right_mel = std::min<int64_t>(win_right / hop, total_mel_frames_);
+  const int64_t num_mel_frames = win_right_mel - win_left_mel;
+
+  next_chunk_start_ = chunk_end;
+  if (is_last) finished_ = true;
+
+  if (num_mel_frames <= 0) {
+    current_encoder_cpu_.clear();
+    current_enc_time_ = 0;
+    current_t_ = 0;
+    current_end_frame_ = 0;
+    return;
+  }
+
+  auto& cpu_allocator = model_.allocator_cpu_;
+
+  // Slice the cached, globally-normalized mel ([num_mels, T_full]) into a
+  // contiguous [1, num_mels, num_mel_frames] CPU tensor. CUDA EP will copy
+  // to device internally if it needs to.
+  auto signal_shape = std::array<int64_t, 3>{1, num_mels, num_mel_frames};
+  auto processed_signal = OrtValue::CreateTensor(cpu_allocator, signal_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
+  float* dst = processed_signal->GetTensorMutableData<float>();
+  for (int b = 0; b < num_mels; ++b) {
+    const float* src = full_mel_.data() + static_cast<size_t>(b) * total_mel_frames_ + win_left_mel;
+    std::memcpy(dst + static_cast<size_t>(b) * num_mel_frames, src,
+                static_cast<size_t>(num_mel_frames) * sizeof(float));
+  }
+
+  encoder_state_->SetInputs(processed_signal.get(), num_mel_frames);
+  DeviceSpan<int32_t> dummy_tokens;
+  encoder_state_->Run(0, dummy_tokens, {});
+
+  // Take ownership of the encoder outputs so the sub-state's slots are reset
+  // for the next chunk (whose shapes differ).
+  std::unique_ptr<OrtValue> enc_output(encoder_state_->outputs_[0]);
+  encoder_state_->outputs_[0] = nullptr;
+  std::unique_ptr<OrtValue> enc_length(encoder_state_->outputs_[1]);
+  encoder_state_->outputs_[1] = nullptr;
+
+  // Encoder output: read directly. Tensors that ORT placed on CUDA we'd need
+  // to copy back via the session's own allocator; with our CPU-resident inputs
+  // ORT typically routes outputs back to CPU via MemcpyToHost. Handle both
+  // just in case.
+  auto enc_shape = enc_output->GetTensorTypeAndShapeInfo()->GetShape();
+  current_enc_time_ = enc_shape[2];
+  size_t enc_elems = 1;
+  for (auto d : enc_shape) enc_elems *= static_cast<size_t>(d);
+
+  auto& enc_mi = enc_output->GetTensorMemoryInfo();
+  bool enc_on_cpu = (enc_mi.GetDeviceType() == OrtMemoryInfoDeviceType_CPU);
+  if (enc_on_cpu) {
+    const float* src = enc_output->GetTensorData<float>();
+    current_encoder_cpu_.assign(src, src + enc_elems);
+  } else {
+    auto& inference_device = *model_.p_device_inputs_;
+    auto enc_span = WrapTensor<float>(inference_device, *enc_output);
+    auto enc_cpu = enc_span.CopyDeviceToCpu();
+    current_encoder_cpu_.assign(enc_cpu.begin(), enc_cpu.end());
+  }
+
+  auto& enc_len_mi = enc_length->GetTensorMemoryInfo();
+  bool enc_len_on_cpu = (enc_len_mi.GetDeviceType() == OrtMemoryInfoDeviceType_CPU);
+  int64_t enc_total;
+  if (enc_len_on_cpu) {
+    enc_total = enc_length->GetTensorData<int64_t>()[0];
+  } else {
+    auto& inference_device = *model_.p_device_inputs_;
+    auto enc_len_span = WrapTensor<int64_t>(inference_device, *enc_length);
+    enc_total = enc_len_span.CopyDeviceToCpu()[0];
+  }
+
+  // Map chunk start/end (sample-space) to encoder-frame indices within this
+  // window. encoder_frame_index = mel_frame_index / subsampling_factor.
+  // Drop left-context frames; on the last chunk consume every remaining
+  // encoder frame (no right-context to trim).
+  const int64_t chunk_start_mel = static_cast<int64_t>(chunk_start / hop) - win_left_mel;
+  const int64_t chunk_end_mel = static_cast<int64_t>(chunk_end / hop) - win_left_mel;
+  int64_t decode_start = chunk_start_mel / sub;
+  int64_t decode_end = is_last ? enc_total : std::min(chunk_end_mel / sub, enc_total);
+  if (decode_end < decode_start) decode_end = decode_start;  // last-chunk rounding
+
+  current_t_ = decode_start;
+  current_end_frame_ = decode_end;
+  symbols_this_frame_ = 0;
+}
+
+int32_t ParakeetTdtState::EmitNextToken() {
+  auto& cpu_allocator = model_.allocator_cpu_;
+
+  const int num_durations = static_cast<int>(cfg_.tdt_durations.size());
+  const int blank_id = cfg_.blank_id;
+  const int max_sym = cfg_.max_symbols_per_step;
+  const int64_t hidden_dim = cfg_.hidden_dim;
+  const int64_t dec_dim = cfg_.decoder_lstm_dim;
+
+  while (true) {
+    while (current_t_ >= current_end_frame_) {
+      if (finished_) return static_cast<int32_t>(blank_id);  // eos
+      EncodeNextChunk();
+    }
+
+    // Build encoder_frame [1, 1, hidden_dim] on CPU from the mirrored
+    // encoder output. Allocated once, reused.
+    const float* enc_data = current_encoder_cpu_.data();
+    const int64_t enc_time = current_enc_time_;
+    auto frame_shape = std::array<int64_t, 3>{1, 1, hidden_dim};
+    if (!encoder_frame_) {
+      encoder_frame_ = OrtValue::CreateTensor(cpu_allocator, frame_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
+    }
+    float* enc_frame_data = encoder_frame_->GetTensorMutableData<float>();
+    for (int64_t d = 0; d < hidden_dim; ++d) {
+      enc_frame_data[d] = enc_data[d * enc_time + current_t_];
+    }
+
+    // Decoder output is [1, dec_dim, 1]; reshape to [1, 1, dec_dim] for
+    // the joiner via a plain memcpy (layout is identical for contiguous data).
+    auto dec_shape = std::array<int64_t, 3>{1, 1, dec_dim};
+    if (!decoder_frame_) {
+      decoder_frame_ = OrtValue::CreateTensor(cpu_allocator, dec_shape, ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
+    }
+    const float* dec_src = decoder_output_->GetTensorData<float>();
+    std::memcpy(decoder_frame_->GetTensorMutableData<float>(), dec_src,
+                static_cast<size_t>(dec_dim) * sizeof(float));
+
+    joiner_state_->SetInputFrames(encoder_frame_.get(), decoder_frame_.get());
+    DeviceSpan<int32_t> dummy_tokens;
+    joiner_state_->Run(0, dummy_tokens, {});
+
+    OrtValue* join_logits = joiner_state_->outputs_[0];
+    const float* logits_data;
+    std::vector<float> logits_buf;
+    auto& mi_jout = join_logits->GetTensorMemoryInfo();
+    if (mi_jout.GetDeviceType() == OrtMemoryInfoDeviceType_CPU) {
+      logits_data = join_logits->GetTensorData<float>();
+    } else {
+      auto& inference_device = *model_.p_device_inputs_;
+      auto logits_span = WrapTensor<float>(inference_device, *join_logits);
+      auto logits_cpu = logits_span.CopyDeviceToCpu();
+      logits_buf.assign(logits_cpu.begin(), logits_cpu.end());
+      logits_data = logits_buf.data();
+    }
+
+    // Joiner output layout: [token_logits (vocab_size) | duration_logits].
+    // Token argmax covers all vocab indices; blank_id is one of them.
+    const int num_tok_logits = model_.config_->model.vocab_size;
+    int best_token = 0;
+    float best_score = logits_data[0];
+    for (int i = 1; i < num_tok_logits; ++i) {
+      if (logits_data[i] > best_score) {
+        best_score = logits_data[i];
+        best_token = i;
+      }
+    }
+
+    // Duration argmax. When the predicted token is blank, forbid duration
+    // index 0: (blank, 0) emits nothing AND doesn't advance current_t_, and
+    // since symbols_this_frame_ is only incremented on a non-blank emit, the
+    // max_symbols_per_step escape never fires either. The loop would hang on
+    // the same frame forever, re-running the joiner with identical inputs.
+    // Forcing dur_idx >= 1 on blank guarantees forward progress.
+    int dur_idx = 0;
+    {
+      const int dur_off = num_tok_logits;
+      const int start_i = (best_token == blank_id) ? 1 : 0;
+      float best_dur_score = -std::numeric_limits<float>::infinity();
+      for (int i = start_i; i < num_durations; ++i) {
+        if (logits_data[dur_off + i] > best_dur_score) {
+          best_dur_score = logits_data[dur_off + i];
+          dur_idx = i;
+        }
+      }
+    }
+    // Map the duration argmax index to an actual encoder-frame skip count via
+    // the TDT duration table (e.g. v3 uses [0,1,2,3,4], so the lookup is the
+    // identity here, but the table format supports non-contiguous schedules
+    // like [0,1,2,4,8]).
+    int skip = cfg_.tdt_durations[dur_idx];
+
+    bool emitted = false;
+    int32_t emitted_token = 0;
+    if (best_token != blank_id) {
+      symbols_this_frame_++;
+      emitted_token = static_cast<int32_t>(best_token);
+      emitted = true;
+      decoder_state_->StepWithToken(emitted_token);
+      decoder_output_ = decoder_state_->TakeDecoderOutput();
+    }
+
+    // Frame-advance bookkeeping. Two cases:
+    //  - skip > 0: model voted to leave this frame, so reset the per-frame
+    //    symbol counter for the next frame.
+    //  - skip == 0: model wants to stay (only possible on a non-blank emit
+    //    here, since blank+0 is forbidden above). Bump-counter logic already
+    //    incremented symbols_this_frame_; if we've hit the cap, force a
+    //    one-frame skip to escape runaway emission at this frame.
+    if (skip > 0) {
+      symbols_this_frame_ = 0;
+    } else if (symbols_this_frame_ >= max_sym) {
+      symbols_this_frame_ = 0;
+      skip = 1;
+    }
+    current_t_ += skip;
+
+    if (emitted) return emitted_token;
+    // Pure-blank frame: nothing to return, loop and process the next frame.
+  }
+}
+
+void ParakeetTdtState::SetExtraInputs(const std::vector<ExtraInput>& extra_inputs) {
+  if (mel_loaded_) return;
+
+  // Locate the pre-computed mel-features tensor produced by ParakeetTdtProcessor.
+  // Expected shape: [1, num_mels, total_frames], already globally normalized.
+  const Tensor* mel_tensor = nullptr;
+  for (const auto& ei : extra_inputs) {
+    if (ei.name == Config::Defaults::AudioFeaturesName) {
+      mel_tensor = ei.tensor.get();
+      break;
+    }
+  }
+  if (!mel_tensor) {
+    throw std::runtime_error("ParakeetTdtState::SetExtraInputs: 'audio_features' input is missing.");
+  }
+
+  auto info = mel_tensor->ort_tensor_->GetTensorTypeAndShapeInfo();
+  auto shape = info->GetShape();
+  if (shape.size() != 3 || shape[0] != 1) {
+    throw std::runtime_error("ParakeetTdtState::SetExtraInputs: audio_features must have shape [1, num_mels, T].");
+  }
+  const int num_mels = static_cast<int>(shape[1]);
+  total_mel_frames_ = static_cast<int>(shape[2]);
+  if (num_mels != model_.config_->model.num_mels) {
+    throw std::runtime_error("ParakeetTdtState::SetExtraInputs: mel num_mels mismatch with model config.");
+  }
+
+  const float* mel_src = mel_tensor->ort_tensor_->GetTensorData<float>();
+  full_mel_.assign(mel_src,
+                   mel_src + static_cast<size_t>(num_mels) * total_mel_frames_);
+
+  // Map mel-frame extent back to audio-sample space; this is what the chunk
+  // / left-context / right-context windows are expressed in.
+  total_audio_ = static_cast<size_t>(total_mel_frames_) * model_.config_->model.hop_length;
+  next_chunk_start_ = 0;
+  finished_ = (total_audio_ == 0);
+  mel_loaded_ = true;
+}
+
+DeviceSpan<float> ParakeetTdtState::Run(int /*total_length*/,
+                                        DeviceSpan<int32_t>& /*next_tokens*/,
+                                        DeviceSpan<int32_t> /*next_indices*/) {
+  throw std::runtime_error(
+      "ParakeetTdtState::Run() is not used directly. "
+      "TDT models bypass the standard search/logits pipeline; use "
+      "Generator::GenerateNextToken() with set_inputs.");
+}
+
+void ParakeetTdtState::StepToken() {
+  // First call: prime the decoder LSTM and encode the first chunk.
+  // Subsequent calls advance the TDT loop by exactly one emitted token (or
+  // mark the chunk done when the audio is fully consumed).
+  if (!initialized_) {
+    InitializeDecoderState();
+    EncodeNextChunk();
+    initialized_ = true;
+  }
+
+  last_tokens_.clear();
+  const int blank_id = cfg_.blank_id;
+  int32_t next_token = EmitNextToken();
+
+  // EmitNextToken returns blank_id as the end-of-stream marker (set when the
+  // trailing chunk is consumed). The framework search would normally treat
+  // blank as a real EOS token; here we just stop emitting and let the
+  // generator surface this via IsChunkDone().
+  if (next_token == blank_id) {
+    chunk_done_ = true;
+    return;
+  }
+
+  all_tokens_.push_back(next_token);
+  last_tokens_.push_back(next_token);
+}
+
+}  // namespace Generators
diff --git a/src/models/parakeet.h b/src/models/parakeet.h
new file mode 100644
index 0000000000..d7877f4ae2
--- /dev/null
+++ b/src/models/parakeet.h
@@ -0,0 +1,248 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+//
+// Parakeet TDT speech recognition model.
+//
+// Mirrors the standard batch model structure (Model + State subclasses) so it can
+// be driven by the standard Generator pipeline:
+//
+//     model = og.Model(config)
+//     processor = model.create_multimodal_processor()
+//     audios = og.Audios.open("audio.wav")
+//     inputs = processor("", audios=audios)
+//     params = og.GeneratorParams(model)
+//     generator = og.Generator(model, params)
+//     generator.set_inputs(inputs)
+//     while not generator.is_done():
+//         generator.generate_next_token()
+//     transcription = processor.decode(generator.get_sequence(0))
+//
+// Internally the encoder is fed one chunk at a time with left + right
+// context (matching the original NeMo streaming reference). The window
+// length varies across chunks: the first chunk is clipped on the left
+// (no past context available), the last chunk is clipped on the right
+// (no more audio), and middle chunks span the full
+// `left_context + chunk + right_context` extent. The encoder is therefore
+// exported with a dynamic time dimension and is given a `signal_length`
+// input each call. The TDT (Token-and-Duration Transducer) decoder runs
+// against the encoder's chunk-proper frames and emits one symbol id per
+// call to StepToken().
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "model.h"
+#include "transducer_state.h"
+
+namespace Generators {
+
+struct ParakeetTdtConfig {
+  // Encoder dimensions
+  int hidden_dim{};
+  int num_encoder_layers{};
+
+  // Decoder LSTM dimensions
+  int decoder_lstm_dim{};
+  int decoder_lstm_layers{};
+
+  // Vocabulary
+  int blank_id{};
+
+  // Streaming chunk config
+  int sample_rate{};
+  int chunk_samples{};
+  int subsampling_factor{};
+  int max_symbols_per_step{};
+  int left_context_samples{};
+  int right_context_samples{};
+
+  // TDT parameters
+  std::vector<int> tdt_durations;
+
+  // Encoder I/O names
+  std::string enc_in_audio;
+  std::string enc_in_length;
+  std::string enc_out_encoded;
+  std::string enc_out_length;
+
+  // Decoder (prediction network) I/O names
+  std::string dec_in_targets;
+  std::string dec_in_targets_length;
+  std::string dec_in_lstm_hidden_state;
+  std::string dec_in_lstm_cell_state;
+  std::string dec_out_outputs;
+  std::string dec_out_outputs_length;
+  std::string dec_out_lstm_hidden_state;
+  std::string dec_out_lstm_cell_state;
+
+  // Joiner I/O names
+  std::string join_in_encoder;
+  std::string join_in_decoder;
+  std::string join_out_logits;
+
+  void PopulateFromConfig(const Config& config);
+};
+
+struct ParakeetTdtModel : Model {
+  ParakeetTdtModel(std::unique_ptr<Config> config, OrtEnv& ort_env);
+
+  std::unique_ptr<State> CreateState(DeviceSpan<int32_t> sequence_lengths,
+                                     const GeneratorParams& params) const override;
+
+  std::unique_ptr<OrtSession> session_encoder_;
+  std::unique_ptr<OrtSession> session_decoder_;
+  std::unique_ptr<OrtSession> session_joiner_;
+
+  std::unique_ptr<OrtSessionOptions> encoder_session_options_;
+  std::unique_ptr<OrtSessionOptions> decoder_session_options_;
+  std::unique_ptr<OrtSessionOptions> joiner_session_options_;
+
+  ParakeetTdtConfig parakeet_config_;
+};
+
+struct ParakeetEncoderSubState : State {
+  ParakeetEncoderSubState(const ParakeetTdtModel& model, const GeneratorParams& params);
+
+  void SetInputs(OrtValue* mel_tensor, int64_t num_mel_frames);
+
+  DeviceSpan<float> Run(int total_length,
+                        DeviceSpan<int32_t>& next_tokens,
+                        DeviceSpan<int32_t> next_indices) override;
+
+ private:
+  const ParakeetTdtModel& model_;
+  const ParakeetTdtConfig& cfg_;
+  std::unique_ptr<OrtValue> signal_length_;
+  size_t mel_input_idx_{};
+  size_t length_input_idx_{};
+};
+
+struct ParakeetDecoderSubState : State {
+  ParakeetDecoderSubState(const ParakeetTdtModel& model, const GeneratorParams& params);
+
+  void ResetLstmState();
+
+  void StepWithToken(int32_t token_id);
+
+  std::unique_ptr<OrtValue> TakeDecoderOutput();
+
+  DeviceSpan<float> Run(int total_length,
+                        DeviceSpan<int32_t>& next_tokens,
+                        DeviceSpan<int32_t> next_indices) override;
+
+ private:
+  const ParakeetTdtModel& model_;
+  const ParakeetTdtConfig& cfg_;
+  std::unique_ptr<OrtValue> targets_;         // [1, 1] int64
+  std::unique_ptr<OrtValue> targets_length_;  // [1] int64, always 1
+  std::unique_ptr<OrtValue> state_h_;         // [layers, 1, dim] float
+  std::unique_ptr<OrtValue> state_c_;         // [layers, 1, dim] float
+  size_t targets_input_idx_{};
+  size_t targets_length_input_idx_{};
+  size_t state_h_input_idx_{};
+  size_t state_c_input_idx_{};
+};
+
+struct ParakeetJoinerSubState : State {
+  ParakeetJoinerSubState(const ParakeetTdtModel& model, const GeneratorParams& params);
+
+  void SetInputFrames(OrtValue* encoder_frame, OrtValue* decoder_frame);
+
+  DeviceSpan<float> Run(int total_length,
+                        DeviceSpan<int32_t>& next_tokens,
+                        DeviceSpan<int32_t> next_indices) override;
+
+ private:
+  const ParakeetTdtModel& model_;
+  const ParakeetTdtConfig& cfg_;
+  size_t encoder_input_idx_{};
+  size_t decoder_input_idx_{};
+};
+
+// State driving the streaming TDT decoder.
+
+struct ParakeetTdtState : TransducerState {
+  ParakeetTdtState(const ParakeetTdtModel& model, const GeneratorParams& params);
+
+  void SetExtraInputs(const std::vector<ExtraInput>& extra_inputs) override;
+
+  // TDT bypasses the search/logits pipeline entirely; the orchestrator state
+  // has no meaningful Run() and instead exposes StepToken() below.
+  DeviceSpan<float> Run(int total_length,
+                        DeviceSpan<int32_t>& next_tokens,
+                        DeviceSpan<int32_t> next_indices) override;
+
+  // Run the TDT loop until a non-blank token is emitted, append it to the
+  // accumulated transcript, and expose it via GetStepTokens(). Sets the
+  // chunk-done flag when the audio has been fully consumed.
+  void StepToken() override;
+
+ private:
+  // Encode the next audio chunk and update current_encoder_ / current_t_ /
+  // current_end_frame_. Sets finished_ when the trailing chunk is encoded.
+  void EncodeNextChunk();
+  // Run the TDT loop until a non-blank token is emitted, or return blank_id
+  // (== eos) when the whole utterance has been consumed.
+  int32_t EmitNextToken();
+  void InitializeDecoderState();
+
+  const ParakeetTdtModel& model_;
+  ParakeetTdtConfig cfg_;
+
+  // Sub-states delegating to the three ORT sessions through the standard
+  // State::Run(session) path
+  std::unique_ptr<ParakeetEncoderSubState> encoder_state_;
+  std::unique_ptr<ParakeetDecoderSubState> decoder_state_;
+  std::unique_ptr<ParakeetJoinerSubState> joiner_state_;
+
+  // Most recent decoder output (kept here, since the joiner consumes it on
+  // every step but the decoder only runs on non-blank emits). Reshaped on
+  // the fly into decoder_frame_ before each joiner call.
+  std::unique_ptr<OrtValue> decoder_output_;
+
+  std::vector<float> full_mel_;
+  int total_mel_frames_{0};
+  bool mel_loaded_{false};
+
+  // Total audio length, in samples (set once when the mel arrives, since
+  // total_audio = total_mel_frames_ * hop_length conceptually).
+  size_t total_audio_{0};
+  // Start of the next chunk-proper region, in audio-sample space. Advances
+  // by chunk_samples_ each EncodeNextChunk() call (clamped at total_audio_).
+  size_t next_chunk_start_{0};
+  // True once the trailing chunk has been encoded; no more encoder runs.
+  bool finished_{false};
+  // True after the decoder LSTM state has been seeded with the SOS token
+  // (lazy init on the first StepToken() call).
+  bool initialized_{false};
+
+  // Current encoder window (output of the most recent encoder run), staged
+  // on CPU for per-frame slicing into the joiner. The encoder runs on
+  // chunk + left context + right context, so the underlying tensor
+  // [1, hidden_dim, T'] covers all three regions. The three indices below
+  // carve out only the chunk-proper region for decoding; the context frames
+  // exist so the encoder has enough receptive field at chunk boundaries.
+  //
+  //   encoder frames:  0 ........ a ........ b ........ T'
+  //                    └─ left ──┘└── chunk ─┘└─ right ─┘
+  //                                ↑          ↑          ↑
+  //                            current_t_  current_end_  current_enc_time_
+  //                            (start)      _frame_       (= T')
+  std::vector<float> current_encoder_cpu_;  // [hidden_dim, T'] flattened
+  int64_t current_enc_time_{0};
+  int64_t current_t_{0};
+  int64_t current_end_frame_{0};
+  int symbols_this_frame_{0};
+
+  // Per-step joiner inputs, allocated lazily on the first decoding step and
+  // reused across every subsequent step to avoid per-frame allocator churn.
+  // Shapes are fixed: encoder_frame_ = [1, 1, encoder_hidden_dim],
+  // decoder_frame_ = [1, 1, decoder_lstm_dim].
+  std::unique_ptr<OrtValue> encoder_frame_;
+  std::unique_ptr<OrtValue> decoder_frame_;
+};
+
+}  // namespace Generators
diff --git a/src/models/parakeet_processor.cpp b/src/models/parakeet_processor.cpp
new file mode 100644
index 0000000000..94805d4ab1
--- /dev/null
+++ b/src/models/parakeet_processor.cpp
@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "../generators.h"
+#include "model.h"
+#include "parakeet_processor.h"
+#include "runner.hpp"
+#include "c_api_utils.hpp"
+#include "nemo_speech_features.hpp"
+#include "nemo_mel_spectrogram.h"
+
+namespace Generators {
+
+ParakeetTdtProcessor::ParakeetTdtProcessor(Config& config, const SessionInfo& /*session_info*/)
+    : config_{config} {}
+
+std::unique_ptr<NamedTensors> ParakeetTdtProcessor::Process(const Tokenizer& /*tokenizer*/,
+                                                            const Payload& payload) const {
+  const auto& m = config_.model;
+  const auto* audios = payload.audios;
+  if (!audios || !audios->audios_) {
+    throw std::runtime_error("ParakeetTdtProcessor::Process: no audio provided.");
+  }
+  if (audios->num_audios_ != 1) {
+    throw std::runtime_error(
+        "ParakeetTdtProcessor currently supports a single audio clip per call. Got: " +
+        std::to_string(audios->num_audios_));
+  }
+
+  Ort::Allocator& allocator{Ort::Allocator::GetWithDefaultOptions()};
+  auto named_tensors = std::make_unique<NamedTensors>();
+
+  // 1. Decode audio file to float32 mono PCM at the model's sample rate with downmixing.
+  ort_extensions::OrtxObjectPtr<OrtxTensorResult> decoded;
+  CheckResult(OrtxDecodeAudio(audios->audios_.get(), 0,
+                              static_cast<int64_t>(m.sample_rate),
+                              /*stereo_to_mono=*/1,
+                              decoded.ToBeAssigned()));
+
+  ort_extensions::OrtxObjectPtr<OrtxTensor> pcm_tensor;
+  CheckResult(OrtxTensorResultGetAt(decoded.get(), 0, pcm_tensor.ToBeAssigned()));
+
+  const float* pcm_data{};
+  const int64_t* pcm_shape{};
+  size_t pcm_dims = 0;
+  CheckResult(OrtxGetTensorData(pcm_tensor.get(), reinterpret_cast<const void**>(&pcm_data),
+                                &pcm_shape, &pcm_dims));
+
+  int64_t num_samples = 0;
+  if (pcm_dims == 1) {
+    num_samples = pcm_shape[0];
+  } else if (pcm_dims == 2) {
+    num_samples = pcm_shape[1];
+  } else {
+    throw std::runtime_error("Unexpected PCM tensor rank: " + std::to_string(pcm_dims));
+  }
+
+  // 2. Full-utterance mel calculation.
+  nemo_mel::NemoMelConfig mel_cfg{};
+  mel_cfg.num_mels = m.num_mels;
+  mel_cfg.fft_size = m.fft_size;
+  mel_cfg.hop_length = m.hop_length;
+  mel_cfg.win_length = m.win_length;
+  mel_cfg.sample_rate = m.sample_rate;
+  mel_cfg.preemph = m.preemph;
+  mel_cfg.log_eps = m.log_eps;
+
+  nemo_mel::NemoStreamingMelExtractor mel_extractor(mel_cfg);
+  auto [mel_data, num_frames] = mel_extractor.Process(pcm_data, static_cast<size_t>(num_samples));
+  if (num_frames <= 0) {
+    throw std::runtime_error("ParakeetTdtProcessor: audio is too short to produce mel frames.");
+  }
+
+  // 3. Per-feature mean/std normalization (NeMo `normalize_batch`).
+  ort_extensions::PerFeatureNormalize norm_kernel;
+  ort_extensions::AttrDict norm_attrs{
+      {"eps", static_cast<double>(m.norm_eps)},
+      {"feature_first", int64_t{1}},
+  };
+  if (auto status = norm_kernel.Init(norm_attrs); !status.IsOk()) {
+    throw std::runtime_error(std::string("PerFeatureNormalize::Init failed: ") + status.Message());
+  }
+
+  std::vector<int64_t> mel_shape{m.num_mels, static_cast<int64_t>(num_frames)};
+  ortc::Tensor<float> norm_in(mel_shape, mel_data.data());
+  ortc::Tensor<float> norm_out(&ort_extensions::CppAllocator::Instance());
+  if (auto status = norm_kernel.Compute(norm_in, norm_out); !status.IsOk()) {
+    throw std::runtime_error(std::string("PerFeatureNormalize::Compute failed: ") + status.Message());
+  }
+
+  // 4. Package the normalized mel as the model input tensor.
+  auto mel_value = OrtValue::CreateTensor<float>(
+      allocator, std::vector<int64_t>{1, m.num_mels, static_cast<int64_t>(num_frames)});
+  std::memcpy(mel_value->GetTensorMutableData<float>(), norm_out.Data(),
+              static_cast<size_t>(m.num_mels) * num_frames * sizeof(float));
+  named_tensors->emplace(std::string(Config::Defaults::AudioFeaturesName),
+                         std::make_shared<Tensor>(std::move(mel_value)));
+
+  return named_tensors;
+}
+
+}  // namespace Generators
diff --git a/src/models/parakeet_processor.h b/src/models/parakeet_processor.h
new file mode 100644
index 0000000000..2926c76e7c
--- /dev/null
+++ b/src/models/parakeet_processor.h
@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+//
+// ParakeetTdtProcessor — decodes the user-provided audio and computes the
+// full mel-spectrogram (with NeMo-style per-feature normalization).
+//
+// Outputs in the NamedTensors map:
+//   * "audio_features" : float32 [1, num_mels, total_frames] — globally
+//     mean/std normalized.
+
+#pragma once
+
+#include "ortx_cpp_helper.h"
+#include "processor.h"
+
+namespace Generators {
+
+struct ParakeetTdtProcessor : Processor {
+  ParakeetTdtProcessor(Config& config, const SessionInfo& session_info);
+
+  ParakeetTdtProcessor() = delete;
+  ParakeetTdtProcessor(const ParakeetTdtProcessor&) = delete;
+  ParakeetTdtProcessor& operator=(const ParakeetTdtProcessor&) = delete;
+
+  std::unique_ptr<NamedTensors> Process(const Tokenizer& tokenizer,
+                                        const Payload& payload) const override;
+
+ private:
+  const Config& config_;
+};
+
+}  // namespace Generators
diff --git a/src/models/transducer_state.h b/src/models/transducer_state.h
new file mode 100644
index 0000000000..3fbfc62bc5
--- /dev/null
+++ b/src/models/transducer_state.h
@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+//
+// Shared base class for streaming transducer models (RNNT, TDT).
+//
+// Transducer models bypass the standard search/logits pipeline: each call
+// to StepToken() advances the decoder by one emitted symbol and appends it
+// to the running transcript.
+
+#pragma once
+
+#include <cstdint>
+#include <span>
+#include <vector>
+
+#include "model.h"
+
+namespace Generators {
+
+struct TransducerState : State {
+  using State::State;
+
+  // Advance the decoder by exactly one emitted (non-blank) symbol when
+  // possible. Implementations must:
+  //   * clear last_tokens_ at entry,
+  //   * append every emitted token to both last_tokens_ and all_tokens_,
+  //   * set chunk_done_ = true when the current chunk/utterance is fully
+  //     consumed.
+  virtual void StepToken() = 0;
+
+  bool IsChunkDone() const { return chunk_done_; }
+  std::span<const int32_t> GetStepTokens() const { return last_tokens_; }
+  std::span<const int32_t> GetAllTokens() const { return all_tokens_; }
+  size_t TokenCount() const { return all_tokens_.size(); }
+
+ protected:
+  // Full transcript accumulated across all StepToken() calls (and chunks).
+  std::vector<int32_t> all_tokens_;
+  // Tokens emitted by the most recent StepToken() call.
+  std::vector<int32_t> last_tokens_;
+  // Set to true when the current chunk has been fully consumed.
+  bool chunk_done_{false};
+};
+
+}  // namespace Generators
diff --git a/src/ort_genai_c.cpp b/src/ort_genai_c.cpp
index 3a0156098d..3ea17eaca7 100644
--- a/src/ort_genai_c.cpp
+++ b/src/ort_genai_c.cpp
@@ -15,6 +15,7 @@
 #include "engine/engine.h"
 #include "models/streaming_processor.h"
 #include "models/nemotron_speech.h"
+#include "models/parakeet.h"
 #include "models/silero_vad.h"
 
 namespace Generators {
@@ -481,9 +482,10 @@ OgaResult* OGA_API_CALL OgaGenerator_GenerateNextToken(OgaGenerator* generator)
 
 OgaResult* OGA_API_CALL OgaGenerator_GetNextTokens(const OgaGenerator* generator, const int32_t** out, size_t* out_count) {
   OGA_TRY
-  // For RNNT models, search_ is not used; return tokens from last StepToken
-  if (auto* speech_state = dynamic_cast<Generators::NemotronSpeechState*>(generator->state_.get())) {
-    auto tokens = speech_state->GetStepTokens();
+  // Transducer models (RNNT, TDT) bypass the standard search; return tokens
+  // emitted by the most recent StepToken() call.
+  if (auto* transducer = dynamic_cast<Generators::TransducerState*>(generator->state_.get())) {
+    auto tokens = transducer->GetStepTokens();
     *out = tokens.data();
     *out_count = tokens.size();
     return nullptr;
@@ -588,10 +590,18 @@ OgaResult* OGA_API_CALL OgaGenerator_SetLogits(OgaGenerator* generator, OgaTenso
 }
 
 size_t OGA_API_CALL OgaGenerator_GetSequenceCount(const OgaGenerator* generator, size_t index) {
+  // Transducer models (RNNT, TDT) bypass the standard search; the orchestrator
+  // state owns the accumulated transcript directly.
+  if (auto* transducer = dynamic_cast<Generators::TransducerState*>(generator->state_.get())) {
+    return transducer->GetAllTokens().size();
+  }
   return generator->GetSequence(static_cast<int>(index)).size();
 }
 
 const int32_t* OGA_API_CALL OgaGenerator_GetSequenceData(const OgaGenerator* generator, size_t index) {
+  if (auto* transducer = dynamic_cast<Generators::TransducerState*>(generator->state_.get())) {
+    return transducer->GetAllTokens().data();
+  }
   return generator->GetSequence(static_cast<int>(index)).CopyDeviceToCpu().data();
 }
 
diff --git a/test/c_api_tests.cpp b/test/c_api_tests.cpp
index c36414de66..6bf94511b5 100644
--- a/test/c_api_tests.cpp
+++ b/test/c_api_tests.cpp
@@ -1701,3 +1701,78 @@ TEST(CAPITests, StreamingASRVadConsecutiveSilence) {
   ASSERT_EQ(mel3, nullptr);  // Chunk 3: dropped
   SUCCEED();
 }
+
+#ifndef PARAKEET_TDT_PATH
+#define PARAKEET_TDT_PATH MODEL_PATH "parakeet-tdt"
+#endif
+
+#ifndef PARAKEET_TDT_AUDIO_JFK
+#define PARAKEET_TDT_AUDIO_JFK MODEL_PATH "audios/jfk.flac"
+#endif
+
+#ifndef PARAKEET_TDT_AUDIO_TEDLIUM
+#define PARAKEET_TDT_AUDIO_TEDLIUM MODEL_PATH "audios/tedlium_long_120s.flac"
+#endif
+
+// Test that the Parakeet TDT model + processor + generator construct correctly.
+TEST(CAPITests, ParakeetTdtCreate) {
+  if (!std::filesystem::exists(PARAKEET_TDT_PATH))
+    GTEST_SKIP() << "Parakeet TDT model not found at " << PARAKEET_TDT_PATH;
+  auto model = OgaModel::Create(PARAKEET_TDT_PATH);
+  auto processor = OgaMultiModalProcessor::Create(*model);
+  ASSERT_NE(processor, nullptr);
+
+  auto params = OgaGeneratorParams::Create(*model);
+  auto generator = OgaGenerator::Create(*model, *params);
+  ASSERT_NE(generator, nullptr);
+}
+
+namespace {
+std::string RunParakeetTdt(const std::string& audio_path) {
+  auto model = OgaModel::Create(PARAKEET_TDT_PATH);
+  auto processor = OgaMultiModalProcessor::Create(*model);
+  auto tokenizer_stream = OgaTokenizerStream::Create(*processor);
+
+  std::vector<const char*> paths{audio_path.c_str()};
+  auto audios = OgaAudios::Load(paths);
+  auto inputs = processor->ProcessAudios("", audios.get());
+
+  auto params = OgaGeneratorParams::Create(*model);
+  auto generator = OgaGenerator::Create(*model, *params);
+  generator->SetInputs(*inputs);
+
+  std::string transcription;
+  while (!generator->IsDone()) {
+    generator->GenerateNextToken();
+    auto count = generator->GetSequenceCount(0);
+    if (count == 0) continue;
+    auto last = generator->GetSequenceData(0)[count - 1];
+    if (auto piece = tokenizer_stream->Decode(last); piece && *piece) {
+      transcription += piece;
+    }
+  }
+  return transcription;
+}
+}  // namespace
+
+// Transcribe the bundled JFK clip and check the output is non-empty.
+TEST(CAPITests, ParakeetTdtTranscribeJfk) {
+  if (!std::filesystem::exists(PARAKEET_TDT_PATH))
+    GTEST_SKIP() << "Parakeet TDT model not found at " << PARAKEET_TDT_PATH;
+  if (!std::filesystem::exists(PARAKEET_TDT_AUDIO_JFK))
+    GTEST_SKIP() << "Audio not found: " << PARAKEET_TDT_AUDIO_JFK;
+
+  auto transcription = RunParakeetTdt(PARAKEET_TDT_AUDIO_JFK);
+  EXPECT_FALSE(transcription.empty());
+}
+
+// Transcribe a 120s TED clip and check the output is non-empty.
+TEST(CAPITests, ParakeetTdtTranscribeLong) {
+  if (!std::filesystem::exists(PARAKEET_TDT_PATH))
+    GTEST_SKIP() << "Parakeet TDT model not found at " << PARAKEET_TDT_PATH;
+  if (!std::filesystem::exists(PARAKEET_TDT_AUDIO_TEDLIUM))
+    GTEST_SKIP() << "Audio not found: " << PARAKEET_TDT_AUDIO_TEDLIUM;
+
+  auto transcription = RunParakeetTdt(PARAKEET_TDT_AUDIO_TEDLIUM);
+  EXPECT_FALSE(transcription.empty());
+}
diff --git a/test/python/conftest.py b/test/python/conftest.py
index 78d4a77aa9..d6583d257e 100644
--- a/test/python/conftest.py
+++ b/test/python/conftest.py
@@ -98,6 +98,16 @@ def nemotron_speech_model_path(request):
     return model_path
 
 
+@pytest.fixture
+def parakeet_tdt_model_path(request):
+    """Return the path to a parakeet-tdt model directory, or skip if not available."""
+    test_data = request.config.getoption("--test_models")
+    model_path = os.path.join(test_data, "parakeet-tdt")
+    if not os.path.exists(os.path.join(model_path, "genai_config.json")):
+        pytest.skip(f"Parakeet TDT model not found at {model_path}")
+    return model_path
+
+
 @pytest.fixture
 def test_data_path(request):
     return request.config.getoption("--test_models")
diff --git a/test/python/test_onnxruntime_genai_e2e.py b/test/python/test_onnxruntime_genai_e2e.py
index f451245dae..199654aa19 100644
--- a/test/python/test_onnxruntime_genai_e2e.py
+++ b/test/python/test_onnxruntime_genai_e2e.py
@@ -193,6 +193,33 @@ def run_nemotron_speech():
     run_subprocess(command, cwd=cwd, log=log).check_returncode()
 
 
+def run_parakeet_tdt():
+    """Run Parakeet TDT E2E test by invoking the parakeet.py example."""
+    log.debug("Running Parakeet TDT Python E2E Test")
+
+    cwd = os.path.dirname(os.path.abspath(__file__))
+    model_path = os.path.join(cwd, "..", "test_models", "parakeet-tdt")
+    if not os.path.exists(model_path):
+        log.info(f"Parakeet TDT model not found at {model_path}, skipping E2E test.")
+        return
+
+    for audio_filename in ("jfk.flac", "tedlium_long_120s.flac"):
+        audio_path = os.path.join(cwd, "..", "test_models", "audios", audio_filename)
+        if not os.path.exists(audio_path):
+            log.info(f"Test audio file not found at {audio_path}, skipping.")
+            continue
+
+        command = [
+            sys.executable,
+            os.path.join(cwd, "..", "..", "examples", "python", "parakeet.py"),
+            "--model_path",
+            model_path,
+            "--audio_file",
+            audio_path,
+        ]
+        run_subprocess(command, cwd=cwd, log=log).check_returncode()
+
+
 def get_args():
     parser = argparse.ArgumentParser()
 
@@ -225,5 +252,8 @@ def get_args():
     # Run Nemotron Speech E2E tests
     run_nemotron_speech()
 
+    # Run Parakeet TDT E2E tests
+    run_parakeet_tdt()
+
     # Run tool calling E2E tests
     run_tool_calling()
diff --git a/test/python/test_parakeet_tdt.py b/test/python/test_parakeet_tdt.py
new file mode 100644
index 0000000000..33b9e22625
--- /dev/null
+++ b/test/python/test_parakeet_tdt.py
@@ -0,0 +1,148 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""End-to-end tests for the Parakeet TDT speech recognition model.
+
+Mirrors the structure of the existing nemotron / whisper tests:
+- creation tests (model + processor + generator)
+- transcription tests on bundled audio clips (jfk.flac, tedlium_long_120s.flac)
+- a WER assertion (< 0.1) against a reference transcription
+
+Reference transcriptions for the bundled clips are defined in
+REFERENCE_TRANSCRIPTIONS below. Setting an entry to an empty string skips the
+WER assertion for that clip (the test still runs end-to-end and confirms the
+model produces non-empty output).
+"""
+
+import os
+import re
+from pathlib import Path
+
+import pytest
+
+import onnxruntime_genai as og
+
+
+# Reference transcriptions for the bundled audio clips. Leave the values empty
+# to skip the WER assertion (the test will still run end-to-end and confirm
+# the model produces non-empty output).
+REFERENCE_TRANSCRIPTIONS = {
+    "jfk.flac": (
+        "And so my fellow Americans ask not what your country can do for you "
+        "ask what you can do for your country"
+    ),
+    "tedlium_long_120s.flac": (
+        "I'm going to talk today about energy and climate. And that might seem a bit "
+        "surprising because my full time work at the foundation is mostly about "
+        "vaccines and seeds, about the things that we need to invent and deliver to "
+        "help the poorest two billion live better lives. But energy and climate are "
+        "extremely important to these people. In fact, more important than to anyone "
+        "else on the planet. The climate getting worse means that many years their "
+        "crops won't grow. There'll be too much rain, not enough rain. Things will "
+        "change in ways that their fragile environment simply can't support. And that "
+        "leads to starvation, it leads to uncertainty, it leads to unrest. The climate changes "
+        "will be terrible for them. Also, the price of energy is very important to them. In "
+        "fact, if you could pick just one thing to lower the price of, to reduce "
+        "poverty, by far you would pick energy. Now, the price of energy has come "
+        "down over time. Really, advanced civilization is based on advances in in"
+        "energy. The coal revolution fueled the industrial revolution, and even in "
+        "the 1900s, we've seen a very rapid decline in the price of electricity. "
+        "That's why we have refrigerators, air conditioning. We can make modern "
+        "materials and do so many things. And so we're in a wonderful situation with "
+        "electricity in the rich world. But as we make it cheaper, and let's say, "
+        "let's go for making it twice as cheap. We need to meet a new constraint, and "
+        "that constraint has to do with CO2. CO2 is warming the planet, and the "
+        "equation on CO2 is actually a very straightforward one. If you sum up the "
+        "CO2."
+    ),
+}
+
+
+def _normalize(text: str) -> list[str]:
+    """Lowercase + strip punctuation + split into whitespace tokens for WER."""
+    text = text.lower()
+    text = re.sub(r"[^\w\s']", " ", text)
+    return text.split()
+
+
+def _wer(reference: str, hypothesis: str) -> float:
+    """Standard Levenshtein-based word error rate."""
+    ref = _normalize(reference)
+    hyp = _normalize(hypothesis)
+    if not ref:
+        return 0.0 if not hyp else 1.0
+
+    # Classic edit-distance DP.
+    n, m = len(ref), len(hyp)
+    dp = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1):
+        dp[i][0] = i
+    for j in range(m + 1):
+        dp[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            if ref[i - 1] == hyp[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1]
+            else:
+                dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
+    return dp[n][m] / float(n)
+
+
+def _transcribe(model_path: str, audio_path: str) -> str:
+    """Run the parakeet pipeline end-to-end and return the decoded text."""
+    model = og.Model(model_path)
+    processor = model.create_multimodal_processor()
+
+    audios = og.Audios.open(audio_path)
+    inputs = processor("", audios=audios)
+
+    params = og.GeneratorParams(model)
+    generator = og.Generator(model, params)
+    generator.set_inputs(inputs)
+
+    while not generator.is_done():
+        generator.generate_next_token()
+
+    return processor.decode(generator.get_sequence(0)).strip()
+
+
+def test_parakeet_create(parakeet_tdt_model_path):
+    """Model + processor + generator construction should succeed."""
+    model = og.Model(parakeet_tdt_model_path)
+    processor = model.create_multimodal_processor()
+    assert processor is not None
+
+    params = og.GeneratorParams(model)
+    generator = og.Generator(model, params)
+    assert generator is not None
+
+
+@pytest.mark.parametrize("relative_audio_path", [Path("audios") / "jfk.flac"])
+def test_parakeet_transcribe_jfk(parakeet_tdt_model_path, test_data_path, relative_audio_path):
+    """Transcribe the short JFK clip and compare to reference (if provided)."""
+    audio_path = os.fspath(Path(test_data_path) / relative_audio_path)
+    if not os.path.exists(audio_path):
+        pytest.skip(f"Audio file not found: {audio_path}")
+
+    transcription = _transcribe(parakeet_tdt_model_path, audio_path)
+    assert transcription, "Empty transcription returned"
+
+    reference = REFERENCE_TRANSCRIPTIONS.get(relative_audio_path.name, "")
+    if reference:
+        wer = _wer(reference, transcription)
+        assert wer < 0.1, f"WER too high: {wer:.3f}\nref: {reference}\nhyp: {transcription}"
+
+
+@pytest.mark.parametrize("relative_audio_path", [Path("audios") / "tedlium_long_120s.flac"])
+def test_parakeet_transcribe_long(parakeet_tdt_model_path, test_data_path, relative_audio_path):
+    """Transcribe the 120s TED clip and compare to reference (if provided)."""
+    audio_path = os.fspath(Path(test_data_path) / relative_audio_path)
+    if not os.path.exists(audio_path):
+        pytest.skip(f"Audio file not found: {audio_path}")
+
+    transcription = _transcribe(parakeet_tdt_model_path, audio_path)
+    assert transcription, "Empty transcription returned"
+
+    reference = REFERENCE_TRANSCRIPTIONS.get(relative_audio_path.name, "")
+    if reference:
+        wer = _wer(reference, transcription)
+        assert wer < 0.1, f"WER too high: {wer:.3f}\nref: {reference}\nhyp: {transcription}"
diff --git a/test/test_models/audios/tedlium_long_120s.flac b/test/test_models/audios/tedlium_long_120s.flac
new file mode 100644
index 0000000000..9e5dcaa674
Binary files /dev/null and b/test/test_models/audios/tedlium_long_120s.flac differ