@@ -42,11 +42,13 @@ function LLMScreen() {
   const { bottom } = useSafeAreaInsets();
   const [isTextInputFocused, setIsTextInputFocused] = useState(false);
   const [userInput, setUserInput] = useState('');
+  const [selectedModel, setSelectedModel] = useState<LLMModelSources>(
+    models.llm.lfm2_5_1_2b_instruct()
+  );
   const textInputRef = useRef<TextInput>(null);
   const { setGlobalGenerating } = useContext(GeneratingContext);
 
-  let llm = Object();
-  
+  const llm = useLLM({ model: selectedModel });
   const tokenCount = llm.isReady ? llm.getGeneratedTokenCount() : 0;
   const { stats, onMessageSend } = useLLMStats(
     llm.response,
@@ -110,6 +112,13 @@ function LLMScreen() {
               />
             </View>
           )}
+
+          <ModelPicker
+            models={LLM_MODELS}
+            selectedModel={selectedModel}
+            onSelect={(m) => setSelectedModel(m)}
+            disabled={llm.isGenerating}
+          />
           <StatsBar stats={stats} />
           <View
             style={[
 
@@ -18,8 +18,8 @@ BaseLLMRunner::BaseLLMRunner(std::unique_ptr<Module> module,
       tokenizer_(std::make_unique<tokenizers::HFTokenizer>()),
       metadata_({
           {kEnableDynamicShape, false},
-          {kMaxSeqLen, 2048},
-          {kMaxContextLen, 2048},
+          {kMaxSeqLen, 128},
+          {kMaxContextLen, 128},
           {kUseKVCache, true},
       }) {}
 
 
@@ -28,8 +28,8 @@ class MultimodalPrefiller {
 
   // Prefill one input segment. Updates start_pos in-place.
   // Returns the first predicted token after this segment.
-  ::executorch::runtime::Result<uint64_t> prefill(const MultimodalInput &input,
-                                                  int64_t &start_pos);
+  ::executorch::runtime::Result<uint64_t>
+  prefill(const std::vector<MultimodalInput> &inputs, int64_t &start_pos);
 
   ::executorch::runtime::Error load();
   bool is_method_loaded();
 
@@ -3,7 +3,6 @@
 #include "constants.h"
 #include "util.h"
 #include <rnexecutorch/Error.h>
-#include <rnexecutorch/Log.h>
 
 namespace executorch::extension::llm {
 
@@ -83,15 +82,10 @@ Error MultimodalRunner::generate_internal(
   }
 
   stats_.inference_start_ms = time_in_ms();
-  const long t_gen_begin = stats_.inference_start_ms;
-  rnexecutorch::log(rnexecutorch::LOG_LEVEL::Info, "inputs count", inputs.size());
   auto prefill_result = mm_prefiller_->prefill(inputs, pos_);
   if (!prefill_result.ok())
     return prefill_result.error();
   uint64_t prefill_next_token = prefill_result.get();
-  const long t_prefill_done = time_in_ms();
-  rnexecutorch::log(rnexecutorch::LOG_LEVEL::Info, "prefill result",
-                    prefill_next_token);
 
   stats_.first_token_ms = time_in_ms();
   stats_.prompt_eval_end_ms = time_in_ms();
 
@@ -35,13 +35,7 @@ TextDecoderRunner::step(TensorPtr &tokens, int64_t start_pos) {
   // dynamic "forward"; single-token decode steps go through the static
   // "forward_decode" method when present (avoids dynamic-shape re-encode
   // overhead — measured 8× faster on gemma4 Vulkan).
-  const char* method_name = "forward";
-  // if (tokens->numel() == 1) {
-  //   auto decode_meta = module_->method_meta("forward_decode");
-  //   if (decode_meta.ok()) {
-  //     method_name = "forward_decode";
-  //   }
-  // }
+  const char *method_name = "forward";
   auto method_meta_result = module_->method_meta(method_name);
   if (!method_meta_result.ok()) {
     return method_meta_result.error();
 
@@ -22,15 +22,10 @@ TextPrefiller::TextPrefiller(TextDecoderRunner *text_decoder_runner,
                              int64_t max_seq_len)
     : text_decoder_runner_(text_decoder_runner), use_kv_cache_(use_kv_cache),
       enable_parallel_prefill_(enable_parallel_prefill),
-      max_seq_len_(max_seq_len > 0 ? max_seq_len : 2048) {
+      max_seq_len_(max_seq_len > 0 ? max_seq_len : 128) {
   // Auto-detect static-shape prefill: when `forward` declares input 0 as
   // [1, N] with N>1, we must pad every prefill call to exactly N tokens.
   prefill_static_len_ = text_decoder_runner_->prefill_static_len();
-  if (prefill_static_len_ > 0) {
-    rnexecutorch::log(
-        rnexecutorch::LOG_LEVEL::Info,
-        "TextPrefiller: static prefill len detected =", prefill_static_len_);
-  }
 }
 
 ::executorch::runtime::Result<uint64_t>
@@ -108,9 +103,6 @@ TextPrefiller::prefill_chunk(std::vector<uint64_t> &prompt_tokens,
     auto tokens = from_blob(tokens_ptr, {1, tensor_len},
                             executorch::aten::ScalarType::Long);
 
-    rnexecutorch::log(rnexecutorch::LOG_LEVEL::Info, "prefill effective_len",
-                      num_prompt_tokens, "tensor_len", tensor_len, "start_pos",
-                      start_pos);
     auto outputs_res = text_decoder_runner_->step(tokens, start_pos);
 
     ET_CHECK_OK_OR_RETURN_ERROR(outputs_res.error());
 
@@ -90,7 +90,6 @@ class TextTokenGenerator {
     timestamp_ = std::chrono::high_resolution_clock::now();
 
     // Generate our tokens
-    rnexecutorch::log(rnexecutorch::LOG_LEVEL::Info, "kappa generator", pos, start_pos, max_new_tokens);
     while (pos < start_pos + max_new_tokens) {
       // Run the model
       auto logits_res = text_decoder_runner_->step(tokens_managed, pos);
@@ -101,8 +100,8 @@ class TextTokenGenerator {
       prev_token = cur_token;
 
       stats_->on_sampling_begin();
-      cur_token =
-          text_decoder_runner_->logits_to_token(logits_tensor, generated_tokens);
+      cur_token = text_decoder_runner_->logits_to_token(logits_tensor,
+                                                        generated_tokens);
       stats_->on_sampling_end();
 
       pos++;
@@ -126,10 +125,6 @@ class TextTokenGenerator {
       // history and corrupt the next turn's chat-template rendering
       // (e.g. duplicated <end_of_turn>).
       if (eos_reached_now) {
-        printf("\n");
-        rnexecutorch::log(rnexecutorch::LOG_LEVEL::Info,
-                          "Reached end of generation");
-#ifndef RNEX_BYPASS_TOKENIZER
         if (!token_cache.empty()) {
           auto flush = tokenizer_->decode(token_cache, false);
           if (flush.ok() && !flush.get().empty() &&
@@ -138,19 +133,11 @@ class TextTokenGenerator {
           }
           token_cache.clear();
         }
-#else
-        token_cache.clear();
-#endif
         break;
       }
 
       token_cache.push_back(static_cast<uint64_t>(cur_token));
 
-#ifdef RNEX_BYPASS_TOKENIZER
-      rnexecutorch::log(rnexecutorch::LOG_LEVEL::Info,
-                        "gen_token=" + std::to_string(cur_token));
-      std::string cache_decoded = std::to_string(cur_token) + " ";
-#else
       // print the token as string, decode it with the Tokenizer object
       // We pass false, as we want don't want to skip special tokens e.g.
       // <think>
@@ -164,7 +151,6 @@ class TextTokenGenerator {
                 std::to_string(static_cast<int32_t>(decodeResult.error())));
       }
       std::string cache_decoded = decodeResult.get();
-#endif
       const auto timeIntervalElapsed =
           std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::high_resolution_clock::now() - timestamp_)
 
@@ -496,11 +496,12 @@ export const models = {
       M.LFM2_5_1_2B_INSTRUCT_QUANTIZED
     ),
     bielik_v3_0_1_5b: pair(M.BIELIK_V3_0_1_5B, M.BIELIK_V3_0_1_5B_QUANTIZED),
+    gemma4_e2b: base(M.GEMMA4_E2B),
     // Multimodal LLMs — same hook/module as plain LLMs, listed here so users
     // pick a model by capability ("LLM") rather than by modality.
     lfm2_5_vl_1_6b: base(M.LFM2_5_VL_1_6B_QUANTIZED),
     lfm2_5_vl_450m: base(M.LFM2_5_VL_450M_QUANTIZED),
-    gemma4_e2b: base(M.GEMMA4_E2B),
+    gemma4_e2b_multimodal: base(M.GEMMA4_E2B_MM),
   },
   classification: {
     efficientnet_v2_s: variant(EFFICIENTNET_V2_S_VARIANTS),
 
@@ -310,7 +310,6 @@ export class LLMController {
       this.isGeneratingCallback(true);
       this.nativeModule.reset();
       let response: string;
-      console.log(input);
       if (hasImages || hasAudio) {
         response = await this.nativeModule.generateMultimodal(
           input,