diff --git a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsActivity.kt b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsActivity.kt
index 73bb0b9..6a30971 100644
--- a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsActivity.kt
+++ b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsActivity.kt
@@ -16,6 +16,10 @@
 package com.android.virtualization.terminal
 
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.Window
+import android.view.WindowManager
 import androidx.appcompat.app.AppCompatActivity
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
@@ -28,6 +32,12 @@
         super.onCreate(savedInstanceState)
         setContentView(R.layout.settings_activity)
 
+        Handler(Looper.getMainLooper()).post {
+            val lp: WindowManager.LayoutParams = getWindow().getAttributes()
+            lp.accessibilityTitle = getString(R.string.action_settings)
+            getWindow().setAttributes(lp)
+        }
+
         val toolbar: MaterialToolbar = findViewById(R.id.settings_toolbar)
         setSupportActionBar(toolbar)
         val settingsItems = arrayOf(
@@ -56,4 +66,4 @@
         recyclerView.layoutManager = LinearLayoutManager(this)
         recyclerView.adapter = settingsListItemAdapter
     }
-}
\ No newline at end of file
+}
diff --git a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsDiskResizeActivity.kt b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsDiskResizeActivity.kt
index 580d20c..d9086a4 100644
--- a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsDiskResizeActivity.kt
+++ b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsDiskResizeActivity.kt
@@ -22,11 +22,16 @@
 import android.icu.util.Measure
 import android.icu.util.MeasureUnit
 import android.os.Bundle
+import android.os.FileUtils
+import android.os.Handler
+import android.os.Looper
 import android.text.SpannableString
 import android.text.Spanned
 import android.text.TextUtils
 import android.text.style.RelativeSizeSpan
 import android.widget.SeekBar
+import android.view.Window
+import android.view.WindowManager
 import android.widget.TextView
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.isVisible
@@ -62,6 +67,13 @@
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.settings_disk_resize)
+
+        Handler(Looper.getMainLooper()).post {
+            val lp: WindowManager.LayoutParams = getWindow().getAttributes()
+            lp.accessibilityTitle = getString(R.string.settings_disk_resize_title)
+            getWindow().setAttributes(lp)
+        }
+
         diskSizeStepMb = 1L shl resources.getInteger(R.integer.disk_size_round_up_step_size_in_mb)
 
         val sharedPref =
diff --git a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsPortForwardingActivity.kt b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsPortForwardingActivity.kt
index fe693c4..0377de4 100644
--- a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsPortForwardingActivity.kt
+++ b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsPortForwardingActivity.kt
@@ -18,6 +18,10 @@
 import android.content.Context
 import android.content.SharedPreferences
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.Window
+import android.view.WindowManager
 import androidx.appcompat.app.AppCompatActivity
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
@@ -30,6 +34,12 @@
         super.onCreate(savedInstanceState)
         setContentView(R.layout.settings_port_forwarding)
 
+        Handler(Looper.getMainLooper()).post {
+            val lp: WindowManager.LayoutParams = getWindow().getAttributes()
+            lp.accessibilityTitle = getString(R.string.settings_port_forwarding_title)
+            getWindow().setAttributes(lp)
+        }
+
         mSharedPref =
             this.getSharedPreferences(getString(R.string.preference_file_key), Context.MODE_PRIVATE)
 
diff --git a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsRecoveryActivity.kt b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsRecoveryActivity.kt
index 00730ff..3adeece 100644
--- a/android/TerminalApp/java/com/android/virtualization/terminal/SettingsRecoveryActivity.kt
+++ b/android/TerminalApp/java/com/android/virtualization/terminal/SettingsRecoveryActivity.kt
@@ -17,8 +17,12 @@
 
 import android.content.Intent
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import android.view.View
+import android.view.Window
+import android.view.WindowManager
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.isVisible
 import androidx.lifecycle.lifecycleScope
