@@ -16,6 +16,7 @@
 #include <utility>
 
 #include <executorch/extension/llm/batching/runner.h>
+#include <executorch/runtime/platform/log.h>
 
 namespace executorch {
 namespace extension {
@@ -35,7 +36,8 @@ struct ServingRuntime::Impl {
   struct Command {
     Operation operation;
     std::string key;
-    std::promise<LifecycleResult> completion;
+    // Queue transfers must not destroy user captures under mutex_.
+    std::unique_ptr<LifecycleCallback> completion;
   };
 
   Impl(
@@ -53,12 +55,44 @@ struct ServingRuntime::Impl {
     }
   }
 
+  static void complete(
+      std::unique_ptr<LifecycleCallback> completion,
+      LifecycleResult result) {
+    if (!completion || !*completion) {
+      return;
+    }
+#if ET_HAS_EXCEPTIONS
+    try {
+#endif
+      (*completion)(std::move(result));
+#if ET_HAS_EXCEPTIONS
+    } catch (...) {
+      ET_LOG(Error, "Lifecycle completion callback threw");
+    }
+#endif
+  }
+
   std::future<LifecycleResult> submit(Operation operation, std::string key) {
-    Command command{operation, std::move(key), {}};
-    auto future = command.completion.get_future();
+    auto completion = std::make_shared<std::promise<LifecycleResult>>();
+    auto future = completion->get_future();
+    submit(
+        operation,
+        std::move(key),
+        [completion = std::move(completion)](LifecycleResult result) {
+          completion->set_value(std::move(result));
+        });
+    return future;
+  }
+
+  void
+  submit(Operation operation, std::string key, LifecycleCallback on_complete) {
+    Command command{
+        operation,
+        std::move(key),
+        std::make_unique<LifecycleCallback>(std::move(on_complete))};
+    LifecycleResult error;
     {
       std::lock_guard<std::mutex> lock(mutex_);
-      LifecycleResult error;
       if (!valid_config_) {
         error =
             ServingError{ErrorCode::InvalidArgument, "invalid runtime config"};
@@ -74,15 +108,16 @@ struct ServingRuntime::Impl {
         error = ServingError{
             ErrorCode::CapacityExceeded, "lifecycle operation limit reached"};
       }
-      if (error) {
-        command.completion.set_value(std::move(error));
-        return future;
+      if (!error) {
+        inbox_.push_back(std::move(command));
+        ++outstanding_;
       }
-      inbox_.push_back(std::move(command));
-      ++outstanding_;
     }
-    cv_.notify_one();
-    return future;
+    if (error) {
+      complete(std::move(command.completion), std::move(error));
+    } else {
+      cv_.notify_one();
+    }
   }
 
   LifecycleResult process(Command& command) {
@@ -190,8 +225,8 @@ struct ServingRuntime::Impl {
           result = ServingError{ErrorCode::NotReady, "runtime is stopping"};
         }
         --outstanding_;
-        command.completion.set_value(std::move(result));
       }
+      complete(std::move(command.completion), std::move(result));
     }
     decltype(sessions_) retired;
     {
@@ -260,16 +295,34 @@ ServingRuntime::~ServingRuntime() {
   shutdown();
 }
 
+void ServingRuntime::open_session_async(
+    std::string key,
+    LifecycleCallback on_complete) {
+  impl_->submit(Impl::Operation::Open, std::move(key), std::move(on_complete));
+}
+
 std::future<LifecycleResult> ServingRuntime::open_session_async(
     std::string key) {
   return impl_->submit(Impl::Operation::Open, std::move(key));
 }
 
+void ServingRuntime::close_session_async(
+    std::string key,
+    LifecycleCallback on_complete) {
+  impl_->submit(Impl::Operation::Close, std::move(key), std::move(on_complete));
+}
+
 std::future<LifecycleResult> ServingRuntime::close_session_async(
     std::string key) {
   return impl_->submit(Impl::Operation::Close, std::move(key));
 }
 
+void ServingRuntime::reset_session_async(
+    std::string key,
+    LifecycleCallback on_complete) {
+  impl_->submit(Impl::Operation::Reset, std::move(key), std::move(on_complete));
+}
+
 std::future<LifecycleResult> ServingRuntime::reset_session_async(
     std::string key) {
   return impl_->submit(Impl::Operation::Reset, std::move(key));
 
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <cstddef>
+#include <functional>
 #include <future>
 #include <memory>
 #include <optional>
@@ -28,13 +29,15 @@ struct ET_EXPERIMENTAL ServingRuntimeConfig {
   std::size_t max_sessions = 1;
   // Reported metadata; 0 means unknown.
   std::size_t max_context_length = 0;
-  // Queued plus executing lifecycle operations. Must be non-zero.
+  // Queued plus executing lifecycle operations, excluding completion
+  // callbacks. Must be non-zero.
   std::size_t max_pending_operations = 64;
 };
 
 // nullopt acknowledges success. Dropping a future does not cancel its
 // operation.
 using LifecycleResult ET_EXPERIMENTAL = std::optional<ServingError>;
+using LifecycleCallback ET_EXPERIMENTAL = std::function<void(LifecycleResult)>;
 
 class ET_EXPERIMENTAL ServingRuntime {
  public:
@@ -55,34 +58,45 @@ class ET_EXPERIMENTAL ServingRuntime {
   ServingRuntime& operator=(ServingRuntime&&) = delete;
 
   // Any thread. Keys must be non-empty. Accepted operations run in admission
-  // order, including operations submitted before a previous future completes.
-  // Queue saturation returns CapacityExceeded without changing session state.
+  // order. Queue saturation reports CapacityExceeded without changing state.
+  // For all lifecycle operations, callbacks run once on control after
+  // processing and admission release, or inline on the caller for immediate
+  // rejection. They run without runtime locks and may race with submission's
+  // return. Callbacks must do short, nonblocking work: no waits for runtime
+  // work or runtime shutdown/destruction. Exceptions are logged, not retried.
+  // An empty callback discards the result. Futures adapt this same completion
+  // path.
+  //
   // Opens may queue during initialization; success means an empty session is
   // owned, or the key was already open. An initial open failure releases its
   // slot. Opening an unavailable key fails with NotReady; use reset to retry.
+  void open_session_async(std::string key, LifecycleCallback on_complete);
   std::future<LifecycleResult> open_session_async(std::string key);
 
   // Idempotent, including absent keys. Success releases the logical slot and
   // requests Session closure through RAII, not synchronous physical cleanup.
+  void close_session_async(std::string key, LifecycleCallback on_complete);
   std::future<LifecycleResult> close_session_async(std::string key);
 
   // Cold replacement, retaining the key and logical slot throughout. Success
   // means reopening completed. Failure destroys the old state and leaves the
   // key unavailable, still reserving its slot until reset succeeds or close
   // releases it. A missing key returns SessionNotFound. Never uses prefix
   // reuse.
+  void reset_session_async(std::string key, LifecycleCallback on_complete);
   std::future<LifecycleResult> reset_session_async(std::string key);
 
   // A synchronized snapshot. Ready means initialized and accepting operations,
   // not that capacity is available. Active slots include opening, reopening,
   // and unavailable keys, but not commands still waiting to reserve a slot.
   ServingInfo info() const;
 
-  // Idempotent, including concurrent callers. Stops admission, settles all
-  // accepted futures, and joins the control and Runner threads. No new work is
-  // accepted afterward. Call only from external threads, never engine
-  // callbacks. Destruction calls shutdown; as usual, object lifetime must be
-  // externally synchronized against callers still accessing the runtime.
+  // Idempotent, including concurrent callers. Stops admission, completes all
+  // accepted operations, and joins the control and Runner threads. Accepted
+  // callbacks have returned and their runtime-owned captures are released.
+  // No new work is accepted afterward. Call only from external threads, never
+  // engine or lifecycle callbacks. Destruction calls shutdown; as usual, object
+  // lifetime must be synchronized against callers still accessing the runtime.
   void shutdown();
 
  private: