diff --git a/src/developer/ffx/build/templates/plugins.rs.jinja b/src/developer/ffx/build/templates/plugins.rs.jinja
index 94ccd6b..ab2a304 100644
--- a/src/developer/ffx/build/templates/plugins.rs.jinja
+++ b/src/developer/ffx/build/templates/plugins.rs.jinja
@@ -127,10 +127,6 @@
 impl fho::FfxTool for SuiteAdapter {
     type Command = {{suite_args_lib}}::FfxPluginCommand;
 
-    fn forces_stdout_log(&self) -> bool {
-      false
-    }
-
     fn supports_machine_output(&self) -> bool {
       ffx_plugin_is_machine_supported(&self.cmd)
     }
diff --git a/src/developer/ffx/command/src/lib.rs b/src/developer/ffx/command/src/lib.rs
index dc0ebe3..6f63e24 100644
--- a/src/developer/ffx/command/src/lib.rs
+++ b/src/developer/ffx/command/src/lib.rs
@@ -161,8 +161,7 @@
         }
     };
 
-    let log_to_stdio = tool.as_ref().map(|tool| tool.forces_stdout_log()).unwrap_or(false);
-    ffx_config::logging::init(&context, log_to_stdio || app.verbose, !log_to_stdio).await?;
+    ffx_config::logging::init(&context, app.verbose, true).await?;
     tracing::info!("starting command: {:?}", Vec::from_iter(cmd.all_iter()));
 
     let metrics = MetricsSession::start(&context).await?;
diff --git a/src/developer/ffx/command/src/tools.rs b/src/developer/ffx/command/src/tools.rs
index 43d67c6..3bd9516 100644
--- a/src/developer/ffx/command/src/tools.rs
+++ b/src/developer/ffx/command/src/tools.rs
@@ -49,7 +49,6 @@
 
 #[async_trait(?Send)]
 pub trait ToolRunner {
-    fn forces_stdout_log(&self) -> bool;
     async fn run(self: Box<Self>, metrics: MetricsSession) -> Result<ExitStatus, Error>;
 }
 
diff --git a/src/developer/ffx/frontends/ffx/BUILD.gn b/src/developer/ffx/frontends/ffx/BUILD.gn
index 0bdea1c..eef891c 100644
--- a/src/developer/ffx/frontends/ffx/BUILD.gn
+++ b/src/developer/ffx/frontends/ffx/BUILD.gn
@@ -47,8 +47,6 @@
     "//src/developer/ffx/daemon/proxy:lib",
     "//src/developer/ffx/lib/errors:lib",
     "//src/developer/ffx/lib/fho/search:lib",
-    "//src/developer/ffx/plugins/daemon:ffx_daemon_plugin_args",
-    "//src/developer/ffx/plugins/daemon:ffx_daemon_plugin_sub_command",
     "//src/lib/fuchsia-async",
     "//third_party/rust_crates:argh",
     "//third_party/rust_crates:async-trait",
