diff --git a/compos/composd/src/compilation_task.rs b/compos/composd/src/compilation_task.rs
deleted file mode 100644
index 871c4fb..0000000
--- a/compos/composd/src/compilation_task.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use crate::instance_starter::CompOsInstance;
-use crate::odrefresh::Odrefresh;
-use android_system_composd::aidl::android::system::composd::{
-    ICompilationTask::ICompilationTask, ICompilationTaskCallback::ICompilationTaskCallback,
-};
-use android_system_composd::binder::{Interface, Result as BinderResult, Strong};
-use anyhow::Result;
-use compos_common::odrefresh::ExitCode;
-use log::{error, warn};
-use std::sync::{Arc, Mutex};
-use std::thread;
-
-// TODO: Delete
-
-#[derive(Clone)]
-pub struct CompilationTask {
-    running_task: Arc<Mutex<Option<RunningTask>>>,
-}
-
-impl Interface for CompilationTask {}
-
-impl ICompilationTask for CompilationTask {
-    fn cancel(&self) -> BinderResult<()> {
-        let task = self.take();
-        if let Some(task) = task {
-            if let Err(e) = task.odrefresh.kill() {
-                warn!("Failed to kill running task: {:?}", e)
-            }
-        }
-        Ok(())
-    }
-}
-
-impl CompilationTask {
-    /// Return the current running task, if any, removing it from this CompilationTask.
-    /// Once removed, meaning the task has ended or been canceled, further calls will always return
-    /// None.
-    fn take(&self) -> Option<RunningTask> {
-        self.running_task.lock().unwrap().take()
-    }
-
-    pub fn start_staged_apex_compile(
-        comp_os: Arc<CompOsInstance>,
-        callback: &Strong<dyn ICompilationTaskCallback>,
-    ) -> Result<CompilationTask> {
-        // TODO: Write to pending
-        // TODO: Delete any existing artifacts
-        let odrefresh = Odrefresh::spawn_compile("test-artifacts")?;
-        let odrefresh = Arc::new(odrefresh);
-        let task =
-            RunningTask { odrefresh: odrefresh.clone(), comp_os, callback: callback.clone() };
-        let task = CompilationTask { running_task: Arc::new(Mutex::new(Some(task))) };
-
-        task.clone().start_waiting_thread(odrefresh);
-
-        Ok(task)
-    }
-
-    pub fn start_test_compile(
-        comp_os: Arc<CompOsInstance>,
-        callback: &Strong<dyn ICompilationTaskCallback>,
-    ) -> Result<CompilationTask> {
-        let odrefresh = Odrefresh::spawn_forced_compile("test-artifacts")?;
-        let odrefresh = Arc::new(odrefresh);
-        let task =
-            RunningTask { odrefresh: odrefresh.clone(), comp_os, callback: callback.clone() };
-        let task = CompilationTask { running_task: Arc::new(Mutex::new(Some(task))) };
-
-        task.clone().start_waiting_thread(odrefresh);
-
-        Ok(task)
-    }
-
-    fn start_waiting_thread(self, odrefresh: Arc<Odrefresh>) {
-        thread::spawn(move || {
-            let exit_code = odrefresh.wait_for_exit();
-            let task = self.take();
-            // We don't do the callback if cancel has already happened.
-            if let Some(task) = task {
-                let result = match exit_code {
-                    Ok(ExitCode::CompilationSuccess) => task.callback.onSuccess(),
-                    Ok(exit_code) => {
-                        error!("Unexpected odrefresh result: {:?}", exit_code);
-                        task.callback.onFailure()
-                    }
-                    Err(e) => {
-                        error!("Running odrefresh failed: {:?}", e);
-                        task.callback.onFailure()
-                    }
-                };
-                if let Err(e) = result {
-                    warn!("Failed to deliver callback: {:?}", e);
-                }
-            }
-        });
-    }
-}
-
-struct RunningTask {
-    odrefresh: Arc<Odrefresh>,
-    callback: Strong<dyn ICompilationTaskCallback>,
-    #[allow(dead_code)] // Keeps the CompOS VM alive
-    comp_os: Arc<CompOsInstance>,
-}
diff --git a/compos/composd/src/composd_main.rs b/compos/composd/src/composd_main.rs
index 6f1e951..df088bc 100644
--- a/compos/composd/src/composd_main.rs
+++ b/compos/composd/src/composd_main.rs
@@ -18,12 +18,10 @@
 //! responsible for managing the lifecycle of the CompOS VM instances, providing key management for
 //! them, and orchestrating trusted compilation.
 
-mod compilation_task;
 mod fd_server_helper;
 mod instance_manager;
 mod instance_starter;
 mod internal_service;
-mod odrefresh;
 mod odrefresh_task;
 mod service;
 
