diff --git a/docker/Dockerfile b/docker/Dockerfile
index 53097d50..cbb504dc 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -91,8 +91,8 @@ ARG rpc_port=3030
 ARG ws_port=1337
 
 ENV DATABASE_URL=${database_url} \
-    HOMESTAR__NODE__NETWORK__RPC_HOST=${rpc_host} \
-    HOMESTAR__NODE__NETWORK__RPC_PORT=${rpc_port} \
+    HOMESTAR__NODE__NETWORK__RPC__HOST=${rpc_host} \
+    HOMESTAR__NODE__NETWORK__RPC__PORT=${rpc_port} \
     HOMESTAR__NODE__NETWORK__WS_PORT=${ws_port}
 
 EXPOSE ${rpc_port} ${ws_port}
diff --git a/examples/websocket-relay/src/main.rs b/examples/websocket-relay/src/main.rs
index 35b77ec0..d5b00051 100644
--- a/examples/websocket-relay/src/main.rs
+++ b/examples/websocket-relay/src/main.rs
@@ -10,7 +10,7 @@ use tracing::info;
 
 fn main() -> Result<()> {
     let settings = Settings::load().expect("runtime settings to be loaded");
-    let _guard = Logger::init(settings.monitoring());
+    let _guard = Logger::init(settings.node().monitoring());
 
     // Just for example purposes, we're going to start the ipfs
     // daemon. Typically, these would be started separately.
diff --git a/homestar-runtime/config/settings.toml b/homestar-runtime/config/settings.toml
index 2be540be..291536a1 100644
--- a/homestar-runtime/config/settings.toml
+++ b/homestar-runtime/config/settings.toml
@@ -1,6 +1,8 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 5000
-metrics_port = 4000
-console_subscriber_port = 5555
+console_subscriber_port = 6669
 
-[node]
+[node.network.metrics]
+port = 4000
diff --git a/homestar-runtime/fixtures/defaults.toml b/homestar-runtime/fixtures/defaults.toml
new file mode 100644
index 00000000..29aad8af
--- /dev/null
+++ b/homestar-runtime/fixtures/defaults.toml
@@ -0,0 +1,74 @@
+[node]
+gc_interval = 1800
+shutdown_timeout = 20
+
+[node.database]
+url = "homestar.db"
+max_pool_size = 100
+
+[node.monitoring]
+process_collector_interval = 5000
+console_subscriber_port = 6669
+
+[node.network]
+events_buffer_len = 1024
+poll_cache_interval = 1000
+
+[node.network.ipfs]
+host = "127.0.0.1"
+port = 5001
+
+[node.network.libp2p]
+listen_address = "/ip4/0.0.0.0/tcp/0"
+node_addresses = []
+announce_addresses = []
+transport_connection_timeout = 60
+max_connected_peers = 32
+max_announce_addresses = 10
+
+[node.network.libp2p.mdns]
+enable = true
+enable_ipv6 = false
+query_interval = 300
+ttl = 540
+
+[node.network.libp2p.rendezvous]
+enable_client = true
+enable_server = false
+registration_ttl = 7200
+discovery_interval = 600
+
+[node.network.libp2p.pubsub]
+enable = true
+duplication_cache_time = 1
+heartbeat = 60
+idle_timeout = 86400
+max_transmit_size = 10485760
+mesh_n_low = 1
+mesh_n_high = 10
+mesh_n = 2
+mesh_outbound_min = 1
+
+[node.network.libp2p.dht]
+p2p_provider_timeout = 30
+receipt_quorum = 2
+workflow_quorum = 3
+
+[node.network.keypair_config]
+random = {}
+
+[node.network.metrics]
+port = 4000
+
+[node.network.rpc]
+host = "::1"
+port = 3030
+max_connections = 10
+server_timeout = 120
+
+[node.network.webserver]
+host = "127.0.0.1"
+port = 1337
+timeout = 120
+websocket_capacity = 2048
+websocket_receiver_timeout = 30000
diff --git a/homestar-runtime/fixtures/settings.toml b/homestar-runtime/fixtures/settings.toml
index 9561abe7..5c11b12c 100644
--- a/homestar-runtime/fixtures/settings.toml
+++ b/homestar-runtime/fixtures/settings.toml
@@ -2,5 +2,9 @@
 
 [node.network]
 events_buffer_len = 1000
-webserver_port = 9999
+
+[node.network.webserver]
+port = 9999
+
+[node.network.libp2p]
 node_addresses = ["/ip4/127.0.0.1/tcp/9998/ws"]
diff --git a/homestar-runtime/src/event_handler.rs b/homestar-runtime/src/event_handler.rs
index 8d9ef988..fdc6e9d9 100644
--- a/homestar-runtime/src/event_handler.rs
+++ b/homestar-runtime/src/event_handler.rs
@@ -114,12 +114,12 @@ where
     DB: Database,
 {
     fn setup_channel(
-        settings: &settings::Node,
+        settings: &settings::Network,
     ) -> (
         channel::AsyncChannelSender<Event>,
         channel::AsyncChannelReceiver<Event>,
     ) {
-        channel::AsyncChannel::with(settings.network.events_buffer_len)
+        channel::AsyncChannel::with(settings.events_buffer_len)
     }
 
     /// Create an [EventHandler] with channel sender/receiver defaults.
@@ -127,16 +127,16 @@ where
     pub(crate) fn new(
         swarm: Swarm<ComposedBehaviour>,
         db: DB,
-        settings: &settings::Node,
+        settings: &settings::Network,
         ws_evt_sender: webserver::Notifier<notifier::Message>,
         ws_workflow_sender: webserver::Notifier<notifier::Message>,
     ) -> Self {
         let (sender, receiver) = Self::setup_channel(settings);
         let sender = Arc::new(sender);
         Self {
-            receipt_quorum: settings.network.receipt_quorum,
-            workflow_quorum: settings.network.workflow_quorum,
-            p2p_provider_timeout: settings.network.p2p_provider_timeout,
+            receipt_quorum: settings.libp2p.dht.receipt_quorum,
+            workflow_quorum: settings.libp2p.dht.workflow_quorum,
+            p2p_provider_timeout: settings.libp2p.dht.p2p_provider_timeout,
             db,
             swarm,
             cache: Arc::new(setup_cache(sender.clone())),
@@ -146,33 +146,37 @@ where
             request_response_senders: FnvHashMap::default(),
             connections: Connections {
                 peers: FnvHashMap::default(),
-                max_peers: settings.network.max_connected_peers,
+                max_peers: settings.libp2p.max_connected_peers,
             },
             rendezvous: Rendezvous {
-                registration_ttl: settings.network.rendezvous_registration_ttl,
-                discovery_interval: settings.network.rendezvous_discovery_interval,
+                registration_ttl: settings.libp2p.rendezvous.registration_ttl,
+                discovery_interval: settings.libp2p.rendezvous.discovery_interval,
                 discovered_peers: FnvHashMap::default(),
                 cookies: FnvHashMap::default(),
             },
-            pubsub_enabled: settings.network.enable_pubsub,
+            pubsub_enabled: settings.libp2p.pubsub.enable,
             ws_evt_sender,
             ws_workflow_sender,
-            node_addresses: settings.network.node_addresses.clone(),
-            announce_addresses: settings.network.announce_addresses.clone(),
-            external_address_limit: settings.network.max_announce_addresses,
-            poll_cache_interval: settings.network.poll_cache_interval,
+            node_addresses: settings.libp2p.node_addresses.clone(),
+            announce_addresses: settings.libp2p.announce_addresses.clone(),
+            external_address_limit: settings.libp2p.max_announce_addresses,
+            poll_cache_interval: settings.poll_cache_interval,
         }
     }
 
     /// Create an [EventHandler] with channel sender/receiver defaults.
     #[cfg(not(feature = "websocket-notify"))]
-    pub(crate) fn new(swarm: Swarm<ComposedBehaviour>, db: DB, settings: &settings::Node) -> Self {
+    pub(crate) fn new(
+        swarm: Swarm<ComposedBehaviour>,
+        db: DB,
+        settings: &settings::Network,
+    ) -> Self {
         let (sender, receiver) = Self::setup_channel(settings);
         let sender = Arc::new(sender);
         Self {
-            receipt_quorum: settings.network.receipt_quorum,
-            workflow_quorum: settings.network.workflow_quorum,
-            p2p_provider_timeout: settings.network.p2p_provider_timeout,
+            receipt_quorum: settings.libp2p.dht.receipt_quorum,
+            workflow_quorum: settings.libp2p.dht.workflow_quorum,
+            p2p_provider_timeout: settings.libp2p.dht.p2p_provider_timeout,
             db,
             swarm,
             cache: Arc::new(setup_cache(sender.clone())),
@@ -182,19 +186,19 @@ where
             request_response_senders: FnvHashMap::default(),
             connections: Connections {
                 peers: FnvHashMap::default(),
-                max_peers: settings.network.max_connected_peers,
+                max_peers: settings.libp2p.max_connected_peers,
             },
             rendezvous: Rendezvous {
-                registration_ttl: settings.network.rendezvous_registration_ttl,
-                discovery_interval: settings.network.rendezvous_discovery_interval,
+                registration_ttl: settings.libp2p.rendezvous.registration_ttl,
+                discovery_interval: settings.libp2p.rendezvous.discovery_interval,
                 discovered_peers: FnvHashMap::default(),
                 cookies: FnvHashMap::default(),
             },
-            pubsub_enabled: settings.network.enable_pubsub,
-            node_addresses: settings.network.node_addresses.clone(),
-            announce_addresses: settings.network.announce_addresses.clone(),
-            external_address_limit: settings.network.max_announce_addresses,
-            poll_cache_interval: settings.network.poll_cache_interval,
+            pubsub_enabled: settings.libp2p.pubsub.enable,
+            node_addresses: settings.libp2p.node_addresses.clone(),
+            announce_addresses: settings.libp2p.announce_addresses.clone(),
+            external_address_limit: settings.libp2p.max_announce_addresses,
+            poll_cache_interval: settings.poll_cache_interval,
         }
     }
 
diff --git a/homestar-runtime/src/main.rs b/homestar-runtime/src/main.rs
index 4ba64d86..f9fce8f7 100644
--- a/homestar-runtime/src/main.rs
+++ b/homestar-runtime/src/main.rs
@@ -30,9 +30,9 @@ fn main() -> Result<()> {
             let _guard = if daemonize {
                 daemon::start(daemon_dir.clone())
                     .expect("runner to be started as a daemon process");
-                FileLogger::init(daemon_dir, settings.monitoring())
+                FileLogger::init(daemon_dir, settings.node().monitoring())
             } else {
-                Logger::init(settings.monitoring())
+                Logger::init(settings.node().monitoring())
             };
 
             info!(
diff --git a/homestar-runtime/src/metrics/exporter.rs b/homestar-runtime/src/metrics/exporter.rs
index 52d52168..5c027aa4 100644
--- a/homestar-runtime/src/metrics/exporter.rs
+++ b/homestar-runtime/src/metrics/exporter.rs
@@ -16,7 +16,7 @@ pub(crate) fn setup_metrics_recorder(
         0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0,
     ];
 
-    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), settings.metrics_port);
+    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), settings.metrics.port);
 
     let (recorder, exporter) = PrometheusBuilder::new()
         .set_buckets_for_metric(
diff --git a/homestar-runtime/src/network/pubsub.rs b/homestar-runtime/src/network/pubsub.rs
index 051f76c7..fafe48a7 100644
--- a/homestar-runtime/src/network/pubsub.rs
+++ b/homestar-runtime/src/network/pubsub.rs
@@ -24,7 +24,7 @@ pub(crate) const RECEIPTS_TOPIC: &str = "receipts";
 /// Setup [gossipsub] mesh protocol with default configuration.
 ///
 /// [gossipsub]: libp2p::gossipsub
-pub(crate) fn new(keypair: Keypair, settings: &settings::Node) -> Result<gossipsub::Behaviour> {
+pub(crate) fn new(keypair: Keypair, settings: &settings::Pubsub) -> Result<gossipsub::Behaviour> {
     // To content-address message, we can take the hash of message and use it as an ID.
     let message_id_fn = |message: &gossipsub::Message| {
         let mut s = DefaultHasher::new();
@@ -33,18 +33,18 @@ pub(crate) fn new(keypair: Keypair, settings: &settings::Node) -> Result<gossips
     };
 
     let gossipsub_config = ConfigBuilder::default()
-        .heartbeat_interval(settings.network.pubsub_heartbeat)
-        .idle_timeout(settings.network.pubsub_idle_timeout)
+        .heartbeat_interval(settings.heartbeat)
+        .idle_timeout(settings.idle_timeout)
         // This sets the kind of message validation. The default is Strict (enforce message signing).
         .validation_mode(ValidationMode::Strict)
-        .max_transmit_size(settings.network.pubsub_max_transmit_size)
-        .mesh_n_low(settings.network.pubsub_mesh_n_low)
-        .mesh_outbound_min(settings.network.pubsub_mesh_outbound_min)
-        .mesh_n(settings.network.pubsub_mesh_n)
-        .mesh_n_high(settings.network.pubsub_mesh_n_high)
+        .max_transmit_size(settings.max_transmit_size)
+        .mesh_n_low(settings.mesh_n_low)
+        .mesh_outbound_min(settings.mesh_outbound_min)
+        .mesh_n(settings.mesh_n)
+        .mesh_n_high(settings.mesh_n_high)
         // Content-address messages. No two messages of the same content will be propagated.
         .message_id_fn(message_id_fn)
-        .duplicate_cache_time(settings.network.pubsub_duplication_cache_time)
+        .duplicate_cache_time(settings.duplication_cache_time)
         .support_floodsub()
         .build()
         .map_err(anyhow::Error::msg)?;
diff --git a/homestar-runtime/src/network/rpc.rs b/homestar-runtime/src/network/rpc.rs
index c9c046a2..667f1d9c 100644
--- a/homestar-runtime/src/network/rpc.rs
+++ b/homestar-runtime/src/network/rpc.rs
@@ -160,12 +160,12 @@ impl Server {
     pub(crate) fn new(settings: &settings::Network, runner_sender: Arc<RpcSender>) -> Self {
         let (tx, rx) = AsyncChannel::oneshot();
         Self {
-            addr: SocketAddr::new(settings.rpc_host, settings.rpc_port),
+            addr: SocketAddr::new(settings.rpc.host, settings.rpc.port),
             sender: tx.into(),
             receiver: rx,
             runner_sender,
-            max_connections: settings.rpc_max_connections,
-            timeout: settings.rpc_server_timeout,
+            max_connections: settings.rpc.max_connections,
+            timeout: settings.rpc.server_timeout,
         }
     }
 
diff --git a/homestar-runtime/src/network/swarm.rs b/homestar-runtime/src/network/swarm.rs
index 642939a5..ce638854 100644
--- a/homestar-runtime/src/network/swarm.rs
+++ b/homestar-runtime/src/network/swarm.rs
@@ -35,9 +35,8 @@ use tracing::{info, warn};
 pub(crate) const HOMESTAR_PROTOCOL_VER: &str = "homestar/0.0.1";
 
 /// Build a new [Swarm] with a given transport and a tokio executor.
-pub(crate) async fn new(settings: &settings::Node) -> Result<Swarm<ComposedBehaviour>> {
+pub(crate) async fn new(settings: &settings::Network) -> Result<Swarm<ComposedBehaviour>> {
     let keypair = settings
-        .network
         .keypair_config
         .keypair()
         .with_context(|| "failed to generate/import keypair for libp2p".to_string())?;
@@ -49,14 +48,14 @@ pub(crate) async fn new(settings: &settings::Node) -> Result<Swarm<ComposedBehav
         .upgrade(upgrade::Version::V1Lazy)
         .authenticate(noise::Config::new(&keypair)?)
         .multiplex(yamux::Config::default())
-        .timeout(settings.network.transport_connection_timeout)
+        .timeout(settings.libp2p.transport_connection_timeout)
         .boxed();
 
     let mut swarm = Swarm::new(
         transport,
         ComposedBehaviour {
-            gossipsub: Toggle::from(if settings.network.enable_pubsub {
-                Some(pubsub::new(keypair.clone(), settings)?)
+            gossipsub: Toggle::from(if settings.libp2p.pubsub.enable {
+                Some(pubsub::new(keypair.clone(), settings.libp2p().pubsub())?)
             } else {
                 None
             }),
@@ -85,24 +84,24 @@ pub(crate) async fn new(settings: &settings::Node) -> Result<Swarm<ComposedBehav
                 )],
                 request_response::Config::default(),
             ),
-            mdns: Toggle::from(if settings.network.enable_mdns {
+            mdns: Toggle::from(if settings.libp2p.mdns.enable {
                 Some(mdns::Behaviour::new(
                     mdns::Config {
-                        ttl: settings.network.mdns_ttl,
-                        query_interval: settings.network.mdns_query_interval,
-                        enable_ipv6: settings.network.mdns_enable_ipv6,
+                        ttl: settings.libp2p.mdns.ttl,
+                        query_interval: settings.libp2p.mdns.query_interval,
+                        enable_ipv6: settings.libp2p.mdns.enable_ipv6,
                     },
                     peer_id,
                 )?)
             } else {
                 None
             }),
-            rendezvous_client: Toggle::from(if settings.network.enable_rendezvous_client {
+            rendezvous_client: Toggle::from(if settings.libp2p.rendezvous.enable_client {
                 Some(rendezvous::client::Behaviour::new(keypair.clone()))
             } else {
                 None
             }),
-            rendezvous_server: Toggle::from(if settings.network.enable_rendezvous_server {
+            rendezvous_server: Toggle::from(if settings.libp2p.rendezvous.enable_server {
                 Some(rendezvous::server::Behaviour::new(
                     rendezvous::server::Config::with_min_ttl(
                         rendezvous::server::Config::default(),
@@ -121,7 +120,7 @@ pub(crate) async fn new(settings: &settings::Node) -> Result<Swarm<ComposedBehav
         swarm::Config::with_tokio_executor(),
     );
 
-    init(&mut swarm, &settings.network)?;
+    init(&mut swarm, settings)?;
 
     Ok(swarm)
 }
@@ -139,7 +138,7 @@ pub(crate) fn init(
     settings: &settings::Network,
 ) -> Result<()> {
     // Listen-on given address
-    swarm.listen_on(settings.listen_address.to_string().parse()?)?;
+    swarm.listen_on(settings.libp2p.listen_address.to_string().parse()?)?;
 
     // Set Kademlia server mode
     swarm
@@ -148,8 +147,8 @@ pub(crate) fn init(
         .set_mode(Some(kad::Mode::Server));
 
     // add external addresses from settings
-    if !settings.announce_addresses.is_empty() {
-        for addr in settings.announce_addresses.iter() {
+    if !settings.libp2p.announce_addresses.is_empty() {
+        for addr in settings.libp2p.announce_addresses.iter() {
             swarm.add_external_address(addr.clone());
         }
     } else {
@@ -160,8 +159,8 @@ pub(crate) fn init(
     }
 
     // Dial nodes specified in settings. Failure here shouldn't halt node startup.
-    for (index, addr) in settings.node_addresses.iter().enumerate() {
-        if index < settings.max_connected_peers as usize {
+    for (index, addr) in settings.libp2p.node_addresses.iter().enumerate() {
+        if index < settings.libp2p.max_connected_peers as usize {
             let _ = swarm
                 .dial(addr.clone())
                 // log dial failure and continue
@@ -184,7 +183,7 @@ pub(crate) fn init(
         }
     }
 
-    if settings.enable_pubsub {
+    if settings.libp2p.pubsub.enable {
         // join `receipts` topic
         swarm
             .behaviour_mut()
diff --git a/homestar-runtime/src/network/webserver.rs b/homestar-runtime/src/network/webserver.rs
index 9cfba640..8a2e1c4f 100644
--- a/homestar-runtime/src/network/webserver.rs
+++ b/homestar-runtime/src/network/webserver.rs
@@ -112,11 +112,11 @@ impl Server {
     }
 
     #[cfg(feature = "websocket-notify")]
-    pub(crate) fn new(settings: &settings::Network) -> Result<Self> {
+    pub(crate) fn new(settings: &settings::Webserver) -> Result<Self> {
         let (evt_sender, _receiver) = Self::setup_channel(settings.websocket_capacity);
         let (msg_sender, _receiver) = Self::setup_channel(settings.websocket_capacity);
-        let host = IpAddr::from_str(&settings.webserver_host.to_string())?;
-        let port_setting = settings.webserver_port;
+        let host = IpAddr::from_str(&settings.host.to_string())?;
+        let port_setting = settings.port;
         let addr = if port_available(host, port_setting) {
             SocketAddr::from((host, port_setting))
         } else {
@@ -132,14 +132,14 @@ impl Server {
             evt_notifier: Notifier::new(evt_sender),
             workflow_msg_notifier: Notifier::new(msg_sender),
             receiver_timeout: settings.websocket_receiver_timeout,
-            webserver_timeout: settings.webserver_timeout,
+            webserver_timeout: settings.timeout,
         })
     }
 
     #[cfg(not(feature = "websocket-notify"))]
-    pub(crate) fn new(settings: &settings::Network) -> Result<Self> {
-        let host = IpAddr::from_str(&settings.webserver_host.to_string())?;
-        let port_setting = settings.webserver_port;
+    pub(crate) fn new(settings: &settings::Webserver) -> Result<Self> {
+        let host = IpAddr::from_str(&settings.host.to_string())?;
+        let port_setting = settings.port;
         let addr = if port_available(host, port_setting) {
             SocketAddr::from((host, port_setting))
         } else {
@@ -153,7 +153,7 @@ impl Server {
             addr,
             capacity: settings.websocket_capacity,
             receiver_timeout: settings.websocket_receiver_timeout,
-            webserver_timeout: settings.webserver_timeout,
+            webserver_timeout: settings.timeout,
         })
     }
 
@@ -272,9 +272,10 @@ mod test {
 
     async fn metrics_handle(settings: Settings) -> PrometheusHandle {
         #[cfg(feature = "monitoring")]
-        let metrics_hdl = crate::metrics::start(settings.monitoring(), settings.node.network())
-            .await
-            .unwrap();
+        let metrics_hdl =
+            crate::metrics::start(settings.node.monitoring(), settings.node.network())
+                .await
+                .unwrap();
 
         #[cfg(not(feature = "monitoring"))]
         let metrics_hdl = crate::metrics::start(settings.node.network())
@@ -288,7 +289,7 @@ mod test {
     fn ws_connect() {
         let TestRunner { runner, settings } = TestRunner::start();
         runner.runtime.block_on(async {
-            let server = Server::new(settings.node().network()).unwrap();
+            let server = Server::new(settings.node().network().webserver()).unwrap();
             let metrics_hdl = metrics_handle(settings).await;
             let (runner_tx, _runner_rx) = AsyncChannel::oneshot();
             server.start(runner_tx, metrics_hdl).await.unwrap();
@@ -330,7 +331,7 @@ mod test {
     async fn ws_metrics_no_prefix() {
         let TestRunner { runner, settings } = TestRunner::start();
         runner.runtime.block_on(async {
-            let server = Server::new(settings.node().network()).unwrap();
+            let server = Server::new(settings.node().network().webserver()).unwrap();
             let metrics_hdl = metrics_handle(settings).await;
             let (runner_tx, _runner_rx) = AsyncChannel::oneshot();
             server.start(runner_tx, metrics_hdl).await.unwrap();
@@ -363,7 +364,7 @@ mod test {
     async fn ws_subscribe_unsubscribe_network_events() {
         let TestRunner { runner, settings } = TestRunner::start();
         runner.runtime.block_on(async {
-            let server = Server::new(settings.node().network()).unwrap();
+            let server = Server::new(settings.node().network().webserver()).unwrap();
             let metrics_hdl = metrics_handle(settings).await;
             let (runner_tx, _runner_rx) = AsyncChannel::oneshot();
             server.start(runner_tx, metrics_hdl).await.unwrap();
@@ -440,7 +441,7 @@ mod test {
     async fn ws_subscribe_workflow_incorrect_params() {
         let TestRunner { runner, settings } = TestRunner::start();
         runner.runtime.block_on(async {
-            let server = Server::new(settings.node().network()).unwrap();
+            let server = Server::new(settings.node().network().webserver()).unwrap();
             let metrics_hdl = metrics_handle(settings).await;
             let (runner_tx, _runner_rx) = AsyncChannel::oneshot();
             server.start(runner_tx, metrics_hdl).await.unwrap();
@@ -474,7 +475,7 @@ mod test {
     async fn ws_subscribe_workflow_runner_timeout() {
         let TestRunner { runner, settings } = TestRunner::start();
         runner.runtime.block_on(async {
-            let server = Server::new(settings.node().network()).unwrap();
+            let server = Server::new(settings.node().network().webserver()).unwrap();
             let metrics_hdl = metrics_handle(settings).await;
             let (runner_tx, _runner_rx) = AsyncChannel::oneshot();
             server.start(runner_tx, metrics_hdl).await.unwrap();
diff --git a/homestar-runtime/src/runner.rs b/homestar-runtime/src/runner.rs
index 0cffccae..ed6217a6 100644
--- a/homestar-runtime/src/runner.rs
+++ b/homestar-runtime/src/runner.rs
@@ -165,10 +165,10 @@ impl Runner {
         db: impl Database + 'static,
         runtime: tokio::runtime::Runtime,
     ) -> Result<Self> {
-        let swarm = runtime.block_on(swarm::new(settings.node()))?;
+        let swarm = runtime.block_on(swarm::new(settings.node().network()))?;
         let peer_id = *swarm.local_peer_id();
 
-        let webserver = webserver::Server::new(settings.node().network())?;
+        let webserver = webserver::Server::new(settings.node().network().webserver())?;
 
         #[cfg(feature = "websocket-notify")]
         let (ws_msg_tx, ws_evt_tx) = {
@@ -179,9 +179,10 @@ impl Runner {
         };
 
         #[cfg(feature = "websocket-notify")]
-        let event_handler = EventHandler::new(swarm, db, settings.node(), ws_evt_tx, ws_msg_tx);
+        let event_handler =
+            EventHandler::new(swarm, db, settings.node().network(), ws_evt_tx, ws_msg_tx);
         #[cfg(not(feature = "websocket-notify"))]
-        let event_handler = EventHandler::new(swarm, db, settings.node());
+        let event_handler = EventHandler::new(swarm, db, settings.node().network());
 
         let event_sender = event_handler.sender();
 
@@ -213,7 +214,7 @@ impl Runner {
 
         #[cfg(feature = "monitoring")]
         let metrics_hdl: PrometheusHandle = self.runtime.block_on(crate::metrics::start(
-            self.settings.monitoring(),
+            self.settings.node.monitoring(),
             self.settings.node.network(),
         ))?;
 
@@ -300,7 +301,7 @@ impl Runner {
                                 info!("getting node info");
                                 let (tx, rx) = AsyncChannel::oneshot();
                                 let _ = self.event_sender.send_async(Event::GetListeners(tx)).await;
-                                let dyn_node_info = if let Ok(listeners) = rx.recv_deadline(Instant::now() + self.settings.node.network.webserver_timeout) {
+                                let dyn_node_info = if let Ok(listeners) = rx.recv_deadline(Instant::now() + self.settings.node.network.webserver.timeout) {
                                     DynamicNodeInfo::new(listeners)
                                 } else {
                                     DynamicNodeInfo::new(vec![])
@@ -699,16 +700,17 @@ mod test {
         let rpc_sender = rpc_server.sender();
 
         let addr = SocketAddr::new(
-            settings.node.network.rpc_host,
-            settings.node.network.rpc_port,
+            settings.node.network.rpc.host,
+            settings.node.network.rpc.port,
         );
 
         let ws_hdl = runner.runtime.block_on(async {
             rpc_server.spawn().await.unwrap();
             #[cfg(feature = "monitoring")]
-            let metrics_hdl = crate::metrics::start(settings.monitoring(), settings.node.network())
-                .await
-                .unwrap();
+            let metrics_hdl =
+                crate::metrics::start(settings.node.monitoring(), settings.node.network())
+                    .await
+                    .unwrap();
             #[cfg(not(feature = "monitoring"))]
             let metrics_hdl = crate::metrics::start(settings.node.network())
                 .await
@@ -758,8 +760,8 @@ mod test {
 
         runner.runtime.spawn(async move {
             let addr = SocketAddr::new(
-                settings.node.network.rpc_host,
-                settings.node.network.rpc_port,
+                settings.node.network.rpc.host,
+                settings.node.network.rpc.port,
             );
 
             let client = Client::new(addr, context::current()).await.unwrap();
diff --git a/homestar-runtime/src/settings.rs b/homestar-runtime/src/settings.rs
index 928a63f5..f82c97ea 100644
--- a/homestar-runtime/src/settings.rs
+++ b/homestar-runtime/src/settings.rs
@@ -13,7 +13,9 @@ use std::{
     time::Duration,
 };
 
+mod libp2p_config;
 mod pubkey_config;
+pub(crate) use libp2p_config::{Libp2p, Pubsub};
 pub(crate) use pubkey_config::PubkeyConfig;
 
 #[cfg(target_os = "windows")]
@@ -24,42 +26,25 @@ const HOME_VAR: &str = "HOME";
 /// Application settings.
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct Settings {
-    #[serde(default)]
-    pub(crate) monitoring: Monitoring,
     #[serde(default)]
     pub(crate) node: Node,
 }
 
 impl Settings {
-    /// Monitoring settings getter.
-    pub fn monitoring(&self) -> &Monitoring {
-        &self.monitoring
-    }
-
     /// Node settings getter.
     pub fn node(&self) -> &Node {
         &self.node
     }
 }
 
-/// Monitoring settings.
-#[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[serde(default)]
-pub struct Monitoring {
-    /// Tokio console port.
-    pub console_subscriber_port: u16,
-    /// Monitoring collection interval in milliseconds.
-    #[cfg(feature = "monitoring")]
-    #[serde_as(as = "DurationMilliSeconds<u64>")]
-    pub process_collector_interval: Duration,
-}
-
 /// Server settings.
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
 pub struct Node {
+    /// Monitoring settings.
+    #[serde(default)]
+    pub(crate) monitoring: Monitoring,
     /// Network settings.
     #[serde(default)]
     pub(crate) network: Network,
@@ -74,145 +59,156 @@ pub struct Node {
     pub(crate) shutdown_timeout: Duration,
 }
 
-/// Network-related settings for a homestar node.
-/// TODO: Split-up and re-arrange.
+/// Database-related settings for a homestar node.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Database {
+    /// Database Url provided within the configuration file.
+    ///
+    /// Note: This is not used if the `DATABASE_URL` environment variable
+    /// is set.
+    #[serde_as(as = "Option<DisplayFromStr>")]
+    pub(crate) url: Option<String>,
+    /// Maximum number of connections managed by the [pool].
+    ///
+    /// [pool]: crate::db::Pool
+    pub(crate) max_pool_size: u32,
+}
+
+/// Monitoring settings.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct Monitoring {
+    /// Tokio console port.
+    pub console_subscriber_port: u16,
+    /// Monitoring collection interval in milliseconds.
+    #[cfg(feature = "monitoring")]
+    #[serde_as(as = "DurationMilliSeconds<u64>")]
+    pub process_collector_interval: Duration,
+}
+
+/// Network settings for a homestar node.
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
 pub struct Network {
-    /// Metrics port for prometheus scraping.
-    pub metrics_port: u16,
+    /// libp2p Settings.
+    pub(crate) libp2p: Libp2p,
+    /// Metrics Settings.
+    pub(crate) metrics: Metrics,
     /// Buffer-length for event(s) / command(s) channels.
     pub(crate) events_buffer_len: usize,
-    /// Address for [Swarm] to listen on.
-    ///
-    /// [Swarm]: libp2p::swarm::Swarm
-    #[serde(with = "http_serde::uri")]
-    pub(crate) listen_address: Uri,
-    /// Enable Rendezvous protocol client.
-    pub(crate) enable_rendezvous_client: bool,
-    /// Enable Rendezvous protocol server.
-    pub(crate) enable_rendezvous_server: bool,
-    /// Rendezvous registration TTL.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) rendezvous_registration_ttl: Duration,
-    /// Rendezvous discovery interval.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) rendezvous_discovery_interval: Duration,
-    /// Enable mDNS.
-    pub(crate) enable_mdns: bool,
-    /// mDNS IPv6 enable flag
-    pub(crate) mdns_enable_ipv6: bool,
-    /// mDNS query interval.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) mdns_query_interval: Duration,
-    /// mDNS TTL.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) mdns_ttl: Duration,
-    /// Timeout for p2p requests for a provided record.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) p2p_provider_timeout: Duration,
-    /// Enable pub/sub.
-    pub(crate) enable_pubsub: bool,
-    /// Pub/sub duplicate cache time.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) pubsub_duplication_cache_time: Duration,
-    /// Pub/sub hearbeat interval for mesh configuration.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) pubsub_heartbeat: Duration,
-    /// Pub/sub idle timeout
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) pubsub_idle_timeout: Duration,
-    /// TODO
-    pub(crate) pubsub_max_transmit_size: usize,
-    /// TODO
-    pub(crate) pubsub_mesh_n_low: usize,
-    /// TODO
-    pub(crate) pubsub_mesh_n_high: usize,
-    /// TODO
-    pub(crate) pubsub_mesh_n: usize,
-    /// TODO
-    pub(crate) pubsub_mesh_outbound_min: usize,
-    /// Quorum for receipt records on the DHT.
-    pub(crate) receipt_quorum: usize,
-    /// RPC-server port.
-    #[serde_as(as = "DisplayFromStr")]
-    pub(crate) rpc_host: IpAddr,
-    /// RPC-server max-concurrent connections.
-    pub(crate) rpc_max_connections: usize,
-    /// RPC-server port.
-    pub(crate) rpc_port: u16,
-    #[serde_as(as = "DurationSeconds<u64>")]
-    /// RPC-server timeout.
-    pub(crate) rpc_server_timeout: Duration,
-    /// Transport connection timeout.
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) transport_connection_timeout: Duration,
-    /// Webserver host address.
-    #[serde(with = "http_serde::uri")]
-    pub(crate) webserver_host: Uri,
-    /// Webserver-server port.
-    pub(crate) webserver_port: u16,
-    /// TODO
-    #[serde_as(as = "DurationSeconds<u64>")]
-    pub(crate) webserver_timeout: Duration,
-    /// Number of *bounded* clients to send messages to, used for a
-    /// [tokio::sync::broadcast::channel]
-    pub(crate) websocket_capacity: usize,
-    /// Websocket-server timeout for receiving messages from the runner.
-    #[serde_as(as = "DurationMilliSeconds<u64>")]
-    pub(crate) websocket_receiver_timeout: Duration,
-    /// Quorum for [workflow::Info] records on the DHT.
-    ///
-    /// [workflow::Info]: crate::workflow::Info
-    pub(crate) workflow_quorum: usize,
+    /// RPC server settings.
+    pub(crate) rpc: Rpc,
     /// Pubkey setup configuration.
     pub(crate) keypair_config: PubkeyConfig,
-    /// Multiaddrs of the trusted nodes to connect to on startup.
-    #[serde_as(as = "Vec<serde_with::DisplayFromStr>")]
-    pub(crate) node_addresses: Vec<libp2p::Multiaddr>,
-    /// Multiaddrs of the external addresses this node will announce to the
-    /// network.
-    #[serde_as(as = "Vec<serde_with::DisplayFromStr>")]
-    pub(crate) announce_addresses: Vec<libp2p::Multiaddr>,
-    /// Maximum number of peers we will dial.
-    pub(crate) max_connected_peers: u32,
-    /// Limit on the number of external addresses we announce to other peers.
-    pub(crate) max_announce_addresses: u32,
     /// Event handler poll cache interval in milliseconds.
     #[serde_as(as = "DurationMilliSeconds<u64>")]
     pub(crate) poll_cache_interval: Duration,
-    /// TODO
+    /// IPFS settings.
     #[cfg(feature = "ipfs")]
     pub(crate) ipfs: Ipfs,
+    /// Webserver settings
+    pub(crate) webserver: Webserver,
 }
 
+/// IPFS Settings
 #[cfg(feature = "ipfs")]
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
 pub(crate) struct Ipfs {
-    /// TODO
+    /// The host where Homestar expects IPFS.
     pub(crate) host: String,
-    /// TODO
+    /// The port where Homestar expects IPFS.
     pub(crate) port: u16,
 }
 
-/// Database-related settings for a homestar node.
+/// Metrics settings.
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
-pub(crate) struct Database {
-    /// Database Url provided within the configuration file.
-    ///
-    /// Note: This is not used if the `DATABASE_URL` environment variable
-    /// is set.
-    #[serde_as(as = "Option<DisplayFromStr>")]
-    pub(crate) url: Option<String>,
-    /// Maximum number of connections managed by the [pool].
-    ///
-    /// [pool]: crate::db::Pool
-    pub(crate) max_pool_size: u32,
+pub(crate) struct Metrics {
+    /// Metrics port for prometheus scraping.
+    pub(crate) port: u16,
+}
+
+/// RPC server settings.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Rpc {
+    /// RPC-server port.
+    #[serde_as(as = "DisplayFromStr")]
+    pub(crate) host: IpAddr,
+    /// RPC-server max-concurrent connections.
+    pub(crate) max_connections: usize,
+    /// RPC-server port.
+    pub(crate) port: u16,
+    #[serde_as(as = "DurationSeconds<u64>")]
+    /// RPC-server timeout.
+    pub(crate) server_timeout: Duration,
+}
+
+/// Webserver settings
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Webserver {
+    /// Webserver host address.
+    #[serde(with = "http_serde::uri")]
+    pub(crate) host: Uri,
+    /// Webserver-server port.
+    pub(crate) port: u16,
+    /// TODO
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) timeout: Duration,
+    /// Number of *bounded* clients to send messages to, used for a
+    /// [tokio::sync::broadcast::channel]
+    pub(crate) websocket_capacity: usize,
+    /// Websocket-server timeout for receiving messages from the runner.
+    #[serde_as(as = "DurationMilliSeconds<u64>")]
+    pub(crate) websocket_receiver_timeout: Duration,
+}
+
+impl Default for Node {
+    fn default() -> Self {
+        Self {
+            gc_interval: Duration::from_secs(1800),
+            shutdown_timeout: Duration::from_secs(20),
+            monitoring: Default::default(),
+            network: Default::default(),
+            db: Default::default(),
+        }
+    }
+}
+
+impl Node {
+    /// Monitoring settings getter.
+    pub fn monitoring(&self) -> &Monitoring {
+        &self.monitoring
+    }
+
+    /// Network settings.
+    pub fn network(&self) -> &Network {
+        &self.network
+    }
+
+    /// Node shutdown timeout.
+    pub fn shutdown_timeout(&self) -> Duration {
+        self.shutdown_timeout
+    }
+}
+
+impl Default for Database {
+    fn default() -> Self {
+        Self {
+            max_pool_size: 100,
+            url: None,
+        }
+    }
 }
 
 #[cfg(feature = "monitoring")]
@@ -234,6 +230,40 @@ impl Default for Monitoring {
     }
 }
 
+impl Default for Network {
+    fn default() -> Self {
+        Self {
+            libp2p: Libp2p::default(),
+            metrics: Metrics::default(),
+            events_buffer_len: 1024,
+            rpc: Rpc::default(),
+            keypair_config: PubkeyConfig::Random,
+            poll_cache_interval: Duration::from_millis(1000),
+            #[cfg(feature = "ipfs")]
+            ipfs: Default::default(),
+            webserver: Webserver::default(),
+        }
+    }
+}
+
+impl Network {
+    /// IPFS settings.
+    #[cfg(feature = "ipfs")]
+    pub(crate) fn ipfs(&self) -> &Ipfs {
+        &self.ipfs
+    }
+
+    /// libp2p settings.
+    pub(crate) fn libp2p(&self) -> &Libp2p {
+        &self.libp2p
+    }
+
+    /// Webserver settings.
+    pub(crate) fn webserver(&self) -> &Webserver {
+        &self.webserver
+    }
+}
+
 #[cfg(feature = "ipfs")]
 impl Default for Ipfs {
     fn default() -> Self {
@@ -244,94 +274,35 @@ impl Default for Ipfs {
     }
 }
 
-impl Default for Database {
+impl Default for Metrics {
     fn default() -> Self {
-        Self {
-            max_pool_size: 100,
-            url: None,
-        }
+        Self { port: 4000 }
     }
 }
 
-impl Default for Node {
+impl Default for Rpc {
     fn default() -> Self {
         Self {
-            gc_interval: Duration::from_secs(1800),
-            shutdown_timeout: Duration::from_secs(20),
-            network: Default::default(),
-            db: Default::default(),
+            host: IpAddr::V6(Ipv6Addr::LOCALHOST),
+            max_connections: 10,
+            port: 3030,
+            server_timeout: Duration::new(120, 0),
         }
     }
 }
 
-impl Default for Network {
+impl Default for Webserver {
     fn default() -> Self {
         Self {
-            metrics_port: 4000,
-            events_buffer_len: 1024,
-            listen_address: Uri::from_static("/ip4/0.0.0.0/tcp/0"),
-            enable_rendezvous_client: true,
-            enable_rendezvous_server: false,
-            rendezvous_registration_ttl: Duration::from_secs(2 * 60 * 60),
-            rendezvous_discovery_interval: Duration::from_secs(10 * 60),
-            // TODO: we would like to enable this by default, however this breaks mdns on at least some linux distros. Requires further investigation.
-            enable_mdns: true,
-            mdns_enable_ipv6: false,
-            mdns_query_interval: Duration::from_secs(5 * 60),
-            mdns_ttl: Duration::from_secs(60 * 9),
-            p2p_provider_timeout: Duration::new(30, 0),
-            enable_pubsub: true,
-            pubsub_duplication_cache_time: Duration::new(1, 0),
-            pubsub_heartbeat: Duration::new(60, 0),
-            pubsub_idle_timeout: Duration::new(60 * 60 * 24, 0),
-            pubsub_max_transmit_size: 10 * 1024 * 1024,
-            pubsub_mesh_n_low: 1,
-            pubsub_mesh_n_high: 10,
-            pubsub_mesh_n: 2,
-            pubsub_mesh_outbound_min: 1,
-            receipt_quorum: 2,
-            rpc_host: IpAddr::V6(Ipv6Addr::LOCALHOST),
-            rpc_max_connections: 10,
-            rpc_port: 3030,
-            rpc_server_timeout: Duration::new(120, 0),
-            transport_connection_timeout: Duration::new(60, 0),
-            webserver_host: Uri::from_static("127.0.0.1"),
-            webserver_port: 1337,
-            webserver_timeout: Duration::new(120, 0),
+            host: Uri::from_static("127.0.0.1"),
+            port: 1337,
+            timeout: Duration::new(120, 0),
             websocket_capacity: 2048,
             websocket_receiver_timeout: Duration::from_millis(30_000),
-            workflow_quorum: 3,
-            keypair_config: PubkeyConfig::Random,
-            node_addresses: Vec::new(),
-            announce_addresses: Vec::new(),
-            max_connected_peers: 32,
-            max_announce_addresses: 10,
-            poll_cache_interval: Duration::from_millis(1000),
-            #[cfg(feature = "ipfs")]
-            ipfs: Default::default(),
         }
     }
 }
 
-impl Node {
-    /// Network settings.
-    pub fn network(&self) -> &Network {
-        &self.network
-    }
-    /// Node shutdown timeout.
-    pub fn shutdown_timeout(&self) -> Duration {
-        self.shutdown_timeout
-    }
-}
-
-impl Network {
-    /// TODO
-    #[cfg(feature = "ipfs")]
-    pub(crate) fn ipfs(&self) -> &Ipfs {
-        &self.ipfs
-    }
-}
-
 impl Settings {
     /// Load settings.
     ///
@@ -412,20 +383,28 @@ mod test {
 
         let mut default_modded_settings = Node::default();
         default_modded_settings.network.events_buffer_len = 1000;
-        default_modded_settings.network.webserver_port = 9999;
+        default_modded_settings.network.webserver.port = 9999;
         default_modded_settings.gc_interval = Duration::from_secs(1800);
         default_modded_settings.shutdown_timeout = Duration::from_secs(20);
-        default_modded_settings.network.node_addresses =
+        default_modded_settings.network.libp2p.node_addresses =
             vec!["/ip4/127.0.0.1/tcp/9998/ws".to_string().try_into().unwrap()];
         assert_eq!(settings.node(), &default_modded_settings);
     }
 
+    #[test]
+    fn default_config() {
+        let settings = Settings::load().unwrap();
+        let default_config = Settings::build(Some("fixtures/defaults.toml".into()))
+            .expect("default settings file in test fixtures");
+        assert_eq!(settings, default_config);
+    }
+
     #[test]
     fn overriding_env() {
-        std::env::set_var("HOMESTAR__NODE__NETWORK__RPC_PORT", "2046");
+        std::env::set_var("HOMESTAR__NODE__NETWORK__RPC__PORT", "2046");
         std::env::set_var("HOMESTAR__NODE__DB__MAX_POOL_SIZE", "1");
         let settings = Settings::build(Some("fixtures/settings.toml".into())).unwrap();
-        assert_eq!(settings.node.network.rpc_port, 2046);
+        assert_eq!(settings.node.network.rpc.port, 2046);
         assert_eq!(settings.node.db.max_pool_size, 1);
     }
 
diff --git a/homestar-runtime/src/settings/libp2p_config.rs b/homestar-runtime/src/settings/libp2p_config.rs
new file mode 100644
index 00000000..b561cb4b
--- /dev/null
+++ b/homestar-runtime/src/settings/libp2p_config.rs
@@ -0,0 +1,190 @@
+//! Libp2p setttings
+
+use http::Uri;
+use serde::{Deserialize, Serialize};
+use serde_with::{serde_as, DurationSeconds};
+use std::time::Duration;
+
+/// libp2p settings.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Libp2p {
+    /// Multiaddrs of the external addresses this node will announce to the
+    /// network.
+    #[serde_as(as = "Vec<serde_with::DisplayFromStr>")]
+    pub(crate) announce_addresses: Vec<libp2p::Multiaddr>,
+    /// Kademlia DHT Settings
+    pub(crate) dht: Dht,
+    /// Address for [Swarm] to listen on.
+    ///
+    /// [Swarm]: libp2p::swarm::Swarm
+    #[serde(with = "http_serde::uri")]
+    pub(crate) listen_address: Uri,
+    /// Maximum number of peers we will dial.
+    pub(crate) max_connected_peers: u32,
+    /// Limit on the number of external addresses we announce to other peers.
+    pub(crate) max_announce_addresses: u32,
+    /// Multiaddrs of the trusted nodes to connect to on startup.
+    #[serde_as(as = "Vec<serde_with::DisplayFromStr>")]
+    pub(crate) node_addresses: Vec<libp2p::Multiaddr>,
+    /// mDNS Settings.
+    pub(crate) mdns: Mdns,
+    /// Pubsub Settings.
+    pub(crate) pubsub: Pubsub,
+    /// Rendezvous Settings.
+    pub(crate) rendezvous: Rendezvous,
+    /// Transport connection timeout.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) transport_connection_timeout: Duration,
+}
+
+/// DHT settings.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Dht {
+    /// Timeout for p2p requests for a provided record.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) p2p_provider_timeout: Duration,
+    /// Quorum for receipt records on the DHT.
+    pub(crate) receipt_quorum: usize,
+    /// Quorum for [workflow::Info] records on the DHT.
+    ///
+    /// [workflow::Info]: crate::workflow::Info
+    pub(crate) workflow_quorum: usize,
+}
+
+/// mDNS settings.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Mdns {
+    /// Enable mDNS.
+    pub(crate) enable: bool,
+    /// mDNS IPv6 enable flag
+    pub(crate) enable_ipv6: bool,
+    /// mDNS query interval.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) query_interval: Duration,
+    /// mDNS TTL.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) ttl: Duration,
+}
+
+/// Pubsub settings.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Pubsub {
+    /// Enable pub/sub.
+    pub(crate) enable: bool,
+    /// Pub/sub duplicate cache time.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) duplication_cache_time: Duration,
+    /// Pub/sub hearbeat interval for mesh configuration.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) heartbeat: Duration,
+    /// Pub/sub idle timeout
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) idle_timeout: Duration,
+    /// Maximum byte size of pub/sub messages.
+    pub(crate) max_transmit_size: usize,
+    /// Minimum number of pub/sub peers.
+    pub(crate) mesh_n_low: usize,
+    /// Maximum number of pub/sub peers.
+    pub(crate) mesh_n_high: usize,
+    /// Target number of pub/sub peers.
+    pub(crate) mesh_n: usize,
+    /// Minimum outbound pub/sub peers before adding more peers.
+    pub(crate) mesh_outbound_min: usize,
+}
+
+/// Rendezvous settings.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub(crate) struct Rendezvous {
+    /// Enable Rendezvous protocol client.
+    pub(crate) enable_client: bool,
+    /// Enable Rendezvous protocol server.
+    pub(crate) enable_server: bool,
+    /// Rendezvous registration TTL.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) registration_ttl: Duration,
+    /// Rendezvous discovery interval.
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub(crate) discovery_interval: Duration,
+}
+
+impl Default for Libp2p {
+    fn default() -> Self {
+        Self {
+            announce_addresses: Vec::new(),
+            dht: Dht::default(),
+            listen_address: Uri::from_static("/ip4/0.0.0.0/tcp/0"),
+            max_connected_peers: 32,
+            max_announce_addresses: 10,
+            mdns: Mdns::default(),
+            node_addresses: Vec::new(),
+            pubsub: Pubsub::default(),
+            rendezvous: Rendezvous::default(),
+            transport_connection_timeout: Duration::new(60, 0),
+        }
+    }
+}
+
+impl Libp2p {
+    /// Pub/sub settings getter.
+    pub(crate) fn pubsub(&self) -> &Pubsub {
+        &self.pubsub
+    }
+}
+
+impl Default for Dht {
+    fn default() -> Self {
+        Self {
+            p2p_provider_timeout: Duration::new(30, 0),
+            receipt_quorum: 2,
+            workflow_quorum: 3,
+        }
+    }
+}
+
+impl Default for Mdns {
+    fn default() -> Self {
+        Self {
+            enable: true,
+            enable_ipv6: false,
+            query_interval: Duration::from_secs(5 * 60),
+            ttl: Duration::from_secs(60 * 9),
+        }
+    }
+}
+
+impl Default for Pubsub {
+    fn default() -> Self {
+        Self {
+            enable: true,
+            duplication_cache_time: Duration::new(1, 0),
+            heartbeat: Duration::new(60, 0),
+            idle_timeout: Duration::new(60 * 60 * 24, 0),
+            max_transmit_size: 10 * 1024 * 1024,
+            mesh_n_low: 1,
+            mesh_n_high: 10,
+            mesh_n: 2,
+            mesh_outbound_min: 1,
+        }
+    }
+}
+
+impl Default for Rendezvous {
+    fn default() -> Self {
+        Self {
+            enable_client: true,
+            enable_server: false,
+            registration_ttl: Duration::from_secs(2 * 60 * 60),
+            discovery_interval: Duration::from_secs(10 * 60),
+        }
+    }
+}
diff --git a/homestar-runtime/src/test_utils/proc_macro/src/lib.rs b/homestar-runtime/src/test_utils/proc_macro/src/lib.rs
index 8334fb5f..5ffbdcc9 100644
--- a/homestar-runtime/src/test_utils/proc_macro/src/lib.rs
+++ b/homestar-runtime/src/test_utils/proc_macro/src/lib.rs
@@ -70,8 +70,8 @@ pub fn db_async_test(_attr: TokenStream, item: TokenStream) -> TokenStream {
 ///     runner.runtime.block_on(rpc_server.spawn()).unwrap();
 ///     runner.runtime.spawn(async move {
 ///         let addr = SocketAddr::new(
-///             settings.node.network.rpc_host,
-///             settings.node.network.rpc_port,
+///             settings.node.network.rpc.host,
+///             settings.node.network.rpc.port,
 ///         );
 ///         let client = Client::new(addr, context::current()).await.unwrap();
 ///         let response = client.ping().await.unwrap();
@@ -98,11 +98,11 @@ pub fn runner_test(_attr: TokenStream, item: TokenStream) -> TokenStream {
             impl TestRunner {
                 fn start() -> TestRunner {
                     let mut settings = crate::Settings::load().unwrap();
-                    settings.node.network.webserver_port = ::homestar_core::test_utils::ports::get_port() as u16;
-                    settings.node.network.rpc_port = ::homestar_core::test_utils::ports::get_port() as u16;
-                    settings.node.network.metrics_port = ::homestar_core::test_utils::ports::get_port() as u16;
+                    settings.node.network.webserver.port = ::homestar_core::test_utils::ports::get_port() as u16;
+                    settings.node.network.rpc.port = ::homestar_core::test_utils::ports::get_port() as u16;
+                    settings.node.network.metrics.port = ::homestar_core::test_utils::ports::get_port() as u16;
                     settings.node.db.url = Some(format!("{}.db", #func_name_as_string));
-                    settings.node.network.websocket_receiver_timeout = std::time::Duration::from_millis(500);
+                    settings.node.network.webserver.websocket_receiver_timeout = std::time::Duration::from_millis(500);
                     let db = crate::test_utils::db::MemoryDb::setup_connection_pool(&settings.node, None).unwrap();
                     let runner = crate::Runner::start(settings.clone(), db).unwrap();
                     TestRunner { runner, settings }
diff --git a/homestar-runtime/tests/fixtures/test_gossip1.toml b/homestar-runtime/tests/fixtures/test_gossip1.toml
index 5c2b725c..a8500685 100644
--- a/homestar-runtime/tests/fixtures/test_gossip1.toml
+++ b/homestar-runtime/tests/fixtures/test_gossip1.toml
@@ -1,20 +1,30 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5550
 
-[node]
+# Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
+[node.network.keypair_config]
+existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
 
-[node.network]
-metrics_port = 3990
-rpc_port = 9790
-webserver_port = 7990
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7020"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7021/p2p/16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc",
 ]
-enable_mdns = false
-enable_rendezvous_client = false
 
-# Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
-[node.network.keypair_config]
-existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+enable_client = false
+
+[node.network.metrics]
+port = 3990
+
+[node.network.rpc]
+port = 9790
+
+[node.network.webserver]
+port = 7990
diff --git a/homestar-runtime/tests/fixtures/test_gossip2.toml b/homestar-runtime/tests/fixtures/test_gossip2.toml
index 0ac179a2..ccc9e9c3 100644
--- a/homestar-runtime/tests/fixtures/test_gossip2.toml
+++ b/homestar-runtime/tests/fixtures/test_gossip2.toml
@@ -1,20 +1,30 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5551
 
-[node]
+# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
+[node.network.keypair_config]
+existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
 
-[node.network]
-metrics_port = 3991
-rpc_port = 9791
-webserver_port = 7991
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7021"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7020/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-enable_mdns = false
-enable_rendezvous_client = false
 
-# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
-[node.network.keypair_config]
-existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.metrics]
+port = 3991
+
+[node.network.libp2p.rendezvous]
+enable_client = false
+
+[node.network.rpc]
+port = 9791
+
+[node.network.webserver]
+port = 7991
diff --git a/homestar-runtime/tests/fixtures/test_mdns1.toml b/homestar-runtime/tests/fixtures/test_mdns1.toml
index 63bcce0b..4a0ad334 100644
--- a/homestar-runtime/tests/fixtures/test_mdns1.toml
+++ b/homestar-runtime/tests/fixtures/test_mdns1.toml
@@ -1,16 +1,24 @@
-[monitoring]
-process_collector_interval = 500
-console_subscriber_port = 5560
-
 [node]
 
-[node.network]
-metrics_port = 4001
-rpc_port = 9800
-webserver_port = 8000
-listen_address = "/ip4/0.0.0.0/tcp/0"
-enable_rendezvous_client = false
+[node.monitoring]
+process_collector_interval = 500
+console_subscriber_port = 5560
 
 # Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
 [node.network.keypair_config]
 existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
+
+[node.network.libp2p]
+listen_address = "/ip4/0.0.0.0/tcp/0"
+
+[node.network.libp2p.rendezvous]
+enable_client = false
+
+[node.network.metrics]
+port = 4001
+
+[node.network.rpc]
+port = 9800
+
+[node.network.webserver]
+port = 8000
diff --git a/homestar-runtime/tests/fixtures/test_mdns2.toml b/homestar-runtime/tests/fixtures/test_mdns2.toml
index c5ddf01c..0aaea51a 100644
--- a/homestar-runtime/tests/fixtures/test_mdns2.toml
+++ b/homestar-runtime/tests/fixtures/test_mdns2.toml
@@ -1,16 +1,24 @@
-[monitoring]
-process_collector_interval = 500
-console_subscriber_port = 5561
-
 [node]
 
-[node.network]
-metrics_port = 4002
-rpc_port = 9801
-webserver_port = 8001
-listen_address = "/ip4/0.0.0.0/tcp/0"
-enable_rendezvous_client = false
+[node.monitoring]
+process_collector_interval = 500
+console_subscriber_port = 5561
 
 # Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
 [node.network.keypair_config]
 existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
+
+[node.network.libp2p]
+listen_address = "/ip4/0.0.0.0/tcp/0"
+
+[node.network.libp2p.rendezvous]
+enable_client = false
+
+[node.network.metrics]
+port = 4002
+
+[node.network.rpc]
+port = 9801
+
+[node.network.webserver]
+port = 8001
diff --git a/homestar-runtime/tests/fixtures/test_metrics.toml b/homestar-runtime/tests/fixtures/test_metrics.toml
index e6c31773..718d8511 100644
--- a/homestar-runtime/tests/fixtures/test_metrics.toml
+++ b/homestar-runtime/tests/fixtures/test_metrics.toml
@@ -1,14 +1,18 @@
-[monitoring]
-process_collector_interval = 500
-console_subscriber_port = 5570
-
 [node]
 
-[node.network]
-metrics_port = 4020
-rpc_port = 9810
-webserver_port = 8010
+[node.monitoring]
+process_collector_interval = 500
+console_subscriber_port = 5570
 
 # Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
 [node.network.keypair_config]
 existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
+
+[node.network.metrics]
+port = 4020
+
+[node.network.rpc]
+port = 9810
+
+[node.network.webserver]
+port = 8010
diff --git a/homestar-runtime/tests/fixtures/test_network1.toml b/homestar-runtime/tests/fixtures/test_network1.toml
index bd1c09cd..6c59eaaa 100644
--- a/homestar-runtime/tests/fixtures/test_network1.toml
+++ b/homestar-runtime/tests/fixtures/test_network1.toml
@@ -1,20 +1,30 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5580
 
-[node]
+# Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
+[node.network.keypair_config]
+existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
 
-[node.network]
-metrics_port = 4030
-rpc_port = 9820
-webserver_port = 8020
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7000"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7001/p2p/16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc",
 ]
-enable_mdns = false
-enable_rendezvous_client = false
 
-# Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
-[node.network.keypair_config]
-existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+enable_client = false
+
+[node.network.metrics]
+port = 4030
+
+[node.network.rpc]
+port = 9820
+
+[node.network.webserver]
+port = 8020
diff --git a/homestar-runtime/tests/fixtures/test_network2.toml b/homestar-runtime/tests/fixtures/test_network2.toml
index 70c167c8..489142c2 100644
--- a/homestar-runtime/tests/fixtures/test_network2.toml
+++ b/homestar-runtime/tests/fixtures/test_network2.toml
@@ -1,20 +1,30 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5581
 
-[node]
+# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
+[node.network.keypair_config]
+existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
 
-[node.network]
-metrics_port = 4031
-rpc_port = 9821
-webserver_port = 8021
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7001"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7000/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-enable_mdns = false
-enable_rendezvous_client = false
 
-# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
-[node.network.keypair_config]
-existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+enable_client = false
+
+[node.network.metrics]
+port = 4031
+
+[node.network.rpc]
+port = 9821
+
+[node.network.webserver]
+port = 8021
diff --git a/homestar-runtime/tests/fixtures/test_notification1.toml b/homestar-runtime/tests/fixtures/test_notification1.toml
index 979515fd..212b37d8 100644
--- a/homestar-runtime/tests/fixtures/test_notification1.toml
+++ b/homestar-runtime/tests/fixtures/test_notification1.toml
@@ -1,20 +1,30 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5582
 
-[node]
+# Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
+[node.network.keypair_config]
+existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
 
-[node.network]
-metrics_port = 4032
-rpc_port = 9822
-webserver_port = 8022
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7010"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7011/p2p/16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc",
 ]
-enable_mdns = false
-enable_rendezvous_client = false
 
-# Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
-[node.network.keypair_config]
-existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.rendezvous]
+enable_client = false
+
+[node.network.metrics]
+port = 4032
+
+[node.network.rpc]
+port = 9822
+
+[node.network.webserver]
+port = 8022
diff --git a/homestar-runtime/tests/fixtures/test_notification2.toml b/homestar-runtime/tests/fixtures/test_notification2.toml
index dd22b7a1..362ecdc2 100644
--- a/homestar-runtime/tests/fixtures/test_notification2.toml
+++ b/homestar-runtime/tests/fixtures/test_notification2.toml
@@ -1,20 +1,30 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5583
 
-[node]
+# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
+[node.network.keypair_config]
+existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
 
-[node.network]
-metrics_port = 4033
-rpc_port = 9823
-webserver_port = 8023
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7011"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7010/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-enable_mdns = false
-enable_rendezvous_client = false
 
-# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
-[node.network.keypair_config]
-existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+enable_client = false
+
+[node.network.metrics]
+port = 4033
+
+[node.network.rpc]
+port = 9823
+
+[node.network.webserver]
+port = 8023
diff --git a/homestar-runtime/tests/fixtures/test_rendezvous1.toml b/homestar-runtime/tests/fixtures/test_rendezvous1.toml
index 585e8837..d80d6359 100644
--- a/homestar-runtime/tests/fixtures/test_rendezvous1.toml
+++ b/homestar-runtime/tests/fixtures/test_rendezvous1.toml
@@ -1,17 +1,27 @@
-[monitoring]
-process_collector_interval = 500
-console_subscriber_port = 5585
-
 [node]
 
-[node.network]
-metrics_port = 4034
-rpc_port = 9824
-webserver_port = 8024
-listen_address = "/ip4/127.0.0.1/tcp/7000"
-enable_rendezvous_server = true
-enable_mdns = false
+[node.monitoring]
+process_collector_interval = 500
+console_subscriber_port = 5585
 
 # Peer ID 12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN
 [node.network.keypair_config]
 existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519.pem" }
+
+[node.network.libp2p]
+listen_address = "/ip4/127.0.0.1/tcp/7000"
+
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+enable_server = true
+
+[node.network.metrics]
+port = 4034
+
+[node.network.rpc]
+port = 9824
+
+[node.network.webserver]
+port = 8024
diff --git a/homestar-runtime/tests/fixtures/test_rendezvous2.toml b/homestar-runtime/tests/fixtures/test_rendezvous2.toml
index bb142da0..0f96954d 100644
--- a/homestar-runtime/tests/fixtures/test_rendezvous2.toml
+++ b/homestar-runtime/tests/fixtures/test_rendezvous2.toml
@@ -1,13 +1,14 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5586
 
-[node]
+# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
+[node.network.keypair_config]
+existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
 
-[node.network]
-metrics_port = 4036
-rpc_port = 9826
-webserver_port = 8026
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7001"
 announce_addresses = [
   "/ip4/127.0.0.1/tcp/7001/p2p/16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc",
@@ -15,8 +16,15 @@ announce_addresses = [
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7000/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-enable_mdns = false
 
-# Peer ID 16Uiu2HAm3g9AomQNeEctL2hPwLapap7AtPSNt8ZrBny4rLx1W5Dc
-[node.network.keypair_config]
-existing = { key_type = "secp256k1", path = "./fixtures/__testkey_secp256k1.der" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.metrics]
+port = 4036
+
+[node.network.rpc]
+port = 9826
+
+[node.network.webserver]
+port = 8026
diff --git a/homestar-runtime/tests/fixtures/test_rendezvous3.toml b/homestar-runtime/tests/fixtures/test_rendezvous3.toml
index a9fceb06..dc2c2bb0 100644
--- a/homestar-runtime/tests/fixtures/test_rendezvous3.toml
+++ b/homestar-runtime/tests/fixtures/test_rendezvous3.toml
@@ -1,19 +1,27 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5587
 
-[node]
+# Peer ID 12D3KooWK99VoVxNE7XzyBwXEzW7xhK7Gpv85r9F3V3fyKSUKPH5
+[node.network.keypair_config]
+existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_2.pem" }
 
-[node.network]
-metrics_port = 4037
-rpc_port = 9827
-webserver_port = 8027
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7002"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7000/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-enable_mdns = false
 
-# Peer ID 12D3KooWK99VoVxNE7XzyBwXEzW7xhK7Gpv85r9F3V3fyKSUKPH5
-[node.network.keypair_config]
-existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_2.pem" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.metrics]
+port = 4037
+
+[node.network.rpc]
+port = 9827
+
+[node.network.webserver]
+port = 8027
diff --git a/homestar-runtime/tests/fixtures/test_rendezvous4.toml b/homestar-runtime/tests/fixtures/test_rendezvous4.toml
index 9e404c84..af354bfe 100644
--- a/homestar-runtime/tests/fixtures/test_rendezvous4.toml
+++ b/homestar-runtime/tests/fixtures/test_rendezvous4.toml
@@ -1,13 +1,14 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5588
 
-[node]
+# Peer ID 12D3KooWJWoaqZhDaoEFshF7Rh1bpY9ohihFhzcW6d69Lr2NASuq
+[node.network.keypair_config]
+existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_3.pem" }
 
-[node.network]
-metrics_port = 4038
-rpc_port = 9828
-webserver_port = 8028
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7003"
 announce_addresses = [
   "/ip4/127.0.0.1/tcp/7003/p2p/12D3KooWJWoaqZhDaoEFshF7Rh1bpY9ohihFhzcW6d69Lr2NASuq",
@@ -15,9 +16,18 @@ announce_addresses = [
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7000/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-rendezvous_registration_ttl = 1
-enable_mdns = false
 
-# Peer ID 12D3KooWJWoaqZhDaoEFshF7Rh1bpY9ohihFhzcW6d69Lr2NASuq
-[node.network.keypair_config]
-existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_3.pem" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+registration_ttl = 1
+
+[node.network.metrics]
+port = 4038
+
+[node.network.rpc]
+port = 9828
+
+[node.network.webserver]
+port = 8028
diff --git a/homestar-runtime/tests/fixtures/test_rendezvous5.toml b/homestar-runtime/tests/fixtures/test_rendezvous5.toml
index f44441a0..79048fc3 100644
--- a/homestar-runtime/tests/fixtures/test_rendezvous5.toml
+++ b/homestar-runtime/tests/fixtures/test_rendezvous5.toml
@@ -1,20 +1,30 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5589
 
-[node]
+# Peer ID 12D3KooWRndVhVZPCiQwHBBBdg769GyrPUW13zxwqQyf9r3ANaba
+[node.network.keypair_config]
+existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_4.pem" }
 
-[node.network]
-metrics_port = 4039
-rpc_port = 9829
-websocket_port = 8029
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7004"
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7000/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-rendezvous_discovery_interval = 1
-enable_mdns = false
 
-# Peer ID 12D3KooWRndVhVZPCiQwHBBBdg769GyrPUW13zxwqQyf9r3ANaba
-[node.network.keypair_config]
-existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_4.pem" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+discovery_interval = 1
+
+[node.network.metrics]
+port = 4039
+
+[node.network.rpc]
+port = 9829
+
+[node.network.webserver]
+port = 8029
diff --git a/homestar-runtime/tests/fixtures/test_rendezvous6.toml b/homestar-runtime/tests/fixtures/test_rendezvous6.toml
index c96d9a14..765c1f21 100644
--- a/homestar-runtime/tests/fixtures/test_rendezvous6.toml
+++ b/homestar-runtime/tests/fixtures/test_rendezvous6.toml
@@ -1,13 +1,14 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5588
 
-[node]
+# Peer ID 12D3KooWPT98FXMfDQYavZm66EeVjTqP9Nnehn1gyaydqV8L8BQw
+[node.network.keypair_config]
+existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_5.pem" }
 
-[node.network]
-metrics_port = 4040
-rpc_port = 9830
-webserver_port = 8030
+[node.network.libp2p]
 listen_address = "/ip4/127.0.0.1/tcp/7005"
 announce_addresses = [
   "/ip4/127.0.0.1/tcp/7005/p2p/12D3KooWPT98FXMfDQYavZm66EeVjTqP9Nnehn1gyaydqV8L8BQw",
@@ -15,9 +16,18 @@ announce_addresses = [
 node_addresses = [
   "/ip4/127.0.0.1/tcp/7000/p2p/12D3KooWDpJ7As7BWAwRMfu1VU2WCqNjvq387JEYKDBj4kx6nXTN",
 ]
-rendezvous_registration_ttl = 5
-enable_mdns = false
 
-# Peer ID 12D3KooWPT98FXMfDQYavZm66EeVjTqP9Nnehn1gyaydqV8L8BQw
-[node.network.keypair_config]
-existing = { key_type = "ed25519", path = "./fixtures/__testkey_ed25519_5.pem" }
+[node.network.libp2p.mdns]
+enable = false
+
+[node.network.libp2p.rendezvous]
+registration_ttl = 5
+
+[node.network.metrics]
+port = 4040
+
+[node.network.rpc]
+port = 9830
+
+[node.network.webserver]
+port = 8030
diff --git a/homestar-runtime/tests/fixtures/test_v4.toml b/homestar-runtime/tests/fixtures/test_v4.toml
index ab9ce320..ae95115f 100644
--- a/homestar-runtime/tests/fixtures/test_v4.toml
+++ b/homestar-runtime/tests/fixtures/test_v4.toml
@@ -1,12 +1,18 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5590
 
-[node]
-
 [node.network]
-metrics_port = 4045
 events_buffer_len = 1000
-rpc_port = 9000
-rpc_host = "127.0.0.1"
-webserver_port = 8031
+
+[node.network.metrics]
+port = 4045
+
+[node.network.rpc]
+host = "127.0.0.1"
+port = 9000
+
+[node.network.webserver]
+port = 8031
diff --git a/homestar-runtime/tests/fixtures/test_v4_alt.toml b/homestar-runtime/tests/fixtures/test_v4_alt.toml
index 72b5222b..bf91ec45 100644
--- a/homestar-runtime/tests/fixtures/test_v4_alt.toml
+++ b/homestar-runtime/tests/fixtures/test_v4_alt.toml
@@ -1,12 +1,18 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5596
 
-[node]
-
 [node.network]
-metrics_port = 4041
 events_buffer_len = 1000
-rpc_port = 9836
-rpc_host = "127.0.0.1"
-webserver_port = 8040
+
+[node.network.metrics]
+port = 4041
+
+[node.network.rpc]
+host = "127.0.0.1"
+port = 9836
+
+[node.network.webserver]
+port = 8040
diff --git a/homestar-runtime/tests/fixtures/test_v6.toml b/homestar-runtime/tests/fixtures/test_v6.toml
index 4f371951..e09ff622 100644
--- a/homestar-runtime/tests/fixtures/test_v6.toml
+++ b/homestar-runtime/tests/fixtures/test_v6.toml
@@ -1,12 +1,18 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5597
 
-[node]
-
 [node.network]
-metrics_port = 4042
 events_buffer_len = 1000
-rpc_port = 9837
-rpc_host = "::1"
-webserver_port = 8050
+
+[node.network.metrics]
+port = 4042
+
+[node.network.rpc]
+host = "::1"
+port = 9837
+
+[node.network.webserver]
+port = 8050
diff --git a/homestar-runtime/tests/fixtures/test_windows_v4.toml b/homestar-runtime/tests/fixtures/test_windows_v4.toml
index a50408f2..df78b182 100644
--- a/homestar-runtime/tests/fixtures/test_windows_v4.toml
+++ b/homestar-runtime/tests/fixtures/test_windows_v4.toml
@@ -1,12 +1,18 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5591
 
-[node]
-
 [node.network]
-metrics_port = 4046
 events_buffer_len = 1000
-rpc_port = 9001
-rpc_host = "127.0.0.1"
-webserver_port = 8032
+
+[node.network.metrics]
+port = 4046
+
+[node.network.rpc]
+host = "127.0.0.1"
+port = 9001
+
+[node.network.webserver]
+port = 8032
diff --git a/homestar-runtime/tests/fixtures/test_workflow1.toml b/homestar-runtime/tests/fixtures/test_workflow1.toml
index 6a0efb11..52531978 100644
--- a/homestar-runtime/tests/fixtures/test_workflow1.toml
+++ b/homestar-runtime/tests/fixtures/test_workflow1.toml
@@ -1,11 +1,17 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5600
 
-[node]
-
 [node.network]
-metrics_port = 4050
 events_buffer_len = 1000
-rpc_port = 9840
-webserver_port = 8060
+
+[node.network.metrics]
+port = 4050
+
+[node.network.rpc]
+port = 9840
+
+[node.network.webserver]
+port = 8060
diff --git a/homestar-runtime/tests/fixtures/test_workflow2.toml b/homestar-runtime/tests/fixtures/test_workflow2.toml
index e81e6d9f..120e31c2 100644
--- a/homestar-runtime/tests/fixtures/test_workflow2.toml
+++ b/homestar-runtime/tests/fixtures/test_workflow2.toml
@@ -1,11 +1,17 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 500
 console_subscriber_port = 5600
 
-[node]
-
 [node.network]
-metrics_port = 4070
 events_buffer_len = 1000
-rpc_port = 9860
-webserver_port = 8061
+
+[node.network.metrics]
+port = 4070
+
+[node.network.rpc]
+port = 9860
+
+[node.network.webserver]
+port = 8061