diff --git a/src/developer/ffx/frontends/ffx/src/main.rs b/src/developer/ffx/frontends/ffx/src/main.rs
index 47065d3..58c8322 100644
--- a/src/developer/ffx/frontends/ffx/src/main.rs
+++ b/src/developer/ffx/frontends/ffx/src/main.rs
@@ -166,14 +166,6 @@
 
 #[async_trait::async_trait(?Send)]
 impl ToolRunner for FfxSubCommand {
-    /// Whether the given subcommand forces logging to stdout
-    fn forces_stdout_log(&self) -> bool {
-        match &self.cmd {
-            subcommand @ FfxBuiltIn { subcommand: Some(_) } if is_daemon(subcommand) => true,
-            _ => false,
-        }
-    }
-
     async fn run(self: Box<Self>, metrics: MetricsSession) -> Result<ExitStatus> {
         if self.app.global.machine.is_some()
             && !ffx_lib_suite::ffx_plugin_is_machine_supported(&self.cmd)
@@ -261,18 +253,6 @@
     ffx_lib_suite::ffx_plugin_impl(&injector, subcommand).await
 }
 
-fn is_daemon(subcommand: &FfxBuiltIn) -> bool {
-    use ffx_daemon_plugin_args::FfxPluginCommand;
-    use ffx_daemon_plugin_sub_command::SubCommand::FfxDaemonStart;
-    use SubCommand::FfxDaemonPlugin;
-    matches!(
-        subcommand,
-        FfxBuiltIn {
-            subcommand: Some(FfxDaemonPlugin(FfxPluginCommand { subcommand: FfxDaemonStart(_) }))
-        }
-    )
-}
-
 #[fuchsia_async::run_singlethreaded]
 async fn main() {
     let result = ffx_command::run::<FfxSuite>(ExecutableKind::MainFfx).await;
diff --git a/src/developer/ffx/lib/fho/macro/src/errors.rs b/src/developer/ffx/lib/fho/macro/src/errors.rs
index ee325f39..5221b9c 100644
--- a/src/developer/ffx/lib/fho/macro/src/errors.rs
+++ b/src/developer/ffx/lib/fho/macro/src/errors.rs
@@ -7,9 +7,7 @@
 
 #[derive(Debug)]
 pub enum ParseError {
-    MalformedFfxAttr(Span),
     DuplicateAttr(Span),
-    DuplicateFfxAttr(Span),
     CommandRequired(Span),
     OnlyStructsSupported(Span),
     OnlyNamedFieldStructsSupported(Span),
@@ -22,21 +20,11 @@
 impl ToTokens for ParseError {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         match self {
-            ParseError::MalformedFfxAttr(span) => tokens.extend(
-                quote_spanned! {*span=>
-                    std::compile_error!("`#[ffx]` attribute malformed. Must contain a list of property literals. So far only `forces_stdout_logs` is supported.");
-                }
-            ),
             ParseError::DuplicateAttr(span) => tokens.extend(
                 quote_spanned! {*span=>
                     std::compile_error!("Duplicate attribute found. Can only have one attribute kind per field");
                 }
             ),
-            ParseError::DuplicateFfxAttr(span) => tokens.extend(
-                quote_spanned! {*span=>
-                    std::compile_error!("Duplicate ffx attribute found. Can only have one attribute of each kind");
-                }
-            ),
             ParseError::CommandRequired(span) => tokens.extend(
                 quote_spanned! {*span=>
                     std::compile_error!("An ffx tool must have exactly one field denoted with the `#[command]` attribute");
diff --git a/src/developer/ffx/lib/fho/macro/src/structs.rs b/src/developer/ffx/lib/fho/macro/src/structs.rs
index e714394..a310570 100644
--- a/src/developer/ffx/lib/fho/macro/src/structs.rs
+++ b/src/developer/ffx/lib/fho/macro/src/structs.rs
@@ -4,7 +4,7 @@
 
 use crate::{
     errors::ParseError,
-    types::{FfxFlag, FromEnvAttributes, NamedField, NamedFieldTy},
+    types::{FromEnvAttributes, NamedField, NamedFieldTy},
 };
 use proc_macro2::{Span, TokenStream};
 use quote::{quote, quote_spanned, ToTokens};
@@ -178,7 +178,6 @@
 }
 
 pub struct NamedFieldStruct<'a> {
-    forces_stdout_logs: bool,
     command_field_decl: CommandFieldTypeDecl<'a>,
     struct_decl: StructDecl<'a>,
     checks: CheckCollection,
@@ -206,19 +205,18 @@
         let command_field_decl = CommandFieldTypeDecl(extract_command_field(&mut fields)?);
         let struct_decl = StructDecl(&parent_ast);
         let attrs = FromEnvAttributes::from_attrs(&parent_ast.attrs)?;
-        let forces_stdout_logs = attrs.flags.contains(&FfxFlag::ForcesStdoutLogs);
         let checks = CheckCollection(attrs.checks);
         let mut vcc = VariableCreationCollection::new();
         for field in fields.into_iter() {
             vcc.add_field(field)?;
         }
-        Ok(Self { forces_stdout_logs, command_field_decl, struct_decl, checks, vcc })
+        Ok(Self { command_field_decl, struct_decl, checks, vcc })
     }
 }
 
 impl ToTokens for NamedFieldStruct<'_> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let Self { forces_stdout_logs, command_field_decl, struct_decl, checks, vcc } = self;
+        let Self { command_field_decl, struct_decl, checks, vcc } = self;
         let command_field_name = command_field_decl.0.field_name;
         let join_results_names = &vcc.join_results_names;
         let span = Span::call_site();
@@ -245,10 +243,6 @@
                     })
                 }
 
-                fn forces_stdout_log(&self) -> bool {
-                    #forces_stdout_logs
-                }
-
                 fn supports_machine_output(&self) -> bool {
                     <<Self as fho::FfxMain>::Writer as fho::ToolIO>::is_machine_supported()
                 }
diff --git a/src/developer/ffx/lib/fho/macro/src/types.rs b/src/developer/ffx/lib/fho/macro/src/types.rs
index 23ef12b6..a798c11 100644
--- a/src/developer/ffx/lib/fho/macro/src/types.rs
+++ b/src/developer/ffx/lib/fho/macro/src/types.rs
@@ -2,10 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-use std::collections::HashSet;
-
 use crate::errors::ParseError;
-use syn::{spanned::Spanned, ExprCall, NestedMeta};
+use syn::{spanned::Spanned, ExprCall};
 
 fn attr_name(attr: &syn::Attribute) -> Result<String, ParseError> {
     if attr.path.segments.len() == 1 {
@@ -15,11 +13,6 @@
     }
 }
 
-fn is_forces_stdout_logs_path(path: &syn::Path) -> bool {
-    path.segments.len() == 1
-        && path.segments.first().unwrap().ident == FfxFlag::ForcesStdoutLogs.to_string().as_str()
-}
-
 #[derive(Clone, Debug)]
 pub struct NamedField<'a> {
     pub field_ty: &'a syn::Type,
@@ -57,9 +50,6 @@
                         attr.parse_args().map_err(|_| ParseError::InvalidWithAttr(attr.span()))?;
                     res.replace(Self::With(expr, NamedField { field_ty, field_name }));
                 }