@@ -36,6 +40,13 @@
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.settings_recovery)
+
+        Handler(Looper.getMainLooper()).post {
+            val lp: WindowManager.LayoutParams = getWindow().getAttributes()
+            lp.accessibilityTitle = getString(R.string.settings_recovery_title)
+            getWindow().setAttributes(lp)
+        }
+
         val resetCard = findViewById<MaterialCardView>(R.id.settings_recovery_reset_card)
         resetCard.setOnClickListener {
             var backupRootfs = false
diff --git a/android/compos_verify/verify.rs b/android/compos_verify/verify.rs
index b94ebbc..a3f18d5 100644
--- a/android/compos_verify/verify.rs
+++ b/android/compos_verify/verify.rs
@@ -124,7 +124,6 @@
         &idsig_manifest_ext_apk,
         &VmParameters {
             name: String::from("ComposVerify"),
-            os: String::from("microdroid"),
             cpu_topology: VmCpuTopology::OneCpu, // This VM runs very little work at boot
             debug_mode: args.debug,
             ..Default::default()
diff --git a/android/composd/aidl/android/system/composd/IIsolatedCompilationService.aidl b/android/composd/aidl/android/system/composd/IIsolatedCompilationService.aidl
index 3748899..dde75e1 100644
--- a/android/composd/aidl/android/system/composd/IIsolatedCompilationService.aidl
+++ b/android/composd/aidl/android/system/composd/IIsolatedCompilationService.aidl
@@ -48,6 +48,5 @@
      * callback, unless the returned ICompilationTask is cancelled. The caller should maintain
      * a reference to the ICompilationTask until compilation completes or is cancelled.
      */
-    ICompilationTask startTestCompile(
-            ApexSource apexSource, ICompilationTaskCallback callback, String os);
+    ICompilationTask startTestCompile(ApexSource apexSource, ICompilationTaskCallback callback);
 }
diff --git a/android/composd/src/instance_manager.rs b/android/composd/src/instance_manager.rs
index cb1f7e4..9e94035 100644
--- a/android/composd/src/instance_manager.rs
+++ b/android/composd/src/instance_manager.rs
@@ -46,12 +46,11 @@
         self.start_instance(CURRENT_INSTANCE_DIR, vm_parameters)
     }
 
-    pub fn start_test_instance(&self, prefer_staged: bool, os: &str) -> Result<CompOsInstance> {
+    pub fn start_test_instance(&self, prefer_staged: bool) -> Result<CompOsInstance> {
         let mut vm_parameters = new_vm_parameters()?;
         vm_parameters.name = String::from("ComposdTest");
         vm_parameters.debug_mode = true;
         vm_parameters.prefer_staged = prefer_staged;
-        vm_parameters.os = os.to_owned();
         self.start_instance(TEST_INSTANCE_DIR, vm_parameters)
     }
 
diff --git a/android/composd/src/service.rs b/android/composd/src/service.rs
index 3cc40af..49cfd3a 100644
--- a/android/composd/src/service.rs
+++ b/android/composd/src/service.rs
@@ -60,7 +60,6 @@
         &self,
         apex_source: ApexSource,
         callback: &Strong<dyn ICompilationTaskCallback>,
-        os: &str,
     ) -> binder::Result<Strong<dyn ICompilationTask>> {
         check_permissions()?;
         let prefer_staged = match apex_source {
@@ -68,7 +67,7 @@
             ApexSource::PreferStaged => true,
             _ => unreachable!("Invalid ApexSource {:?}", apex_source),
         };
-        to_binder_result(self.do_start_test_compile(prefer_staged, callback, os))
+        to_binder_result(self.do_start_test_compile(prefer_staged, callback))
     }
 }
 
@@ -94,12 +93,9 @@
         &self,
         prefer_staged: bool,
         callback: &Strong<dyn ICompilationTaskCallback>,
-        os: &str,
     ) -> Result<Strong<dyn ICompilationTask>> {
-        let comp_os = self
-            .instance_manager
-            .start_test_instance(prefer_staged, os)
-            .context("Starting CompOS")?;
+        let comp_os =
+            self.instance_manager.start_test_instance(prefer_staged).context("Starting CompOS")?;
 
         let target_dir_name = TEST_ARTIFACTS_SUBDIR.to_owned();
         let task = OdrefreshTask::start(
diff --git a/android/composd_cmd/composd_cmd.rs b/android/composd_cmd/composd_cmd.rs
index 6281bd0..6d096a1 100644
--- a/android/composd_cmd/composd_cmd.rs
+++ b/android/composd_cmd/composd_cmd.rs
@@ -46,10 +46,6 @@
         /// If any APEX is staged, prefer the staged version.
         #[clap(long)]
         prefer_staged: bool,
-
-        /// OS for the VM.
-        #[clap(long, default_value = "microdroid")]
-        os: String,
     },
 }
 
@@ -60,7 +56,7 @@
 
     match action {
         Actions::StagedApexCompile {} => run_staged_apex_compile()?,
-        Actions::TestCompile { prefer_staged, os } => run_test_compile(prefer_staged, &os)?,
+        Actions::TestCompile { prefer_staged } => run_test_compile(prefer_staged)?,
     }
 
     println!("All Ok!");
@@ -120,9 +116,9 @@
     run_async_compilation(|service, callback| service.startStagedApexCompile(callback))
 }
 
-fn run_test_compile(prefer_staged: bool, os: &str) -> Result<()> {
+fn run_test_compile(prefer_staged: bool) -> Result<()> {
     let apex_source = if prefer_staged { ApexSource::PreferStaged } else { ApexSource::NoStaged };
-    run_async_compilation(|service, callback| service.startTestCompile(apex_source, callback, os))
+    run_async_compilation(|service, callback| service.startTestCompile(apex_source, callback))
 }
 
 fn run_async_compilation<F>(start_compile_fn: F) -> Result<()>
diff --git a/android/vm/src/run.rs b/android/vm/src/run.rs
index 2157ea8..0037327 100644
--- a/android/vm/src/run.rs
+++ b/android/vm/src/run.rs
@@ -173,6 +173,7 @@
         } else {
             bail!("unexpected architecture!");
         }
+        custom_config.extraKernelCmdlineParams.push(String::from("keep_bootcon"));
     }
 
     let vm_config = VirtualMachineConfig::AppConfig(VirtualMachineAppConfig {
diff --git a/build/debian/build.sh b/build/debian/build.sh
index 1e43b60..dfcffb6 100755
--- a/build/debian/build.sh
+++ b/build/debian/build.sh
@@ -238,6 +238,7 @@
 	)
 # TODO(b/365955006): remove these lines when uboot supports x86_64 EFI application
 elif [[ "$arch" == "x86_64" ]]; then
+	rm -f vmlinuz initrd.img
 	virt-get-kernel -a "${built_image}"
 	mv vmlinuz* vmlinuz
 	mv initrd.img* initrd.img
diff --git a/build/debian/build_in_container.sh b/build/debian/build_in_container.sh
index d5680e0..ef64254 100755
--- a/build/debian/build_in_container.sh
+++ b/build/debian/build_in_container.sh
@@ -23,6 +23,8 @@
   esac
 done
 
-docker run --privileged -it --workdir /root/Virtualization/build/debian -v \
-  "$ANDROID_BUILD_TOP/packages/modules/Virtualization:/root/Virtualization" -v \
-  /dev:/dev ubuntu:22.04 /root/Virtualization/build/debian/build.sh -a "$arch" $release_flag
+docker run --privileged -it -v /dev:/dev \
+  -v "$ANDROID_BUILD_TOP/packages/modules/Virtualization:/root/Virtualization" \
+  --workdir /root/Virtualization/build/debian \
+  ubuntu:22.04 \
+  bash -c "/root/Virtualization/build/debian/build.sh -a "$arch" $release_flag || bash"
diff --git a/libs/libcompos_common/compos_client.rs b/libs/libcompos_common/compos_client.rs
index 6872582..316eaa9 100644
--- a/libs/libcompos_common/compos_client.rs
+++ b/libs/libcompos_common/compos_client.rs
@@ -58,8 +58,6 @@
 pub struct VmParameters {
     /// The name of VM for identifying.
     pub name: String,
-    /// The OS of VM.
-    pub os: String,
     /// Whether the VM should be debuggable.
     pub debug_mode: bool,
     /// CPU topology of the VM. Defaults to 1 vCPU.
@@ -131,7 +129,6 @@
 
         let config = VirtualMachineConfig::AppConfig(VirtualMachineAppConfig {
             name: parameters.name.clone(),
-            osName: parameters.os.clone(),
             apk: Some(apk_fd),
             idsig: Some(idsig_fd),
             instanceId: instance_id,
