diff --git a/.gitignore b/.gitignore
index c8985e0..224a7ea 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+/docs
+
 /target
 *.zip
 *.txt
@@ -14,4 +16,4 @@ MultiTool.yaml
 # Remove any workers user for development
 /worker/**
 wrangler.toml
-wrangler.json
\ No newline at end of file
+wrangler.json
diff --git a/src/adapters/backend/deploy_meta.rs b/src/adapters/backend/deploy_meta.rs
index 7f40969..7769d53 100644
--- a/src/adapters/backend/deploy_meta.rs
+++ b/src/adapters/backend/deploy_meta.rs
@@ -16,7 +16,7 @@ pub(crate) type RolloutId = u64;
 /// rollout. This struct is mostly used in conjuction with a `BackendClient`
 /// to hold the context for the current rollout.
 #[derive(Builder, Getters, Clone)]
-pub(crate) struct RolloutMetadata {
+pub struct RolloutMetadata {
     workspace_id: WorkspaceId,
     application_id: ApplicationId,
     rollout_id: RolloutId,
diff --git a/src/adapters/backend/mod.rs b/src/adapters/backend/mod.rs
index 3c615e3..402dc1e 100644
--- a/src/adapters/backend/mod.rs
+++ b/src/adapters/backend/mod.rs
@@ -23,7 +23,7 @@ use tokio::sync::mpsc::Sender;
 use tokio::sync::oneshot;
 use tokio::time::Duration;
 
-pub(crate) use deploy_meta::*;
+pub use deploy_meta::*;
 use tracing::trace;
 
 /// Write the CLI's version to a
@@ -84,7 +84,7 @@ impl BackendClient {
 
     pub fn is_authenicated(&self) -> Result<()> {
         if self.session.clone().is_some_and(Session::is_not_expired) {
-            return Ok(());
+            Ok(())
         } else {
             bail!("Please login before running this command.");
         }
@@ -343,9 +343,9 @@ impl BackendClient {
             };
             let metrics = StatusCodeMetrics {
                 app_group: group,
-                status_2xx_count: item.get_count(&ResponseStatusCode::_2XX) as u32,
-                status_4xx_count: item.get_count(&ResponseStatusCode::_4XX) as u32,
-                status_5xx_count: item.get_count(&ResponseStatusCode::_5XX) as u32,
+                status_2xx_count: item.get_count(&ResponseStatusCode::_2XX),
+                status_4xx_count: item.get_count(&ResponseStatusCode::_4XX),
+                status_5xx_count: item.get_count(&ResponseStatusCode::_5XX),
                 created_at: item.created_at().to_rfc3339(),
             };
 
@@ -427,8 +427,8 @@ impl BackendClient {
 
     pub(crate) async fn create_application<T: AsRef<str>>(
         &self,
-        workspace_id: WorkspaceId,
-        name: T,
+        _workspace_id: WorkspaceId,
+        _name: T,
     ) -> Result<ApplicationDetails> {
         self.is_authenicated()?;
 
@@ -454,7 +454,7 @@ impl BackendClient {
 
         if workspaces.len() > 1 {
             bail!("More than one workspace with the given name found.");
-        } else if workspaces.len() < 1 {
+        } else if workspaces.is_empty() {
             bail!("No workspace with the given name exists for this account");
         } else {
             // TODO: We can simplify this code with .ok_or()
@@ -488,7 +488,7 @@ impl BackendClient {
 
         let application = if applications.len() > 1 {
             bail!("More than one application with the given name found.");
-        } else if applications.len() < 1 {
+        } else if applications.is_empty() {
             bail!("No application with the given name exists for this account");
         } else {
             // TODO: We can simplify this code with .ok_or()
@@ -535,8 +535,8 @@ impl BackendConfig {
         // • Convert the Option<T> to a String.
         let origin = origin.map(|val| val.as_ref().to_owned());
         // • Set up the default configuration values.
-        let jwt = session.and_then(|session| match session {
-            Session::User(creds) => Some(creds.jwt),
+        let jwt = session.map(|session| match session {
+            Session::User(creds) => creds.jwt,
         });
         let conf = Configuration {
             base_path: origin.unwrap_or(MULTITOOL_ORIGIN.to_string()),
diff --git a/src/adapters/cloudflare/deployments.rs b/src/adapters/cloudflare/deployments.rs
index a4b83ae..02825a8 100644
--- a/src/adapters/cloudflare/deployments.rs
+++ b/src/adapters/cloudflare/deployments.rs
@@ -2,18 +2,13 @@ use bon::Builder;
 use derive_getters::Getters;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 pub enum DeploymentStrategy {
     #[serde(rename = "percentage")]
+    #[default]
     Percentage,
 }
 
-impl Default for DeploymentStrategy {
-    fn default() -> Self {
-        Self::Percentage
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Builder, Getters)]
 pub struct CreateDeploymentRequest {
     #[serde(default)]
diff --git a/src/adapters/cloudflare/metrics.rs b/src/adapters/cloudflare/metrics.rs
index 4de3781..4c06798 100644
--- a/src/adapters/cloudflare/metrics.rs
+++ b/src/adapters/cloudflare/metrics.rs
@@ -49,6 +49,7 @@ pub struct EventData {
 
 #[derive(Deserialize, Debug)]
 pub struct RequestData {
+    #[allow(dead_code)] // TODO: Why is this dead?
     pub url: String,
     pub method: String,
     pub path: String,
@@ -78,11 +79,11 @@ pub struct CloudflareErrorLog {
     pub logs: Vec<String>,
 }
 
-impl Into<Vec<CloudflareErrorLog>> for ErrorLogsResponse {
-    fn into(self) -> Vec<CloudflareErrorLog> {
+impl From<ErrorLogsResponse> for Vec<CloudflareErrorLog> {
+    fn from(val: ErrorLogsResponse) -> Self {
         let mut error_logs = Vec::new();
 
-        for (_request_id, invocations) in self.invocations {
+        for (_request_id, invocations) in val.invocations {
             // The cf-worker-event entry contains the request/response details
             let event_entry = invocations
                 .iter()
diff --git a/src/adapters/cloudflare/mod.rs b/src/adapters/cloudflare/mod.rs
index 2dc6355..14e03ca 100644
--- a/src/adapters/cloudflare/mod.rs
+++ b/src/adapters/cloudflare/mod.rs
@@ -398,8 +398,8 @@ impl CloudflareClient {
         let count = metrics_response
             .result
             .calculations
-            .get(0)
-            .and_then(|c| c.aggregates.get(0).cloned())
+            .first()
+            .and_then(|c| c.aggregates.first().cloned())
             .map_or(0, |a| a.count);
 
         Ok(count)
diff --git a/src/adapters/cloudflare/uploads.rs b/src/adapters/cloudflare/uploads.rs
index 0704e18..4954a7c 100644
--- a/src/adapters/cloudflare/uploads.rs
+++ b/src/adapters/cloudflare/uploads.rs
@@ -4,6 +4,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::{adapters::cloudflare::deployments::Binding, fs::wrangler::Wrangler};
 
+// this is probably dead because we bundle the upload,
+// which we won't do in the future.
+#[allow(dead_code)]
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct UploadSessionResponse {
     pub jwt: String,
@@ -11,6 +14,9 @@ pub struct UploadSessionResponse {
     pub buckets: Vec<Vec<String>>,
 }
 
+// this is probably dead because we bundle the upload,
+// which we won't do in the future.
+#[allow(dead_code)]
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct UploadAssetsResponse {
     pub jwt: String,
diff --git a/src/adapters/ingresses/apig.rs b/src/adapters/ingresses/apig.rs
index a172508..ec16485 100644
--- a/src/adapters/ingresses/apig.rs
+++ b/src/adapters/ingresses/apig.rs
@@ -68,14 +68,12 @@ impl AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -110,14 +108,12 @@ impl AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -157,14 +153,12 @@ impl AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -217,14 +211,12 @@ impl Ingress for AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -256,14 +248,12 @@ impl Ingress for AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -291,14 +281,12 @@ impl Ingress for AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -337,14 +325,12 @@ impl Ingress for AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -394,14 +380,12 @@ impl Ingress for AwsApiGateway {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
diff --git a/src/adapters/mod.rs b/src/adapters/mod.rs
index 6ff6097..6cd7490 100644
--- a/src/adapters/mod.rs
+++ b/src/adapters/mod.rs
@@ -1,7 +1,8 @@
-pub use backend::BackendClient;
-pub(crate) use backend::{LockedState, RolloutMetadata};
+pub use backend::{BackendClient, RolloutMetadata};
 pub use cloudflare::CloudflareClient;
 
+pub(crate) use backend::LockedState;
+
 pub use ingresses::*;
 pub use monitors::*;
 pub use platforms::*;
diff --git a/src/adapters/platforms/lambda.rs b/src/adapters/platforms/lambda.rs
index 443dae1..20f1751 100644
--- a/src/adapters/platforms/lambda.rs
+++ b/src/adapters/platforms/lambda.rs
@@ -72,14 +72,12 @@ impl Platform for LambdaPlatform {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
@@ -115,14 +113,12 @@ impl Platform for LambdaPlatform {
                 let error_message = match err {
                     SdkError::ServiceError(service_err) => {
                         // Extract the specific service error details
-                        format!(
-                            "{}",
-                            service_err
-                                .err()
-                                .meta()
-                                .message()
-                                .unwrap_or("No error message found")
-                        )
+                        service_err
+                            .err()
+                            .meta()
+                            .message()
+                            .unwrap_or("No error message found")
+                            .to_string()
                     }
                     _ => format!("{:?}", err),
                 };
diff --git a/src/adapters/platforms/mod.rs b/src/adapters/platforms/mod.rs
index e7c9a6a..7bd3776 100644
--- a/src/adapters/platforms/mod.rs
+++ b/src/adapters/platforms/mod.rs
@@ -36,6 +36,7 @@ impl Shutdownable for MockPlatform {
 
 mod cloudflare;
 mod lambda;
+mod vercel;
 
 #[cfg(test)]
 mod tests {
diff --git a/src/adapters/platforms/vercel.rs b/src/adapters/platforms/vercel.rs
new file mode 100644
index 0000000..02990a6
--- /dev/null
+++ b/src/adapters/platforms/vercel.rs
@@ -0,0 +1,56 @@
+#![allow(dead_code)]
+// TODO: This module will not be dead code once we allow the Vercel
+// platform to be constructed.
+
+use crate::{Shutdownable, adapters::backend::PlatformConfig, subsystems::ShutdownResult};
+
+use super::Platform;
+use async_trait::async_trait;
+use derive_getters::Getters;
+use miette::Result;
+
+// Placeholder: Eventually, we will implement a proper Vercel client.
+// For now, we mock this as a unit type since we know it will be a required
+// parameter later.
+type VercelClient = ();
+
+#[derive(Getters)]
+pub struct Vercel {
+    client: VercelClient,
+}
+
+impl Vercel {
+    pub fn new(client: VercelClient) -> Self {
+        Self { client }
+    }
+}
+
+#[async_trait]
+impl Platform for Vercel {
+    fn get_config(&self) -> PlatformConfig {
+        todo!();
+    }
+
+    async fn deploy(&mut self) -> Result<(String, String)> {
+        todo!();
+    }
+
+    async fn yank_canary(&mut self) -> Result<()> {
+        todo!();
+    }
+
+    async fn delete_canary(&mut self) -> Result<()> {
+        todo!();
+    }
+
+    async fn promote_rollout(&mut self) -> Result<()> {
+        todo!();
+    }
+}
+
+#[async_trait]
+impl Shutdownable for Vercel {
+    async fn shutdown(&mut self) -> ShutdownResult {
+        todo!();
+    }
+}
diff --git a/src/artifacts/cloudflare/manifest.rs b/src/artifacts/cloudflare/manifest.rs
index ecb5138..c3e9107 100644
--- a/src/artifacts/cloudflare/manifest.rs
+++ b/src/artifacts/cloudflare/manifest.rs
@@ -45,17 +45,17 @@ impl CloudflareFileManifest {
             let file_entry = entry.into_diagnostic()?;
 
             // Ignore directories, we only want files.
-            if file_entry.file_type().map_or(false, |ft| ft.is_dir()) {
+            if file_entry.file_type().is_some_and(|ft| ft.is_dir()) {
                 continue;
             }
 
             let file_path = file_entry.path().to_path_buf();
 
             // Skip files with names that match manifest filenames
-            if let Some(filename) = file_path.file_name().and_then(|n| n.to_str()) {
-                if manifest_filenames.contains(&filename.to_string()) {
-                    continue;
-                }
+            if let Some(filename) = file_path.file_name().and_then(|n| n.to_str())
+                && manifest_filenames.contains(&filename.to_string())
+            {
+                continue;
             }
 
             files.push(file_path);
diff --git a/src/artifacts/cloudflare/mod.rs b/src/artifacts/cloudflare/mod.rs
index 9e777d2..1307492 100644
--- a/src/artifacts/cloudflare/mod.rs
+++ b/src/artifacts/cloudflare/mod.rs
@@ -11,6 +11,9 @@ pub(crate) use manifest::CloudflareFileManifest;
 
 mod manifest;
 
+// this is probably dead because we bundle the upload,
+// which we won't do in the future.
+#[allow(dead_code)]
 pub async fn read_file_as_b64<P: AsRef<Path>>(filepath: P, sink: &mut impl Write) -> Result<()> {
     let path = filepath.as_ref();
     let mut encoder = EncoderWriter::new(sink, &STANDARD);
diff --git a/src/cmd/init.rs b/src/cmd/init.rs
index b272f89..817c1e7 100644
--- a/src/cmd/init.rs
+++ b/src/cmd/init.rs
@@ -53,7 +53,7 @@ impl Init {
             // the toml and toml_edit crates to preserve comments
             // in the TOML files we read.
             // https://docs.rs/toml_edit/latest/toml_edit/
-            if let Ok(_) = fs.application_manifest() {
+            if fs.application_manifest().is_ok() {
                 info!(
                     "It looks like you already have an initialized application manifest. Exiting."
                 );
@@ -268,6 +268,7 @@ impl InitStateMachine for PromptWorkspace {
 struct PromptApplication {
     manifest: Arc<Mutex<Manifest>>,
     terminal: Arc<Terminal>,
+    #[allow(dead_code)] // TODO: why is this field unused?
     fs: FileSystem,
     workspace_id: u32,
     backend: BackendClient,
@@ -318,7 +319,7 @@ impl InitStateMachine for PromptApplication {
             // Create the application
             // Since we have a todo! in the create_application method,
             // this code will not actually run until that's implemented
-            let application = match self
+            let _application = match self
                 .backend
                 .create_application(self.workspace_id, application_name.clone())
                 .await
diff --git a/src/cmd/run/mod.rs b/src/cmd/run/mod.rs
index 348d94f..f30b255 100644
--- a/src/cmd/run/mod.rs
+++ b/src/cmd/run/mod.rs
@@ -10,7 +10,7 @@ use multitool_sdk::models::{ApplicationDetails, WorkspaceSummary};
 use thiserror::Error;
 use tokio::join;
 use tokio::runtime::Runtime;
-use tracing::{debug, error, info};
+use tracing::{debug, info};
 
 use crate::Terminal;
 
@@ -102,7 +102,7 @@ impl Run {
         let workspace_not_found =
             miette!("The workspace {name} does not exist within your account.");
         self.backend
-            .get_workspace_by_name(&name)
+            .get_workspace_by_name(name)
             .await
             .context(workspace_not_found)
     }
@@ -135,7 +135,7 @@ impl Run {
         let application_not_found =
             miette!("The application {name} does not exist within the workspace {workspace_name}.");
         self.backend
-            .get_application_by_name(workspace.id, &name)
+            .get_application_by_name(workspace.id, name)
             .await
             .context(application_not_found)
     }
diff --git a/src/config/cli.rs b/src/config/cli.rs
index d6017f6..a573f36 100644
--- a/src/config/cli.rs
+++ b/src/config/cli.rs
@@ -1,4 +1,4 @@
-use clap::{Parser, command};
+use clap::Parser;
 use derive_getters::Getters;
 use tracing::level_filters::LevelFilter;
 
diff --git a/src/config/mod.rs b/src/config/mod.rs
index 909700d..4aca83e 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -1,7 +1,6 @@
 pub use cli::Cli;
 pub use init::InitSubcommand;
 pub use login::LoginSubcommand;
-pub use proxy::ProxySubcommand;
 pub use run::RunSubcommand;
 
 mod cli;
diff --git a/src/fs/manifest/schema.rs b/src/fs/manifest/schema.rs
index aa899ba..871f97c 100644
--- a/src/fs/manifest/schema.rs
+++ b/src/fs/manifest/schema.rs
@@ -3,7 +3,6 @@ use std::{path::PathBuf, sync::OnceLock};
 use miette::{Diagnostic, miette};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use tracing::error;
 
 use crate::{
     adapters::{
@@ -307,7 +306,7 @@ impl AwsLambdaConfig {
             return Ok(path.to_path_buf());
         }
 
-        return Ok(PathBuf::from(&self.artifact_path));
+        Ok(PathBuf::from(&self.artifact_path))
     }
 
     async fn load_platform(&self, args: &RunSubcommand) -> Result<BoxedPlatform> {
diff --git a/src/fs/mod.rs b/src/fs/mod.rs
index f500d5c..2c61be6 100644
--- a/src/fs/mod.rs
+++ b/src/fs/mod.rs
@@ -233,6 +233,9 @@ pub enum DirectoryType {
     /// The directory for non-essential project files
     Cache,
     /// Persistent data lives here between runs.
+    // We will probably need this later, like when we need to check
+    // version expiration dates without phoning home.
+    #[allow(dead_code)]
     Data,
     /// The application root directory is the dir that contains the manifest
     /// file relevant to the current operating context. It's usually
diff --git a/src/fs/wrangler.rs b/src/fs/wrangler.rs
index 28317a6..7ed43b0 100644
--- a/src/fs/wrangler.rs
+++ b/src/fs/wrangler.rs
@@ -3,6 +3,8 @@ use derive_getters::Getters;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
+// TODO: Check whether this type is actually needed.
+#[allow(dead_code)]
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct Vars {
     #[serde(flatten)]
diff --git a/src/numbers/mod.rs b/src/numbers/mod.rs
index 99f6261..379710a 100644
--- a/src/numbers/mod.rs
+++ b/src/numbers/mod.rs
@@ -3,7 +3,10 @@ use std::fmt;
 
 pub(crate) use errors::OutOfRangeError;
 
+// TODO: why is this type unused?
+#[allow(dead_code)]
 pub type CpuUsage = FixedPrecisionNumber<2>;
+
 pub use whole_number::WholeNumber;
 pub use whole_percent::WholePercent;
 
diff --git a/src/stats/contingency.rs b/src/stats/contingency.rs
index 8a8b10d..953f96c 100644
--- a/src/stats/contingency.rs
+++ b/src/stats/contingency.rs
@@ -1,3 +1,7 @@
+#![allow(dead_code)]
+// We may eventually remove this module, since I think it has been
+// superseded by code on the backend, but I'm not totally sure.
+
 use std::num::NonZeroUsize;
 
 use crate::stats::{Categorical, histogram::Histogram};
diff --git a/src/stats/histogram.rs b/src/stats/histogram.rs
index 066ee2d..409be48 100644
--- a/src/stats/histogram.rs
+++ b/src/stats/histogram.rs
@@ -60,20 +60,23 @@ where
 
     /// Reset all bins to zero.
     pub fn clear(&mut self) {
-        self.bins = Box::new([0; N]);
+        *self.bins = [0; N];
     }
 
     /// Reset the given bins to zero.
+    #[allow(dead_code)]
     fn clear_category(&mut self, cat: &C) {
         let index = cat.category();
         self.bins[index] = 0;
     }
 
+    #[allow(dead_code)]
     pub(super) fn set_count(&mut self, cat: &C, count: u32) {
         self.clear_category(cat);
         self.increment_by(cat, count);
     }
 
+    #[allow(dead_code)]
     pub(super) fn get_count_by_index(&self, i: usize) -> u32 {
         if i >= N {
             panic!(
diff --git a/src/subsystems/controller/mod.rs b/src/subsystems/controller/mod.rs
index c19154f..aa92adc 100644
--- a/src/subsystems/controller/mod.rs
+++ b/src/subsystems/controller/mod.rs
@@ -2,13 +2,12 @@ use async_trait::async_trait;
 use bon::bon;
 use miette::{Report, Result};
 use tokio_graceful_shutdown::{IntoSubsystem, SubsystemBuilder, SubsystemHandle};
-use tracing::{debug, error, trace};
+use tracing::{debug, trace};
 
 use crate::adapters::{BackendClient, BoxedIngress, BoxedMonitor, BoxedPlatform, RolloutMetadata};
 use crate::subsystems::PLATFORM_SUBSYSTEM_NAME;
 use crate::{IngressSubsystem, PlatformSubsystem};
 
-use crate::subsystems::{ERROR_LOGS_SUBSYSTEM_NAME, ErrorLogsController};
 use monitor::{MONITOR_CONTROLLER_SUBSYSTEM_NAME, MonitorController};
 
 use super::{INGRESS_SUBSYSTEM_NAME, RELAY_SUBSYSTEM_NAME, RelaySubsystem};
diff --git a/src/subsystems/error_logs/mod.rs b/src/subsystems/error_logs/mod.rs
index 8c19d04..89ffd60 100644
--- a/src/subsystems/error_logs/mod.rs
+++ b/src/subsystems/error_logs/mod.rs
@@ -1,3 +1,9 @@
+#![allow(dead_code)]
+// This module temporarily allows dead code, because we initially
+// built it to demo the Agentic SRE functionality, which we are
+// not currently productionizing. We will remove this code if we
+// choose not to productionize, or make use of it if we do.
+
 use std::time::Duration;
 
 use crate::adapters::{BackendClient, RolloutMetadata};
@@ -14,8 +20,8 @@ use crate::adapters::{CloudflareClient, backend::MonitorConfig};
 /// The frequency with which we poll Cloudflare for error logs.
 const DEFAULT_POLL_INTERVAL: Duration = Duration::from_secs(60);
 
-/// The name of the error logs subsystem.
-pub const ERROR_LOGS_SUBSYSTEM_NAME: &str = "errorlogs";
+// The name of the error logs subsystem.
+// pub const ERROR_LOGS_SUBSYSTEM_NAME: &str = "errorlogs";
 
 /// The ErrorLogsController is responsible for periodically fetching
 /// error logs from Cloudflare.
diff --git a/src/subsystems/handle.rs b/src/subsystems/handle.rs
index bed94f3..5b7ae04 100644
--- a/src/subsystems/handle.rs
+++ b/src/subsystems/handle.rs
@@ -9,7 +9,7 @@ use super::{ShutdownResult, Shutdownable};
 /// A handle to a thread, communicating over a channel.
 /// The type `M` can be specialized to implement communication
 /// with different subsystems.
-pub(crate) struct Handle<M> {
+pub struct Handle<M> {
     pub(super) outbox: Arc<Sender<M>>,
     pub(super) shutdown_trigger: Arc<Sender<()>>,
 }
diff --git a/src/subsystems/mod.rs b/src/subsystems/mod.rs
index 9edeb95..88b8910 100644
--- a/src/subsystems/mod.rs
+++ b/src/subsystems/mod.rs
@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use miette::Diagnostic;
 
 pub use controller::{CONTROLLER_SUBSYSTEM_NAME, ControllerSubsystem};
-pub use error_logs::{ERROR_LOGS_SUBSYSTEM_NAME, ErrorLogsController};
+// pub use error_logs::{ERROR_LOGS_SUBSYSTEM_NAME, ErrorLogsController};
 pub use ingress::{INGRESS_SUBSYSTEM_NAME, IngressSubsystem};
 
 pub use monitor::{MONITOR_SUBSYSTEM_NAME, MonitorSubsystem};
diff --git a/src/subsystems/monitor/mail.rs b/src/subsystems/monitor/mail.rs
index 0cb4305..9d53a6f 100644
--- a/src/subsystems/monitor/mail.rs
+++ b/src/subsystems/monitor/mail.rs
@@ -44,13 +44,13 @@ impl<T: Observation + Send + 'static> Monitor for MonitorHandle<T> {
     }
 }
 
-pub(crate) enum MonitorMail<T: Observation> {
+pub enum MonitorMail<T: Observation> {
     Query(QueryParams<T>),
     SetBaselineVersionId(VersionParams),
     SetCanaryVersionId(VersionParams),
 }
 
-pub(crate) struct QueryParams<T: Observation> {
+pub struct QueryParams<T: Observation> {
     /// The sender where the response is written.
     pub(super) outbox: oneshot::Sender<QueryResp<T>>,
 }
@@ -61,7 +61,7 @@ impl<T: Observation> QueryParams<T> {
     }
 }
 
-pub(crate) struct VersionParams {
+pub struct VersionParams {
     /// The sender where the response is written.
     pub(super) outbox: oneshot::Sender<VersionResp>,
     pub(super) version_id: String,
diff --git a/src/terminal/logging.rs b/src/terminal/logging.rs
index ff0a7bd..652575d 100644
--- a/src/terminal/logging.rs
+++ b/src/terminal/logging.rs
@@ -26,7 +26,7 @@ pub(super) fn setup_logger(level: LevelFilter) {
             .with_line_number(false)
             .with_target(false)
             // Scope the subscriber to ONLY the multitool module.
-            .with_env_filter(format!("multitool={}", level.to_string()))
+            .with_env_filter(format!("multitool={}", level))
             .compact()
             .finish();
 
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index 32a6f45..b26ebcc 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -18,7 +18,7 @@ pub async fn load_default_aws_config() -> &'static SdkConfig {
 async fn load_config() -> SdkConfig {
     // We don't need a particular version, but we pin to one to ensure
     // it doesn't accidently slip if `latest` gets updated without our knowledge.
-    let behavior = BehaviorVersion::v2025_01_17();
+    let behavior = BehaviorVersion::v2025_08_07();
     aws_config::load_defaults(behavior).await
 }