-                name @ ("ffx" | "check") => {
-                    return Err(ParseError::UnexpectedAttr(name.to_owned(), attr.span()));
-                }
                 _ => {} // ignore unknown attributes (like derive)
             }
         }
@@ -67,58 +57,16 @@
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub enum FfxFlag {
-    ForcesStdoutLogs,
-}
-
-impl ToString for FfxFlag {
-    fn to_string(&self) -> String {
-        match self {
-            Self::ForcesStdoutLogs => "forces_stdout_logs".to_owned(),
-        }
-    }
-}
-
-impl TryFrom<&NestedMeta> for FfxFlag {
-    type Error = ParseError;
-    fn try_from(value: &NestedMeta) -> Result<Self, Self::Error> {
-        match value {
-            syn::NestedMeta::Meta(syn::Meta::Path(path)) if is_forces_stdout_logs_path(path) => {
-                Ok(Self::ForcesStdoutLogs)
-            }
-            _ => Err(ParseError::MalformedFfxAttr(value.span())),
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct FromEnvAttributes {
-    pub flags: HashSet<FfxFlag>,
     pub checks: Vec<ExprCall>,
 }
 
 impl FromEnvAttributes {
     pub fn from_attrs(attrs: &Vec<syn::Attribute>) -> Result<Self, ParseError> {
-        let mut flags = HashSet::new();
         let mut checks = Vec::new();
         for attr in attrs.iter() {
             match attr_name(attr)?.as_str() {
-                "ffx" => {
-                    let meta_list = match attr
-                        .parse_meta()
-                        .map_err(|_| ParseError::MalformedFfxAttr(attr.span()))?
-                    {
-                        syn::Meta::List(list) => Ok(list),
-                        meta => Err(ParseError::MalformedFfxAttr(meta.span())),
-                    }?;
-                    for item in &meta_list.nested {
-                        let flag = item.try_into()?;
-                        if !flags.insert(flag) {
-                            return Err(ParseError::DuplicateFfxAttr(item.span()));
-                        }
-                    }
-                }
                 "check" => checks.push(
                     attr.parse_args().map_err(|_| ParseError::InvalidCheckAttr(attr.span()))?,
                 ),
@@ -128,7 +76,7 @@
                 _ => {} // ignore unknown attributes
             }
         }
-        Ok(Self { flags, checks })
+        Ok(Self { checks })
     }
 }
 
@@ -138,72 +86,6 @@
     use crate::testing::parse_macro_derive;
 
     #[test]
-    fn test_parse_ffx_attr_ty() {
-        let ast = parse_macro_derive(
-            r#"
-            #[derive(FfxTool)]
-            #[ffx(forces_stdout_logs)]
-            struct Foo {}
-            "#,
-        );
-        assert!(
-            FromEnvAttributes::from_attrs(&ast.attrs)
-                .unwrap()
-                .flags
-                .contains(&FfxFlag::ForcesStdoutLogs),
-            "Expected forces_stdout_logs attribute"
-        );
-    }
-
-    #[test]
-    fn test_parse_ffx_attr_ty_failure_duplicate() {
-        let ast = parse_macro_derive(
-            r#"
-            #[derive(FfxTool)]
-            #[ffx(forces_stdout_logs, forces_stdout_logs)]
-            struct Foo {}
-            "#,
-        );
-        match FromEnvAttributes::from_attrs(&ast.attrs) {
-            Ok(r) => panic!("Expected failure. Instead received {r:?}"),
-            Err(ParseError::DuplicateFfxAttr(_)) => {}
-            e => panic!("Received unexpected error: {e:?}"),
-        }
-    }
-
-    #[test]
-    fn test_parse_ffx_attr_ty_typo() {
-        let ast = parse_macro_derive(
-            r#"
-            #[derive(FfxTool)]
-            #[ffx(force_stdout_loggerooooo)]
-            struct Foo {}
-            "#,
-        );
-        match FromEnvAttributes::from_attrs(&ast.attrs) {
-            Ok(r) => panic!("Expected failure. Instead received {r:?}"),
-            Err(ParseError::MalformedFfxAttr(_)) => {}
-            e => panic!("Received unexpected error: {e:?}"),
-        }
-    }
-
-    #[test]
-    fn test_parse_ffx_attr_ty_empty() {
-        let ast = parse_macro_derive(
-            r#"
-            #[derive(FfxTool)]
-            #[ffx]
-            struct Foo {}
-            "#,
-        );
-        match FromEnvAttributes::from_attrs(&ast.attrs) {
-            Ok(r) => panic!("Expected failure. Instead received {r:?}"),
-            Err(ParseError::MalformedFfxAttr(_)) => {}
-            e => panic!("Received unexpected error: {e:?}"),
-        }
-    }
-
-    #[test]
     fn test_parse_ffx_attr_ty_check() {
         let ast = parse_macro_derive(
             r#"
diff --git a/src/developer/ffx/lib/fho/search/src/lib.rs b/src/developer/ffx/lib/fho/search/src/lib.rs
index 80473f8..fb3f114 100644
--- a/src/developer/ffx/lib/fho/search/src/lib.rs
+++ b/src/developer/ffx/lib/fho/search/src/lib.rs
@@ -46,10 +46,6 @@
 
 #[async_trait::async_trait(?Send)]
 impl ToolRunner for ExternalSubTool {
-    fn forces_stdout_log(&self) -> bool {
-        false
-    }
-
     async fn run(self: Box<Self>, _metrics: MetricsSession) -> Result<ExitStatus> {
         // fho v0: Run the exact same command, just with the first argument
         // replaced with the 'real' tool location. We will also exec() it so
diff --git a/src/developer/ffx/lib/fho/src/subtool.rs b/src/developer/ffx/lib/fho/src/subtool.rs
index be48835..0591f43 100644
--- a/src/developer/ffx/lib/fho/src/subtool.rs
+++ b/src/developer/ffx/lib/fho/src/subtool.rs
@@ -22,7 +22,6 @@
 pub trait FfxTool: FfxMain + Sized {
     type Command: FromArgs + SubCommand + ArgsInfo;
 
-    fn forces_stdout_log(&self) -> bool;
     fn supports_machine_output(&self) -> bool;
     fn has_schema(&self) -> bool;
 
@@ -99,10 +98,6 @@
 
 #[async_trait(?Send)]
 impl ToolRunner for MetadataRunner {
-    fn forces_stdout_log(&self) -> bool {
-        false
-    }
-
     async fn run(self: Box<Self>, _metrics: MetricsSession) -> Result<ExitStatus> {
         // We don't ever want to emit metrics for a metadata query, it's a tool-level
         // command
@@ -123,10 +118,6 @@
 
 #[async_trait(?Send)]
 impl<T: FfxTool> ToolRunner for FhoTool<T> {
-    fn forces_stdout_log(&self) -> bool {
-        self.main.forces_stdout_log()
-    }
-
     async fn run(self: Box<Self>, metrics: MetricsSession) -> Result<ExitStatus> {
         metrics.print_notice(&mut std::io::stderr()).await?;
         let writer = TryFromEnv::try_from_env(&self.env).await?;
diff --git a/src/developer/ffx/lib/fho/src/testing.rs b/src/developer/ffx/lib/fho/src/testing.rs
index bf17bf5..a2cc2c8 100644
--- a/src/developer/ffx/lib/fho/src/testing.rs
+++ b/src/developer/ffx/lib/fho/src/testing.rs
@@ -221,7 +221,6 @@
     }
 
     #[derive(fho_macro::FfxTool, Debug)]
-    #[ffx(forces_stdout_logs)]
     #[check(SimpleCheck(true))]
     pub struct FakeTool {
         from_env_string: NewTypeString,