diff --git a/peridot/bin/sessionmgr/BUILD.gn b/peridot/bin/sessionmgr/BUILD.gn
index b3657da..0097f9e 100644
--- a/peridot/bin/sessionmgr/BUILD.gn
+++ b/peridot/bin/sessionmgr/BUILD.gn
@@ -25,7 +25,6 @@
     "//peridot/public/lib/app_driver/cpp:app_driver",
     "//sdk/fidl/fuchsia.modular.internal",
     "//sdk/lib/fidl/cpp",
-    "//sdk/lib/sys/inspect/cpp",
     "//zircon/public/lib/async-loop-cpp",
     "//zircon/public/lib/trace-provider-with-fdio",
   ]
@@ -95,7 +94,6 @@
     "//peridot/public/lib/async/cpp:operation",
     "//sdk/lib/fidl/cpp",
     "//sdk/lib/sys/cpp",
-    "//sdk/lib/sys/inspect/cpp",
     "//sdk/lib/ui/scenic/cpp",
     "//src/ledger/bin/fidl",
     "//src/lib/fxl",
@@ -278,7 +276,6 @@
     "//peridot/lib/ledger_client:constants",
     "//sdk/lib/sys/cpp",
     "//sdk/lib/sys/cpp/testing:unit",
-    "//sdk/lib/sys/inspect/cpp",
     "//sdk/lib/ui/scenic/cpp",
     "//src/lib/fxl/test:gtest_main",
     "//third_party/googletest:gmock",
