@@ -88,6 +88,16 @@ set_tests_properties(
              RESOURCE_LOCK arm_ethos_u_runtime
 )
 
+add_test(
+  NAME runner_input_restoration
+  COMMAND "${_ethos_u_runtime_tests_dir}/test_runner_input_restoration.sh"
+          "${EXECUTORCH_ROOT}" "${_ethos_u_runtime_test_output_dir}"
+)
+set_tests_properties(
+  runner_input_restoration PROPERTIES LABELS "arm;ethos-u;runtime;runner;fvp"
+                                      RESOURCE_LOCK arm_ethos_u_runtime
+)
+
 add_test(
   NAME memory_allocation_planned_fast
   COMMAND "${_ethos_u_runtime_tests_dir}/test_memory_allocation_planned_fast.sh"
 
@@ -0,0 +1,33 @@
+#!/bin/bash
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+set -eo pipefail
+
+source "$(cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd)/setup_env.sh"
+
+test_dir="${test_output_dir}/runner_input_restoration"
+mkdir -p "${test_dir}"
+
+for target in ethos-u55-128 ethos-u85-128; do
+    log_file="${test_dir}/${target}.log"
+
+    # add.py reuses the input arena for its output. Without restoration,
+    # x + x + 2 produces 4, 10, 22 instead of 4 on every iteration.
+    "${et_root_dir}/examples/arm/run.sh" \
+        --et_build_root="${test_dir}" \
+        --output="${test_dir}/${target}" \
+        --target="${target}" \
+        --model_name="${et_root_dir}/examples/arm/example_modules/add.py" \
+        --no_delegate \
+        --no_quantize \
+        --select_ops_list="aten::add.out" \
+        --bundleio \
+        --extra_build_flags="-DET_NUM_INFERENCES=3" \
+        2>&1 | tee "${log_file}"
+
+    grep -q "3 inferences finished" "${log_file}"
+    grep -q "Test_result: PASS" "${log_file}"
+done
@@ -464,8 +464,16 @@ template <typename ValueType>
 
 Error prepare_input_tensors(
     Method& method,
-    MemoryAllocator& allocator,
-    const std::vector<std::pair<char*, size_t>>& input_buffers) {
+    EValue* input_evalues,
+    const std::vector<std::pair<char*, size_t>>& input_buffers,
+    ET_UNUSED const void* bundled_model_data = nullptr) {
+#if defined(ET_BUNDLE_IO)
+  if (bundled_model_data != nullptr) {
+    return executorch::bundled_program::load_bundled_input(
+        method, bundled_model_data, testset_idx);
+  }
+#endif
+
   MethodMeta method_meta = method.method_meta();
   size_t num_inputs = method_meta.num_inputs();
 
@@ -476,12 +484,6 @@ Error prepare_input_tensors(
       "Wrong number of inputs allocated compared to method");
 #endif
 
-  EValue* input_evalues = allocator.allocateList<EValue>(num_inputs);
-  ET_CHECK_OR_RETURN_ERROR(
-      input_evalues != nullptr,
-      MemoryAllocationFailed,
-      "Could not allocate memory for input evalues.");
-
   Error err = method.get_inputs(input_evalues, num_inputs);
   ET_CHECK_OK_OR_RETURN_ERROR(err);
 
@@ -618,6 +620,7 @@ struct RunnerContext {
   Box<HierarchicalAllocator> planned_memory;
   Box<MemoryManager> memory_manager;
   Box<Result<Method>> method;
+  EValue* input_evalues = nullptr;
 #if defined(ET_EVENT_TRACER_ENABLED)
   Box<ETDumpGen> etdump_gen;
 #if defined(ET_DUMP_INTERMEDIATE_OUTPUTS) || defined(ET_DUMP_OUTPUTS)
@@ -890,24 +893,28 @@ void runner_init(
   size_t input_membase = ctx.method_allocator->used_size();
 
 #if defined(ET_BUNDLE_IO)
-  if (ctx.bundle_io) {
-    // Get inputs from bundled IO ".bpte" data
-    // Useful for testing
-    ET_LOG(Info, "Input testset[%d] from bundled bpte", testset_idx);
-    Error status = executorch::bundled_program::load_bundled_input(
-        *ctx.method.value(), model_data, testset_idx);
-    ET_CHECK_MSG(
-        status == Error::Ok,
-        "load_bundled_input failed with status 0x%" PRIx32,
-        status);
-  } else
+  if (!ctx.bundle_io
+#if defined(SEMIHOSTING)
+      || ctx.server_mode
+#endif
+  )
 #endif
   {
-    Error status = ::prepare_input_tensors(
-        *ctx.method.value(), ctx.method_allocator.value(), input_buffers);
+    const size_t num_inputs = ctx.method.value()->inputs_size();
+    ctx.input_evalues = ctx.method_allocator->allocateList<EValue>(num_inputs);
     ET_CHECK_MSG(
-        status == Error::Ok, "Failed to prepare inputs 0x%" PRIx32, status);
+        ctx.input_evalues != nullptr || num_inputs == 0,
+        "Could not allocate memory for input evalues.");
   }
+  Error input_status = ::prepare_input_tensors(
+      *ctx.method.value(),
+      ctx.input_evalues,
+      input_buffers,
+      ctx.bundle_io ? model_data : nullptr);
+  ET_CHECK_MSG(
+      input_status == Error::Ok,
+      "Failed to prepare inputs 0x%" PRIx32,
+      input_status);
 #if defined(ET_LOG_DUMP_INPUT)
   {
     std::vector<EValue> inputs((*ctx.method.value())->inputs_size());
@@ -1333,7 +1340,10 @@ bool verify_result(RunnerContext& ctx, const void* model_data) {
   return model_ok;
 }
 
-bool run_model(RunnerContext& ctx, const void* model_data) {
+bool run_model(
+    RunnerContext& ctx,
+    const void* model_data,
+    const std::vector<std::pair<char*, size_t>>& input_buffers) {
   Error status;
   ET_LOG(
       Info,
@@ -1344,7 +1354,16 @@ bool run_model(RunnerContext& ctx, const void* model_data) {
   for (n = 0; n < num_inferences; n++) {
     ET_LOG(
         Debug, "Running inference number %lu", static_cast<printf_size_t>(n));
-    // Run the model.
+    if (n > 0) {
+      status = ::prepare_input_tensors(
+          *ctx.method.value(),
+          ctx.input_evalues,
+          input_buffers,
+          ctx.bundle_io ? model_data : nullptr);
+      if (status != Error::Ok) {
+        break;
+      }
+    }
     status = ctx.method.value()->execute();
     if (status != Error::Ok) {
       break;
@@ -1408,7 +1427,7 @@ bool run_model_server(
         status == Error::Ok, "Could not reload inputs: 0x%" PRIx32, status);
 
     status = ::prepare_input_tensors(
-        *ctx.method.value(), ctx.temp_allocator.value(), input_buffers);
+        *ctx.method.value(), ctx.input_evalues, input_buffers);
     ET_CHECK_MSG(
         status == Error::Ok, "Failed to prepare inputs 0x%" PRIx32, status);
 
@@ -1544,8 +1563,8 @@ int main(int argc, const char* argv[]) {
   // Byte 4-7 is usually a nice magic number that could be good to print to make
   // sure it's OK ETxx for PTE and BPxx for bundled pte where xx is a number.
   // cppcheck-suppress knownConditionTrueFalse
-  if (model_data == nullptr || model_size == 0) {
-    ET_LOG(Fatal, "Model data is not initialized");
+  if (model_data == nullptr || model_size < 8) {
+    ET_LOG(Fatal, "Model data is missing or too short");
     return 1;
   }
 #if defined(SEMIHOSTING)
@@ -1578,15 +1597,15 @@ int main(int argc, const char* argv[]) {
   if (ctx.server_mode) {
     model_ok = run_model_server(ctx, model_data, input_buffers);
   } else {
-    model_ok = run_model(ctx, model_data);
+    model_ok = run_model(ctx, model_data, input_buffers);
   }
 #if defined(ETHOSU55)
   if (keep_powered) {
     set_runner_power(false);
   }
 #endif
 #else
-  model_ok = run_model(ctx, model_data);
+  model_ok = run_model(ctx, model_data, input_buffers);
 #endif
   ET_LOG(Info, "Model run: %d", model_ok);