diff --git a/compos/composd/src/odrefresh.rs b/compos/composd/src/odrefresh.rs
deleted file mode 100644
index a6ca995..0000000
--- a/compos/composd/src/odrefresh.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-//! Handle the details of executing odrefresh to generate compiled artifacts.
-
-// TODO: Delete
-
-use anyhow::{bail, Context, Result};
-use compos_common::odrefresh::{ExitCode, ODREFRESH_PATH};
-use compos_common::timeouts::{need_extra_time, EXTENDED_TIMEOUTS};
-use compos_common::VMADDR_CID_ANY;
-use shared_child::SharedChild;
-use std::process::Command;
-
-pub struct Odrefresh {
-    child: SharedChild,
-}
-
-impl Odrefresh {
-    pub fn spawn_compile(target_dir: &str) -> Result<Self> {
-        Self::spawn_odrefresh(target_dir, "--compile")
-    }
-
-    pub fn spawn_forced_compile(target_dir: &str) -> Result<Self> {
-        Self::spawn_odrefresh(target_dir, "--force-compile")
-    }
-
-    fn spawn_odrefresh(target_dir: &str, compile_arg: &str) -> Result<Self> {
-        // We don`t need to capture stdout/stderr - odrefresh writes to the log
-        let mut cmdline = Command::new(ODREFRESH_PATH);
-        if need_extra_time()? {
-            cmdline
-                .arg(format!(
-                    "--max-execution-seconds={}",
-                    EXTENDED_TIMEOUTS.odrefresh_max_execution_time.as_secs()
-                ))
-                .arg(format!(
-                    "--max-child-process-seconds={}",
-                    EXTENDED_TIMEOUTS.odrefresh_max_child_process_time.as_secs()
-                ));
-        }
-        cmdline
-            .arg(format!("--use-compilation-os={}", VMADDR_CID_ANY as i32))
-            .arg(format!("--dalvik-cache={}", target_dir))
-            .arg(compile_arg);
-        let child = SharedChild::spawn(&mut cmdline).context("Running odrefresh")?;
-        Ok(Odrefresh { child })
-    }
-
-    pub fn wait_for_exit(&self) -> Result<ExitCode> {
-        // No timeout here - but clients can kill the process, which will end the wait.
-        let status = self.child.wait()?;
-        if let Some(exit_code) = status.code() {
-            ExitCode::from_i32(exit_code)
-        } else {
-            bail!("odrefresh exited with {}", status)
-        }
-    }
-
-    pub fn kill(&self) -> Result<()> {
-        self.child.kill().context("Killing odrefresh process failed")
-    }
-}
diff --git a/compos/composd/src/service.rs b/compos/composd/src/service.rs
index 69cf008..093e428 100644
--- a/compos/composd/src/service.rs
+++ b/compos/composd/src/service.rs
@@ -17,7 +17,6 @@
 //! Implementation of IIsolatedCompilationService, called from system server when compilation is
 //! desired.
 
-use crate::compilation_task::CompilationTask;
 use crate::instance_manager::InstanceManager;
 use crate::odrefresh_task::OdrefreshTask;
 use android_system_composd::aidl::android::system::composd::{
@@ -62,14 +61,6 @@
         check_permissions()?;
         to_binder_result(self.do_start_test_compile(callback))
     }
-
-    fn startAsyncOdrefresh(
-        &self,
-        callback: &Strong<dyn ICompilationTaskCallback>,
-    ) -> binder::Result<Strong<dyn ICompilationTask>> {
-        check_permissions()?;
-        to_binder_result(self.do_start_async_odrefresh(callback))
-    }
 }
 
 impl IsolatedCompilationService {
@@ -80,7 +71,9 @@
         // TODO: Try to start the current instance with staged APEXes to see if it works?
         let comp_os = self.instance_manager.start_pending_instance().context("Starting CompOS")?;
 
-        let task = CompilationTask::start_staged_apex_compile(comp_os, callback)?;
+        // TODO: Write to compos-pending instead
+        let target_dir_name = "test-artifacts".to_owned();
+        let task = OdrefreshTask::start(comp_os, target_dir_name, callback)?;
 
         Ok(BnCompilationTask::new_binder(task, BinderFeatures::default()))
     }
@@ -91,17 +84,6 @@
     ) -> Result<Strong<dyn ICompilationTask>> {
         let comp_os = self.instance_manager.start_test_instance().context("Starting CompOS")?;
 
-        let task = CompilationTask::start_test_compile(comp_os, callback)?;
-
-        Ok(BnCompilationTask::new_binder(task, BinderFeatures::default()))
-    }
-
-    fn do_start_async_odrefresh(
-        &self,
-        callback: &Strong<dyn ICompilationTaskCallback>,
-    ) -> Result<Strong<dyn ICompilationTask>> {
-        let comp_os = self.instance_manager.start_test_instance().context("Starting CompOS")?;
-
         let target_dir_name = "test-artifacts".to_owned();
         let task = OdrefreshTask::start(comp_os, target_dir_name, callback)?;