diff --git a/peridot/bin/sessionmgr/puppet_master/dispatch_story_command_executor_unittest.cc b/peridot/bin/sessionmgr/puppet_master/dispatch_story_command_executor_unittest.cc
index 86adaec..ff95079 100644
--- a/peridot/bin/sessionmgr/puppet_master/dispatch_story_command_executor_unittest.cc
+++ b/peridot/bin/sessionmgr/puppet_master/dispatch_story_command_executor_unittest.cc
@@ -54,8 +54,7 @@
  protected:
   void SetUp() override {
     TestWithLedger::SetUp();
-    session_storage_ =
-        std::make_unique<SessionStorage>(ledger_client(), LedgerPageId());
+    session_storage_ = std::make_unique<SessionStorage>(ledger_client(), LedgerPageId());
   }
 
   void Reset() {
diff --git a/peridot/bin/sessionmgr/sessionmgr.cc b/peridot/bin/sessionmgr/sessionmgr.cc
index 556e49a..c13f49c 100644
--- a/peridot/bin/sessionmgr/sessionmgr.cc
+++ b/peridot/bin/sessionmgr/sessionmgr.cc
@@ -8,15 +8,13 @@
 #include <lib/fit/defer.h>
 #include <lib/fit/function.h>
 #include <lib/sys/cpp/component_context.h>
-#include <lib/sys/inspect/cpp/component.h>
-
-#include <memory>
-
 #include <src/lib/fxl/command_line.h>
 #include <src/lib/fxl/macros.h>
 #include <src/lib/fxl/strings/split_string.h>
 #include <trace-provider/provider.h>
 
+#include <memory>
+
 #include "peridot/bin/basemgr/cobalt/cobalt.h"
 #include "peridot/bin/sessionmgr/sessionmgr_impl.h"
 #include "peridot/lib/modular_config/modular_config.h"
@@ -92,19 +90,15 @@
 
   async::Loop loop(&kAsyncLoopConfigAttachToThread);
 
-  auto component_context = sys::ComponentContext::Create();
-  auto inspector = sys::ComponentInspector::Initialize(component_context.get());
-  inspect::Node& inspect_root = inspector->root();
-
   trace::TraceProviderWithFdio trace_provider(loop.dispatcher());
+  std::unique_ptr<sys::ComponentContext> component_context(sys::ComponentContext::Create());
 
   auto cobalt_cleanup =
       SetupCobalt((config.enable_cobalt()), std::move(loop.dispatcher()), component_context.get());
 
   modular::AppDriver<modular::SessionmgrImpl> driver(
       component_context->outgoing(),
-      std::make_unique<modular::SessionmgrImpl>(component_context.get(), std::move(config),
-                                                std::move(inspect_root)),
+      std::make_unique<modular::SessionmgrImpl>(component_context.get(), std::move(config)),
       [&loop, &cobalt_cleanup] {
         cobalt_cleanup.call();
         loop.Quit();
diff --git a/peridot/bin/sessionmgr/sessionmgr_impl.cc b/peridot/bin/sessionmgr/sessionmgr_impl.cc
index 6673f21..3827c1f 100644
--- a/peridot/bin/sessionmgr/sessionmgr_impl.cc
+++ b/peridot/bin/sessionmgr/sessionmgr_impl.cc
@@ -175,11 +175,9 @@
 };
 
 SessionmgrImpl::SessionmgrImpl(sys::ComponentContext* const component_context,
-                               fuchsia::modular::session::SessionmgrConfig config,
-                               inspect::Node node_object)
+                               fuchsia::modular::session::SessionmgrConfig config)
     : component_context_(component_context),
       config_(std::move(config)),
-      node_(std::move(node_object)),
       story_provider_impl_("StoryProviderImpl"),
       agent_runner_("AgentRunner"),
       weak_ptr_factory_(this) {
@@ -608,9 +606,8 @@
   // all modules to be terminated before agents are terminated. Agents must
   // outlive the stories which contain modules that are connected to those
   // agents.
-
-  session_storage_ = std::make_unique<SessionStorage>(
-      ledger_client_.get(), fuchsia::ledger::PageId());
+  session_storage_ =
+      std::make_unique<SessionStorage>(ledger_client_.get(), fuchsia::ledger::PageId());
 
   module_facet_reader_.reset(
       new ModuleFacetReaderImpl(component_context_->svc()->Connect<fuchsia::sys::Loader>()));
diff --git a/peridot/bin/sessionmgr/sessionmgr_impl.h b/peridot/bin/sessionmgr/sessionmgr_impl.h
index 0c09161..7c4037e 100644
--- a/peridot/bin/sessionmgr/sessionmgr_impl.h
+++ b/peridot/bin/sessionmgr/sessionmgr_impl.h
@@ -20,7 +20,6 @@
 #include <lib/fidl/cpp/binding.h>
 #include <lib/fidl/cpp/interface_ptr.h>
 #include <lib/fit/function.h>
-#include <lib/sys/inspect/cpp/component.h>
 
 #include <memory>
 #include <string>
@@ -64,7 +63,7 @@
                        EntityProviderLauncher {
  public:
   SessionmgrImpl(sys::ComponentContext* component_context,
-                 fuchsia::modular::session::SessionmgrConfig config, inspect::Node object);
+                 fuchsia::modular::session::SessionmgrConfig config);
   ~SessionmgrImpl() override;
 
   // |AppDriver| calls this.
@@ -185,9 +184,6 @@
   sys::ComponentContext* const component_context_;
 
   fuchsia::modular::session::SessionmgrConfig config_;
-
-  inspect::Node node_;
-
   std::unique_ptr<scoped_tmpfs::ScopedTmpFS> memfs_for_ledger_;
 
   fidl::BindingSet<fuchsia::modular::internal::Sessionmgr> bindings_;
diff --git a/peridot/bin/sessionmgr/sessionmgr_impl_unittest.cc b/peridot/bin/sessionmgr/sessionmgr_impl_unittest.cc
index 8b15402..23c33b1 100644
--- a/peridot/bin/sessionmgr/sessionmgr_impl_unittest.cc
+++ b/peridot/bin/sessionmgr/sessionmgr_impl_unittest.cc
@@ -277,10 +277,8 @@
 
   component_context_provider.service_directory_provider()->AddService(fake_launcher.GetHandler());
 
-  inspect::Node root_node;
   fuchsia::modular::internal::SessionmgrPtr sessionmgr;
-  SessionmgrImpl sessionmgr_impl(component_context_provider.context(), std::move(config),
-                                 std::move(root_node));
+  SessionmgrImpl sessionmgr_impl(component_context_provider.context(), std::move(config));
   component_context_provider.ConnectToPublicService(sessionmgr.NewRequest());
 
   sessionmgr.set_error_handler([](zx_status_t status) {
diff --git a/peridot/bin/sessionmgr/story_runner/BUILD.gn b/peridot/bin/sessionmgr/story_runner/BUILD.gn
index 80526bb..717e5d8 100644
--- a/peridot/bin/sessionmgr/story_runner/BUILD.gn
+++ b/peridot/bin/sessionmgr/story_runner/BUILD.gn
@@ -77,7 +77,6 @@
     "//sdk/fidl/fuchsia.ui.views",
     "//sdk/lib/fidl/cpp",
     "//sdk/lib/sys/cpp",
-    "//sdk/lib/sys/inspect/cpp",
     "//src/ledger/bin/fidl",
     "//src/lib/fxl",
   ]
