diff --git a/Android.bp b/Android.bp
index 7945e35..0dc83d0 100644
--- a/Android.bp
+++ b/Android.bp
@@ -155,6 +155,7 @@
     ],
     static_libs: [
         "libcuttlefish_host_config",
+        "libjsoncpp",
         "libgflags",
     ],
     shared_libs: [
@@ -206,6 +207,7 @@
     ],
     static_libs: [
         "libcuttlefish_host_config",
+        "libjsoncpp",
         "libgtest_host",
         "libgflags",
     ],
diff --git a/common/commands/wifi_relay/Android.bp b/common/commands/wifi_relay/Android.bp
index c496ef0..5393d4a 100644
--- a/common/commands/wifi_relay/Android.bp
+++ b/common/commands/wifi_relay/Android.bp
@@ -39,6 +39,7 @@
         host: {
             static_libs: [
                 "libcuttlefish_host_config",
+                "libjsoncpp",
             ],
         },
     },
diff --git a/common/commands/wifi_relay/wifi_relay.cpp b/common/commands/wifi_relay/wifi_relay.cpp
index 2b21765..4d862b0 100644
--- a/common/commands/wifi_relay/wifi_relay.cpp
+++ b/common/commands/wifi_relay/wifi_relay.cpp
@@ -20,7 +20,7 @@
 #include "common/commands/wifi_relay/nl_client.h"
 
 #if defined(CUTTLEFISH_HOST)
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 #endif
 
 #include <linux/netdevice.h>
diff --git a/common/frontend/socket_forward_proxy/Android.bp b/common/frontend/socket_forward_proxy/Android.bp
index 4def7bf..3eba53f 100644
--- a/common/frontend/socket_forward_proxy/Android.bp
+++ b/common/frontend/socket_forward_proxy/Android.bp
@@ -36,6 +36,7 @@
         host: {
             static_libs: [
                 "libcuttlefish_host_config",
+                "libjsoncpp",
                 "libadb_connection_maintainer",
             ],
         },
diff --git a/common/frontend/socket_forward_proxy/main.cpp b/common/frontend/socket_forward_proxy/main.cpp
index a04c601..e361059 100644
--- a/common/frontend/socket_forward_proxy/main.cpp
+++ b/common/frontend/socket_forward_proxy/main.cpp
@@ -33,7 +33,7 @@
 #include "common/vsoc/lib/socket_forward_region_view.h"
 
 #ifdef CUTTLEFISH_HOST
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 #include "host/libs/adb_connection_maintainer/adb_connection_maintainer.h"
 #endif
 
diff --git a/common/vsoc/lib/screen_region_view_test.cpp b/common/vsoc/lib/screen_region_view_test.cpp
index b192c67..cc02baa 100644
--- a/common/vsoc/lib/screen_region_view_test.cpp
+++ b/common/vsoc/lib/screen_region_view_test.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "screen_region_view.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 #include <stdio.h>
 
 using vsoc::screen::ScreenRegionView;
diff --git a/host/commands/launch/Android.bp b/host/commands/launch/Android.bp
index e9789b8..650ccb9 100644
--- a/host/commands/launch/Android.bp
+++ b/host/commands/launch/Android.bp
@@ -35,6 +35,7 @@
     ],
     static_libs: [
         "libcuttlefish_host_config",
+        "libcuttlefish_vm_manager",
         "libivserver",
         "libvadb",
         "libusbip",
diff --git a/host/commands/launch/main.cc b/host/commands/launch/main.cc
index c3b2151..9605049 100644
--- a/host/commands/launch/main.cc
+++ b/host/commands/launch/main.cc
@@ -38,14 +38,13 @@
 #include "common/vsoc/lib/vsoc_memory.h"
 #include "common/vsoc/shm/screen_layout.h"
 #include "host/commands/launch/pre_launch_initializers.h"
-#include "host/libs/config/file_partition.h"
-#include "host/libs/config/guest_config.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 #include "host/libs/ivserver/ivserver.h"
 #include "host/libs/ivserver/options.h"
 #include "host/libs/monitor/kernel_log_server.h"
 #include "host/libs/usbip/server.h"
 #include "host/libs/vadb/virtual_adb_server.h"
+#include "host/libs/vm_manager/libvirt_manager.h"
 
 namespace {
 std::string StringFromEnv(const char* varname, std::string defval) {
@@ -55,13 +54,20 @@
   }
   return valstr;
 }
+
+std::string DefaultHostArtifactsPath(const char* file_name) {
+  return (StringFromEnv("ANDROID_HOST_OUT", StringFromEnv("HOME", ".")) + "/") +
+         file_name;
+}
+
 }  // namespace
 
-#define VIRSH_OPTIONS_PLACEHOLDER "<virsh_options>"
-
 using vsoc::GetPerInstanceDefault;
-using vsoc::GetDefaultPerInstancePath;
 
+DEFINE_string(
+    system_image, "",
+    "Path to the system image, if empty it is assumed to be a file named "
+    "system.img in the directory specified by -system_image_dir");
 DEFINE_string(cache_image, "", "Location of the cache partition image.");
 DEFINE_int32(cpus, 2, "Virtual CPU count.");
 DEFINE_string(data_image, "", "Location of the data partition image.");
@@ -72,10 +78,11 @@
 DEFINE_string(blank_data_image_fmt, "ext4",
               "The fs format for the blank data image. Used with mkfs.");
 
-DECLARE_int32(dpi);
-DECLARE_int32(x_res);
-DECLARE_int32(y_res);
-DECLARE_int32(num_screen_buffers);
+DEFINE_int32(x_res, 720, "Width of the screen in pixels");
+DEFINE_int32(y_res, 1280, "Height of the screen in pixels");
+DEFINE_int32(dpi, 160, "Pixels per inch for the screen");
+DEFINE_int32(refresh_rate_hz, 60, "Screen refresh rate in Hertz");
+DEFINE_int32(num_screen_buffers, 3, "The number of screen buffers");
 
 DEFINE_bool(disable_app_armor_security, false,
             "Disable AppArmor security in libvirt. For debug only.");
@@ -83,17 +90,10 @@
             "Disable DAC security in libvirt. For debug only.");
 DEFINE_string(extra_kernel_command_line, "",
               "Additional flags to put on the kernel command line");
-DECLARE_int32(instance);
 DEFINE_string(initrd, "", "Location of cuttlefish initrd file.");
 DEFINE_string(kernel, "", "Location of cuttlefish kernel file.");
 DEFINE_string(kernel_command_line, "",
               "Location of a text file with the kernel command line.");
-DEFINE_string(hypervisor_uri, "qemu:///system", "Hypervisor cannonical uri.");
-DEFINE_string(launch_command,
-              "virsh " VIRSH_OPTIONS_PLACEHOLDER " create /dev/fd/0",
-              "Command to start an instance. If <virsh_options> is present it "
-              "will be replaced by options to the virsh command");
-DEFINE_bool(log_xml, false, "Log the XML machine configuration");
 DEFINE_int32(memory_mb, 2048,
              "Total amount of memory available for guest, MB.");
 std::string g_default_mempath{GetPerInstanceDefault("/var/run/shm/cvd-")};
@@ -102,11 +102,13 @@
 std::string g_default_mobile_interface{GetPerInstanceDefault("cvd-mobile-")};
 DEFINE_string(mobile_interface, g_default_mobile_interface.c_str(),
               "Network interface to use for mobile networking");
-std::string g_default_qemusocket = GetDefaultPerInstancePath("ivshmem_socket_qemu");
-DEFINE_string(qemusocket, g_default_qemusocket.c_str(), "QEmu socket path");
+DEFINE_string(mobile_tap_name, GetPerInstanceDefault("amobile"),
+              "The name of the tap interface to use for mobile");
 std::string g_default_serial_number{GetPerInstanceDefault("CUTTLEFISHCVD")};
 DEFINE_string(serial_number, g_default_serial_number.c_str(),
               "Serial number to use for the device");
+DEFINE_string(instance_dir, vsoc::GetDefaultPerInstanceDir(),
+              "A directory to put all instance specific files");
 DEFINE_string(system_image_dir,
               StringFromEnv("ANDROID_PRODUCT_OUT", StringFromEnv("HOME", ".")),
               "Location of the system partition images.");
@@ -117,27 +119,40 @@
             " Will be deprecated soon.");
 DEFINE_bool(start_vnc_server, true, "Whether to start the vnc server process.");
 DEFINE_string(vnc_server_binary,
-              StringFromEnv("ANDROID_HOST_OUT", StringFromEnv("HOME", ".")) +
-                  "/bin/vnc_server",
+              DefaultHostArtifactsPath("/bin/vnc_server"),
               "Location of the vnc server binary.");
 DEFINE_int32(vnc_server_port, GetPerInstanceDefault(6444),
              "The port on which the vnc server should listen");
 DEFINE_string(socket_forward_proxy_binary,
-              StringFromEnv("ANDROID_HOST_OUT", StringFromEnv("HOME", ".")) +
-                  "/bin/socket_forward_proxy",
+              DefaultHostArtifactsPath("/bin/socket_forward_proxy"),
               "Location of the socket_forward_proxy binary.");
 DEFINE_string(adb_mode, "tunnel",
               "Mode for adb connection. Can be usb for usb forwarding, or "
               "tunnel for tcp connection. If using tunnel, you may have to "
               "run 'adb kill-server' to get the device to show up.");
 DEFINE_int32(vhci_port, GetPerInstanceDefault(0), "VHCI port to use for usb");
+DEFINE_string(guest_mac_address,
+              GetPerInstanceDefault("00:43:56:44:80:"), // 00:43:56:44:80:0x
+              "MAC address of the wifi interface to be created on the guest.");
+DEFINE_string(host_mac_address,
+              "42:00:00:00:00:00",
+              "MAC address of the wifi interface running on the host.");
 DEFINE_bool(start_wifi_relay, true, "Whether to start the wifi_relay process.");
 DEFINE_string(wifi_relay_binary,
-              StringFromEnv("ANDROID_HOST_OUT", StringFromEnv("HOME", ".")) +
-                  "/bin/wifi_relay",
+              DefaultHostArtifactsPath("/bin/wifi_relay"),
               "Location of the wifi_relay binary.");
+std::string g_default_wifi_interface{GetPerInstanceDefault("cvd-wifi-")};
+DEFINE_string(wifi_interface, g_default_wifi_interface.c_str(),
+              "Network interface to use for wifi");
+// TODO(b/72969289) This should be generated
+DEFINE_string(dtb, DefaultHostArtifactsPath("config/cuttlefish.dtb"),
+              "Path to the cuttlefish.dtb file");
 
-DECLARE_string(uuid);
+constexpr char kDefaultUuidPrefix[] = "699acfc4-c8c4-11e7-882b-5065f31dc1";
+DEFINE_string(uuid, vsoc::GetPerInstanceDefault(kDefaultUuidPrefix).c_str(),
+              "UUID to use for the device. Random if not specified");
+
+DECLARE_string(config_file);
 
 namespace {
 const std::string kDataPolicyUseExisting = "use_existing";
@@ -147,10 +162,6 @@
 constexpr char kAdbModeTunnel[] = "tunnel";
 constexpr char kAdbModeUsb[] = "usb";
 
-std::string GetVirshOptions() {
-  return std::string("-c ").append(FLAGS_hypervisor_uri);
-}
-
 // VirtualUSBManager manages virtual USB device presence for Cuttlefish.
 class VirtualUSBManager {
  public:
@@ -196,9 +207,8 @@
 // Cuttlefish and host-side daemons.
 class IVServerManager {
  public:
-  IVServerManager()
-      : server_(ivserver::IVServerOptions(FLAGS_mempath,
-                                          FLAGS_qemusocket,
+  IVServerManager(const std::string& mempath, const std::string& qemu_socket)
+      : server_(ivserver::IVServerOptions(mempath, qemu_socket,
                                           vsoc::GetDomain())) {}
 
   ~IVServerManager() = default;
@@ -256,8 +266,16 @@
                 bool wait_for_child = true) {
   pid_t pid = fork();
   if (!pid) {
-    int rval = execve(command[0], const_cast<char* const*>(command),
-                      const_cast<char* const*>(envp));
+    int rval;
+    // If envp is NULL, the current process's environment is used as the
+    // environment of the child process. To force an empty emvironment for the
+    // child process pass the address of a pointer to NULL
+    if (envp == NULL) {
+      rval = execv(command[0], const_cast<char* const*>(command));
+    } else {
+      rval = execve(command[0], const_cast<char* const*>(command),
+                    const_cast<char* const*>(envp));
+    }
     // No need for an if: if exec worked it wouldn't have returned
     LOG(ERROR) << "exec of " << command[0] << " failed (" << strerror(errno)
                << ")";
@@ -276,6 +294,11 @@
   }
 }
 
+bool FileExists(const char* path) {
+  struct stat unused;
+  return stat(path, &unused) != -1 || errno != ENOENT;
+}
+
 void CreateBlankImage(
     const std::string& image, int image_mb, const std::string& image_fmt) {
   LOG(INFO) << "Creating " << image;
@@ -299,6 +322,84 @@
   subprocess(rm_command, NULL);
 }
 
+bool ApplyDataImagePolicy(const char* data_image) {
+  bool data_exists = FileExists(data_image);
+  bool remove{};
+  bool create{};
+
+  if (FLAGS_data_policy == kDataPolicyUseExisting) {
+    if (!data_exists) {
+      LOG(FATAL) << "Specified data image file does not exists: " << data_image;
+      return false;
+    }
+    if (FLAGS_blank_data_image_mb > 0) {
+      LOG(FATAL) << "You should NOT use -blank_data_image_mb with -data_policy="
+                 << kDataPolicyUseExisting;
+      return false;
+    }
+    create = false;
+    remove = false;
+  } else if (FLAGS_data_policy == kDataPolicyAlwaysCreate) {
+    remove = data_exists;
+    create = true;
+  } else if (FLAGS_data_policy == kDataPolicyCreateIfMissing) {
+    create = !data_exists;
+    remove = false;
+  } else {
+    LOG(FATAL) << "Invalid data_policy: " << FLAGS_data_policy;
+  }
+
+  if (remove) {
+    RemoveFile(data_image);
+  }
+
+  if (create) {
+    if (FLAGS_blank_data_image_mb <= 0) {
+      LOG(FATAL) << "-blank_data_image_mb is required to create data image";
+    }
+    CreateBlankImage(
+        data_image, FLAGS_blank_data_image_mb, FLAGS_blank_data_image_fmt);
+  } else {
+    LOG(INFO) << data_image << " exists. Not creating it.";
+  }
+
+  return true;
+}
+
+bool EnsureDirExists(const char* dir) {
+  if (!FileExists(dir)) {
+    LOG(INFO) << "Setting up " << dir;
+    if (mkdir(dir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0) {
+      if (errno == EACCES) {
+        // TODO(79170615) Don't use sudo once libvirt is replaced
+        LOG(WARNING) << "Not enough permission to create " << dir
+                     << " retrying with sudo";
+        const char* mkdir_command[]{"/usr/bin/sudo", "/bin/mkdir", "-m",
+                                    "0775",          dir,          NULL};
+        subprocess(mkdir_command, NULL);
+
+        // When created with sudo the owner and group is root.
+        std::string user_group = getenv("USER");
+        user_group += ":libvirt-qemu";
+        const char* chown_cmd[] = {"/usr/bin/sudo", "/bin/chown",
+                                   user_group.c_str(), dir, NULL};
+        subprocess(chown_cmd, NULL);
+      } else {
+        LOG(FATAL) << "Unable to create " << dir << ". Error: " << errno;
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+std::string GetConfigFile() {
+  return vsoc::CuttlefishConfig::Get()->PerInstancePath(
+      "cuttlefish_config.json");
+}
+
+std::string GetConfigFileArg() { return "-config_file=" + GetConfigFile(); }
+
 std::string GetGuestPortArg() {
   constexpr int kEmulatorPort = 5555;
   return std::string{"--guest_ports="} + std::to_string(kEmulatorPort);
@@ -310,14 +411,6 @@
       std::to_string(vsoc::GetPerInstanceDefault(kFirstHostPort));
 }
 
-std::string GetDomainArg() {
-  return std::string{"--domain="} + vsoc::GetDomain();
-}
-
-std::string GetInstanceArg() {
-  return std::string{"--instance="} + std::to_string(FLAGS_instance);
-}
-
 void ValidateAdbModeFlag() {
   CHECK(FLAGS_adb_mode == kAdbModeUsb ||
         FLAGS_adb_mode == kAdbModeTunnel) << "invalid --adb_mode";
@@ -335,15 +428,13 @@
   if (AdbTunnelEnabled()) {
     auto guest_port_arg = GetGuestPortArg();
     auto host_port_arg = GetHostPortArg();
-    auto domain_arg = GetDomainArg();
-    auto instance_arg = GetInstanceArg();
+    auto config_arg = GetConfigFileArg();
 
     const char* const socket_proxy[] = {
       FLAGS_socket_forward_proxy_binary.c_str(),
       guest_port_arg.c_str(),
       host_port_arg.c_str(),
-      domain_arg.c_str(),
-      instance_arg.c_str(),
+      config_arg.c_str(),
       NULL
     };
     subprocess(socket_proxy, nullptr, false);
@@ -354,13 +445,11 @@
   if (FLAGS_start_vnc_server) {
     // Launch the vnc server, don't wait for it to complete
     auto port_options = "-port=" + std::to_string(FLAGS_vnc_server_port);
-    auto domain_arg = GetDomainArg();
-    auto instance_arg = GetInstanceArg();
+    auto config_arg = GetConfigFileArg();
     const char* vnc_command[] = {
       FLAGS_vnc_server_binary.c_str(),
       port_options.c_str(),
-      domain_arg.c_str(),
-      instance_arg.c_str(),
+      config_arg.c_str(),
       NULL
     };
     subprocess(vnc_command, NULL, false);
@@ -370,45 +459,22 @@
 void LaunchWifiRelayIfEnabled() {
   if (FLAGS_start_wifi_relay) {
     // Launch the wifi relay, don't wait for it to complete
-    auto domain_arg = GetDomainArg();
-    auto instance_arg = GetInstanceArg();
-
+    auto config_arg = GetConfigFileArg();
     const char* relay_command[] = {
         "/usr/bin/sudo",
+        "-E",
         FLAGS_wifi_relay_binary.c_str(),
-        domain_arg.c_str(),
-        instance_arg.c_str(),
+        config_arg.c_str(),
         NULL
     };
 
     subprocess(relay_command, NULL /* envp */, false /* wait_for_child */);
   }
 }
-
-}  // anonymous namespace
-
-int main(int argc, char** argv) {
-  ::android::base::InitLogging(argv, android::base::StderrLogger);
-  google::ParseCommandLineFlags(&argc, &argv, true);
-  ValidateAdbModeFlag();
-
-  LOG_IF(FATAL, FLAGS_system_image_dir.empty())
-      << "--system_image_dir must be specified.";
-
-  std::string per_instance_dir = vsoc::GetDefaultPerInstanceDir();
-  struct stat unused;
-  if ((stat(per_instance_dir.c_str(), &unused) == -1) && (errno == ENOENT)) {
-    LOG(INFO) << "Setting up " << per_instance_dir;
-    const char* mkdir_command[]{
-        "/usr/bin/sudo",          "/bin/mkdir", "-m", "0775",
-        per_instance_dir.c_str(), NULL};
-    subprocess(mkdir_command, NULL);
-    std::string owner_group{getenv("USER")};
-    owner_group += ":libvirt-qemu";
-    const char* chown_command[]{"/usr/bin/sudo", "/bin/chown",
-                                owner_group.c_str(), per_instance_dir.c_str(),
-                                NULL};
-    subprocess(chown_command, NULL);
+bool ResolveInstanceFiles() {
+  if (FLAGS_system_image_dir.empty()) {
+    LOG(FATAL) << "--system_image_dir must be specified.";
+    return false;
   }
 
   // If user did not specify location of either of these files, expect them to
@@ -416,165 +482,186 @@
   if (FLAGS_kernel.empty()) {
     FLAGS_kernel = FLAGS_system_image_dir + "/kernel";
   }
-
   if (FLAGS_kernel_command_line.empty()) {
     FLAGS_kernel_command_line = FLAGS_system_image_dir + "/cmdline";
   }
-
+  if (FLAGS_system_image.empty()) {
+    FLAGS_system_image = FLAGS_system_image_dir + "/system.img";
+  }
   if (FLAGS_initrd.empty()) {
     FLAGS_initrd = FLAGS_system_image_dir + "/ramdisk.img";
   }
-
   if (FLAGS_cache_image.empty()) {
     FLAGS_cache_image = FLAGS_system_image_dir + "/cache.img";
   }
-
-  if (FLAGS_data_policy == kDataPolicyCreateIfMissing) {
-    FLAGS_data_image = FLAGS_system_image_dir + "/userdata_blank.img";
-    if (FLAGS_blank_data_image_mb <= 0) {
-      LOG(FATAL) << "You should use -blank_data_image_mb with -data_policy="
-                 << kDataPolicyCreateIfMissing;
-    }
-    // Create a blank data image if the image doesn't exist yet
-    if ((stat(FLAGS_data_image.c_str(), &unused) == -1) && (errno == ENOENT)) {
-      CreateBlankImage(
-          FLAGS_data_image, FLAGS_blank_data_image_mb, FLAGS_blank_data_image_fmt);
-    } else {
-      LOG(INFO) << FLAGS_data_image << " exists. Not creating it.";
-    }
-  } else if (FLAGS_data_policy == kDataPolicyAlwaysCreate) {
-    FLAGS_data_image = FLAGS_system_image_dir + "/userdata_blank.img";
-    if (FLAGS_blank_data_image_mb <= 0) {
-      LOG(FATAL) << "You should use -blank_data_image_mb with -data_policy="
-                 << kDataPolicyAlwaysCreate;
-    }
-    RemoveFile(FLAGS_data_image);
-    CreateBlankImage(
-        FLAGS_data_image, FLAGS_blank_data_image_mb, FLAGS_blank_data_image_fmt);
-  } else if (FLAGS_data_policy == kDataPolicyUseExisting) {
-    // Do nothing. Use FLAGS_data_image.
-    if (FLAGS_blank_data_image_mb > 0) {
-      LOG(FATAL) << "You should NOT use -blank_data_image_mb with -data_policy="
-                 << kDataPolicyUseExisting;
-    }
-  } else {
-    LOG(FATAL) << "Invalid data_policy: " << FLAGS_data_policy;
-  }
-
   if (FLAGS_data_image.empty()) {
     FLAGS_data_image = FLAGS_system_image_dir + "/userdata.img";
   }
-
   if (FLAGS_vendor_image.empty()) {
     FLAGS_vendor_image = FLAGS_system_image_dir + "/vendor.img";
   }
 
-  // Each of these calls is free to fail and terminate launch if file does not
-  // exist or could not be created.
-  auto system_partition = config::FilePartition::ReuseExistingFile(
-      FLAGS_system_image_dir + "/system.img");
-  auto data_partition =
-      config::FilePartition::ReuseExistingFile(FLAGS_data_image);
-  auto cache_partition =
-      config::FilePartition::ReuseExistingFile(FLAGS_cache_image);
-  auto vendor_partition =
-      config::FilePartition::ReuseExistingFile(FLAGS_vendor_image);
-
-  std::ostringstream cmdline;
-  std::ifstream t(FLAGS_kernel_command_line);
-  if (!t) {
-    LOG(FATAL) << "Unable to open " << FLAGS_kernel_command_line;
-  }
-  cmdline << t.rdbuf();
-  t.close();
-  cmdline << " androidboot.serialno=" << FLAGS_serial_number;
-  cmdline << " androidboot.lcd_density=" << FLAGS_dpi;
-  if (FLAGS_extra_kernel_command_line.size()) {
-    cmdline << " " << FLAGS_extra_kernel_command_line;
+  // Create data if necessary
+  if (!ApplyDataImagePolicy(FLAGS_data_image.c_str())) {
+    return false;
   }
 
-  std::string entropy_source = "/dev/urandom";
+  // Check that the files exist
+  for (const auto& file :
+       {FLAGS_system_image, FLAGS_vendor_image, FLAGS_cache_image, FLAGS_kernel,
+        FLAGS_initrd, FLAGS_data_image, FLAGS_kernel_command_line}) {
+    if (!FileExists(file.c_str())) {
+      LOG(FATAL) << "File not found: " << file;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SetUpGlobalConfiguration() {
+  if (!ResolveInstanceFiles()) {
+    return false;
+  }
   auto& memory_layout = *vsoc::VSoCMemoryLayout::Get();
-
-  config::GuestConfig cfg;
-  cfg.SetID(FLAGS_instance)
-      .SetVCPUs(FLAGS_cpus)
-      .SetMemoryMB(FLAGS_memory_mb)
-      .SetKernelName(FLAGS_kernel)
-      .SetInitRDName(FLAGS_initrd)
-      .SetKernelArgs(cmdline.str())
-      .SetIVShMemSocketPath(FLAGS_qemusocket)
-      .SetIVShMemVectorCount(memory_layout.GetRegions().size())
-      .SetSystemPartitionPath(system_partition->GetName())
-      .SetCachePartitionPath(cache_partition->GetName())
-      .SetDataPartitionPath(data_partition->GetName())
-      .SetVendorPartitionPath(vendor_partition->GetName())
-      .SetMobileBridgeName(FLAGS_mobile_interface)
-      .SetEntropySource(entropy_source)
-      .SetDisableDACSecurity(FLAGS_disable_dac_security)
-      .SetDisableAppArmorSecurity(FLAGS_disable_app_armor_security)
-      .SetUUID(FLAGS_uuid);
-  if(AdbUsbEnabled()) {
-    cfg.SetUSBV1SocketName(
-        GetDefaultPerInstancePath(cfg.GetInstanceName() + "-usb"));
-  }
-  cfg.SetKernelLogSocketName(
-      GetDefaultPerInstancePath(cfg.GetInstanceName() + "-kernel-log"));
-
-  std::string xml = cfg.Build();
-  if (FLAGS_log_xml) {
-    LOG(INFO) << "Using XML:\n" << xml;
+  auto config = vsoc::CuttlefishConfig::Get();
+  // Set this first so that calls to PerInstancePath below are correct
+  config->set_instance_dir(FLAGS_instance_dir);
+  if (!EnsureDirExists(FLAGS_instance_dir.c_str())) {
+    return false;
   }
 
-  VirtualUSBManager vadb(cfg.GetUSBV1SocketName(), FLAGS_vhci_port,
-                         GetPerInstanceDefault("android_usbip"));
-  vadb.Start();
+  config->set_serial_number(FLAGS_serial_number);
 
+  config->set_cpus(FLAGS_cpus);
+  config->set_memory_mb(FLAGS_memory_mb);
+
+  config->set_dpi(FLAGS_dpi);
+  config->set_x_res(FLAGS_x_res);
+  config->set_y_res(FLAGS_y_res);
+  config->set_refresh_rate_hz(FLAGS_refresh_rate_hz);
+
+  config->set_kernel_image_path(FLAGS_kernel);
+  std::ostringstream extra_cmdline;
+  extra_cmdline << " androidboot.serialno=" << FLAGS_serial_number;
+  extra_cmdline << " androidboot.lcd_density=" << FLAGS_dpi;
+  if (FLAGS_extra_kernel_command_line.size()) {
+    extra_cmdline << " " << FLAGS_extra_kernel_command_line;
+  }
+  config->ReadKernelArgs(FLAGS_kernel_command_line.c_str(),
+                         extra_cmdline.str());
+
+  config->set_ramdisk_image_path(FLAGS_initrd);
+  config->set_system_image_path(FLAGS_system_image);
+  config->set_cache_image_path(FLAGS_cache_image);
+  config->set_data_image_path(FLAGS_data_image);
+  config->set_vendor_image_path(FLAGS_vendor_image);
+  config->set_dtb_path(FLAGS_dtb);
+
+  config->set_mempath(FLAGS_mempath);
+  config->set_ivshmem_qemu_socket_path(
+      config->PerInstancePath("ivshmem_socket_qemu"));
+  config->set_ivshmem_client_socket_path(
+      config->PerInstancePath("ivshmem_socket_client"));
+  config->set_ivshmem_vector_count(memory_layout.GetRegions().size());
+
+  config->set_usb_v1_socket_name(config->PerInstancePath("usb-v1"));
+  config->set_vhci_port(FLAGS_vhci_port);
+  config->set_usb_ip_socket_name(config->PerInstancePath("usb-ip"));
+
+  config->set_kernel_log_socket_name(config->PerInstancePath("kernel-log"));
+  config->set_console_path(config->PerInstancePath("console"));
+  config->set_logcat_path(config->PerInstancePath("logcat"));
+
+  config->set_mobile_bridge_name(FLAGS_mobile_interface);
+  config->set_mobile_tap_name(FLAGS_mobile_tap_name);
+
+  config->set_wifi_guest_mac_addr(FLAGS_guest_mac_address);
+  config->set_wifi_host_mac_addr(FLAGS_host_mac_address);
+
+  config->set_entropy_source("/dev/urandom");
+  config->set_uuid(FLAGS_uuid);
+
+  config->set_disable_dac_security(FLAGS_disable_dac_security);
+  config->set_disable_app_armor_security(FLAGS_disable_app_armor_security);
+
+  if(!AdbUsbEnabled()) {
+    config->disable_usb_adb();
+  }
+
+  return true;
+}
+
+}  // anonymous namespace
+
+namespace launch_cvd {
+void ParseCommandLineFlags(int argc, char** argv) {
+  // The config_file is created by the launcher, so the launcher is the only
+  // host process that doesn't use the flag.
+  // Set the default to empty.
+  google::SetCommandLineOptionWithMode("config_file", "",
+                                       gflags::SET_FLAGS_DEFAULT);
+  google::ParseCommandLineFlags(&argc, &argv, true);
+  // Set the flag value to empty (in case the caller passed a value for it).
+  FLAGS_config_file = "";
+
+  ValidateAdbModeFlag();
+}
+}  // namespace launch_cvd
+
+int main(int argc, char** argv) {
+  ::android::base::InitLogging(argv, android::base::StderrLogger);
+  launch_cvd::ParseCommandLineFlags(argc, argv);
+
+  // Do this early so that the config object is ready for anything that needs it
+  if (!SetUpGlobalConfiguration()) {
+    return -1;
+  }
+
+  auto& memory_layout = *vsoc::VSoCMemoryLayout::Get();
   // TODO(b/79170615) These values need to go to the config object/file and the
   // region resizing be done by the ivserver process (or maybe the config
   // library to ensure all processes have the correct value?)
-  size_t screen_size =
+  size_t screen_region_size =
       memory_layout
           .GetRegionByName(vsoc::layout::screen::ScreenLayout::region_name)
           ->region_size();
   auto actual_width = ((FLAGS_x_res * 4) + 15) & ~15;  // aligned to 16
-  screen_size += FLAGS_num_screen_buffers *
+  screen_region_size += FLAGS_num_screen_buffers *
                  (actual_width * FLAGS_y_res + 16 /* padding */);
-  screen_size += (FLAGS_num_screen_buffers - 1) * 4096; /* Guard pages */
+  screen_region_size += (FLAGS_num_screen_buffers - 1) * 4096; /* Guard pages */
   memory_layout.ResizeRegion(vsoc::layout::screen::ScreenLayout::region_name,
-                             screen_size);
+                             screen_region_size);
   // TODO(b/79170615) Resize gralloc region too.
 
-  IVServerManager ivshmem;
+
+  auto config = vsoc::CuttlefishConfig::Get();
+  // Save the config object before starting any host process
+  if (!config->SaveToFile(GetConfigFile())) {
+    return -1;
+  }
+
+  // Start the usb manager
+  VirtualUSBManager vadb(config->usb_v1_socket_name(), config->vhci_port(),
+                         config->usb_ip_socket_name());
+  vadb.Start();
+
+  // Start IVServer
+  IVServerManager ivshmem(config->mempath(), config->ivshmem_qemu_socket_path());
   ivshmem.Start();
-  KernelLogMonitor kmon(cfg.GetKernelLogSocketName(),
-                        GetDefaultPerInstancePath("kernel.log"),
+
+  KernelLogMonitor kmon(config->kernel_log_socket_name(),
+                        config->PerInstancePath("kernel.log"),
                         FLAGS_deprecated_boot_completed);
   kmon.Start();
 
-  sleep(1);
-
-  // Initialize the regions that require it before the VM starts.
+  // Initialize the regions that require so before the VM starts.
   PreLaunchInitializers::Initialize();
 
-  std::string launch_command = FLAGS_launch_command;
-  auto pos = launch_command.find(VIRSH_OPTIONS_PLACEHOLDER);
-  if (pos != std::string::npos) {
-    launch_command.replace(
-        pos, sizeof(VIRSH_OPTIONS_PLACEHOLDER) - 1, GetVirshOptions());
-  }
-
-  FILE* launch = popen(launch_command.c_str(), "w");
-  if (!launch) {
-    LOG(FATAL) << "Unable to execute " << launch_command;
-  }
-  int rval = fputs(xml.c_str(), launch);
-  if (rval == EOF) {
-    LOG(FATAL) << "Launch command exited while accepting XML";
-  }
-  int exit_code = pclose(launch);
-  if (exit_code) {
-    LOG(FATAL) << "Launch command exited with status " << exit_code;
+  // Start the guest VM
+  vm_manager::LibvirtManager libvirt;
+  if (!libvirt.Start()) {
+    LOG(FATAL) << "Unable to start libvirt";
+    return -1;
   }
 
   LaunchSocketForwardProxyIfEnabled();
diff --git a/host/commands/launch/ril_region_handler.cc b/host/commands/launch/ril_region_handler.cc
index e122e29..31f5107 100644
--- a/host/commands/launch/ril_region_handler.cc
+++ b/host/commands/launch/ril_region_handler.cc
@@ -22,21 +22,13 @@
 #include <memory>
 #include <string>
 
-#include <gflags/gflags.h>
-#include <glog/logging.h>
-#include <libxml/parser.h>
-#include <libxml/tree.h>
-
 #include "common/vsoc/lib/ril_region_view.h"
 #include "host/commands/launch/pre_launch_initializers.h"
-#include "host/libs/config/host_config.h"
-
-DECLARE_string(hypervisor_uri);
-DECLARE_string(mobile_interface);
+#include "host/libs/config/cuttlefish_config.h"
 
 namespace {
 
-int number_of_ones(int val) {
+int number_of_ones(unsigned long val) {
   int ret = 0;
   while (val) {
     ret += val % 2;
@@ -54,7 +46,7 @@
   std::string ril_broadcast;
 
   bool ObtainConfig(const std::string& interface) {
-    bool ret = ParseLibvirtXml(interface) && GetBroadcastAddr(interface);
+    bool ret = ParseIntefaceAttributes(interface);
     LOG(INFO) << "Network config:";
     LOG(INFO) << "ipaddr = " << ril_ipaddr;
     LOG(INFO) << "gateway = " << ril_gateway;
@@ -65,102 +57,74 @@
   }
 
  private:
-  bool GetBroadcastAddr(const std::string& interface) {
-    struct ifaddrs *ifap{}, *ifa{};
-    struct sockaddr_in *sa{};
-    char *addr{};
-    getifaddrs (&ifap);
-    for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
-      if (ifa->ifa_addr && ifa->ifa_addr->sa_family==AF_INET) {
-        if (strcmp(ifa->ifa_name, interface.c_str())) continue;
-        sa = reinterpret_cast<sockaddr_in*>(ifa->ifa_ifu.ifu_broadaddr);
-        addr = inet_ntoa(sa->sin_addr);
-        this->ril_broadcast = strtok(addr, "\n");
+  bool ParseIntefaceAttributes(struct ifaddrs* ifa) {
+    // if (ifa->ifa_addr->sa_family != AF_INET) {
+    //   LOG(ERROR) << "The " << ifa->ifa_name << " interface is not IPv4";
+    //   return false;
+    // }
+    struct sockaddr_in* sa;
+    char* addr_str;
+
+    // Gateway
+    sa = reinterpret_cast<sockaddr_in*>(ifa->ifa_addr);
+    addr_str = inet_ntoa(sa->sin_addr);
+    this->ril_gateway = strtok(addr_str, "\n");
+    auto gateway_s_addr = ntohl(sa->sin_addr.s_addr);
+
+    // Broadcast
+    sa = reinterpret_cast<sockaddr_in*>(ifa->ifa_broadaddr);
+    addr_str = inet_ntoa(sa->sin_addr);
+    this->ril_broadcast = strtok(addr_str, "\n");
+    auto broadcast_s_addr = ntohl(sa->sin_addr.s_addr);
+
+    // Netmask
+    sa = reinterpret_cast<sockaddr_in*>(ifa->ifa_netmask);
+    this->ril_prefixlen = number_of_ones(sa->sin_addr.s_addr);
+    auto netmask_s_addr = ntohl(sa->sin_addr.s_addr);
+
+    // Address (Find an address in the network different than the network, the
+    // gateway and the broadcast)
+    auto network = gateway_s_addr & netmask_s_addr;
+    auto s_addr = network + 1;
+    // s_addr & ~netmask_s_addr is zero when s_addr wraps around the network
+    while (s_addr & ~netmask_s_addr) {
+      if (s_addr != gateway_s_addr && s_addr != broadcast_s_addr) {
+        break;
       }
+      ++s_addr;
     }
-
-    freeifaddrs(ifap);
-    return (this->ril_broadcast.size() > 0);
-  }
-
-  bool ParseLibvirtXml(const std::string& interface) {
-    std::string net_dump_command =
-        "virsh -c " + FLAGS_hypervisor_uri + " net-dumpxml " + interface;
-    std::shared_ptr<FILE> net_xml_file(popen(net_dump_command.c_str(), "r"),
-                                       pclose);
-    if (!net_xml_file) {
-      LOG(ERROR) << "Unable to popen virsh...";
+    if (s_addr == network) {
+      LOG(ERROR) << "No available address found in interface " << ifa->ifa_name;
       return false;
     }
-    std::shared_ptr<xmlDoc> doc(
-        xmlReadFd(fileno(net_xml_file.get()), NULL, NULL, 0), xmlFreeDoc);
-    if (!doc) {
-      LOG(ERROR) << "Unable to parse network xml";
-      return false;
-    }
-
-    xmlNode* element = xmlDocGetRootElement(doc.get());
-    element = element->xmlChildrenNode;
-    while (element) {
-      if (strcmp(reinterpret_cast<const char*>(element->name), "ip") == 0) {
-        return ProcessIpNode(element);
-      }
-      element = element->next;
-    }
-    LOG(ERROR) << "ip node not found in network xml spec";
-    return false;
-  }
-
-  bool ParseIpAttributes(xmlNode* ip_node) {
-    // The gateway is the host ip address
-    this->ril_gateway = reinterpret_cast<const char*>(
-        xmlGetProp(ip_node, reinterpret_cast<const xmlChar*>("address")));
-
-    // The prefix length need to be obtained from the network mask
-    auto* netmask = reinterpret_cast<const char*>(
-        xmlGetProp(ip_node, reinterpret_cast<const xmlChar*>("netmask")));
-    int byte1, byte2, byte3, byte4;
-    sscanf(netmask, "%d.%d.%d.%d", &byte1, &byte2, &byte3, &byte4);
-    this->ril_prefixlen = 0;
-    this->ril_prefixlen += number_of_ones(byte1);
-    this->ril_prefixlen += number_of_ones(byte2);
-    this->ril_prefixlen += number_of_ones(byte3);
-    this->ril_prefixlen += number_of_ones(byte4);
+    struct in_addr addr;
+    addr.s_addr = htonl(s_addr);
+    addr_str = inet_ntoa(addr);
+    this->ril_ipaddr = strtok(addr_str, "\n");
     return true;
   }
 
-  bool ProcessDhcpNode(xmlNode* dhcp_node) {
-    xmlNode* child = dhcp_node->xmlChildrenNode;
-    while (child) {
-      if (strcmp(reinterpret_cast<const char*>(child->name), "range") == 0) {
-        this->ril_ipaddr = reinterpret_cast<const char*>(
-            xmlGetProp(child, reinterpret_cast<const xmlChar*>("start")));
-        return true;
+  bool ParseIntefaceAttributes(const std::string& interface) {
+    struct ifaddrs *ifa_list{}, *ifa{};
+    bool ret = false;
+    getifaddrs(&ifa_list);
+    for (ifa = ifa_list; ifa; ifa = ifa->ifa_next) {
+      if (strcmp(ifa->ifa_name, interface.c_str()) == 0 &&
+          ifa->ifa_addr->sa_family == AF_INET) {
+        ret = ParseIntefaceAttributes(ifa);
+        break;
       }
-      child = child->next;
     }
-    LOG(ERROR) << "range node not found in network xml spec";
-    return false;
-  }
-
-  bool ProcessIpNode(xmlNode* ip_node) {
-    ParseIpAttributes(ip_node);
-    xmlNode* child = ip_node->xmlChildrenNode;
-    while (child) {
-      if (strcmp(reinterpret_cast<const char*>(child->name), "dhcp") == 0) {
-        return ProcessDhcpNode(child);
-      }
-      child = child->next;
-    }
-    LOG(ERROR) << "dhcp node not found in network xml spec";
-    return false;
+    freeifaddrs(ifa_list);
+    return ret;
   }
 };
 }  // namespace
 
 void InitializeRilRegion() {
   NetConfig netconfig;
-  if (!netconfig.ObtainConfig(FLAGS_mobile_interface)) {
+  auto config = vsoc::CuttlefishConfig::Get();
+  if (!netconfig.ObtainConfig(config->mobile_bridge_name())) {
     LOG(ERROR) << "Unable to obtain the network configuration";
     return;
   }
@@ -175,16 +139,12 @@
 
   auto dest = region->data();
 
-  snprintf(
-      dest->ipaddr, sizeof(dest->ipaddr), "%s", netconfig.ril_ipaddr.c_str());
-  snprintf(dest->gateway,
-           sizeof(dest->gateway),
-           "%s",
+  snprintf(dest->ipaddr, sizeof(dest->ipaddr), "%s",
+           netconfig.ril_ipaddr.c_str());
+  snprintf(dest->gateway, sizeof(dest->gateway), "%s",
            netconfig.ril_gateway.c_str());
   snprintf(dest->dns, sizeof(dest->dns), "%s", netconfig.ril_dns.c_str());
-  snprintf(dest->broadcast,
-           sizeof(dest->broadcast),
-           "%s",
+  snprintf(dest->broadcast, sizeof(dest->broadcast), "%s",
            netconfig.ril_broadcast.c_str());
   dest->prefixlen = netconfig.ril_prefixlen;
 }
diff --git a/host/commands/launch/screen_region_handler.cc b/host/commands/launch/screen_region_handler.cc
index 4214482..6e19ca1 100644
--- a/host/commands/launch/screen_region_handler.cc
+++ b/host/commands/launch/screen_region_handler.cc
@@ -14,29 +14,23 @@
  * limitations under the License.
  */
 
-#include <gflags/gflags.h>
 #include <glog/logging.h>
 
 #include "common/vsoc/lib/screen_region_view.h"
 #include "host/commands/launch/pre_launch_initializers.h"
-#include "host/libs/config/host_config.h"
-
-DEFINE_int32(x_res, 720, "Width of the screen in pixels");
-DEFINE_int32(y_res, 1280, "Height of the screen in pixels");
-DEFINE_int32(dpi, 160, "Pixels per inch for the screen");
-DEFINE_int32(refresh_rate_hz, 60, "Screen refresh rate in Hertz");
-DEFINE_int32(num_screen_buffers, 3, "The number of screen buffers");
+#include "host/libs/config/cuttlefish_config.h"
 
 void InitializeScreenRegion() {
   auto region =
       vsoc::screen::ScreenRegionView::GetInstance(vsoc::GetDomain().c_str());
+  auto config = vsoc::CuttlefishConfig::Get();
   if (!region) {
-    LOG(ERROR) << "Screen region was not found";
+    LOG(FATAL) << "Screen region was not found";
     return;
   }
   auto dest = region->data();
-  dest->x_res = FLAGS_x_res;
-  dest->y_res = FLAGS_y_res;
-  dest->dpi = FLAGS_dpi;
-  dest->refresh_rate_hz = FLAGS_refresh_rate_hz;
+  dest->x_res = config->x_res();
+  dest->y_res = config->y_res();
+  dest->dpi = config->dpi();
+  dest->refresh_rate_hz = config->refresh_rate_hz();
 }
diff --git a/host/commands/launch/wifi_region_handler.cc b/host/commands/launch/wifi_region_handler.cc
index 7f82c6a..9d87c64 100644
--- a/host/commands/launch/wifi_region_handler.cc
+++ b/host/commands/launch/wifi_region_handler.cc
@@ -14,60 +14,38 @@
  * limitations under the License.
  */
 
-#include <cassert>
 #include <string>
 
-#include <gflags/gflags.h>
 #include <glog/logging.h>
 
 #include "common/vsoc/lib/wifi_exchange_view.h"
 #include "host/commands/launch/pre_launch_initializers.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 
 using vsoc::wifi::WifiExchangeView;
 
-namespace {
-
-std::string GetPerInstanceDefaultMacAddress(const char* base_mac) {
-  WifiExchangeView::MacAddress addr;
-  if (!WifiExchangeView::ParseMACAddress(base_mac, &addr)) {
-    LOG(FATAL) << "Unable to parse MAC address: " << base_mac;
-    return "";
-  }
-  // Modify the last byte of the mac address to make it different for every cvd
-  addr.back() = static_cast<uint8_t>(vsoc::GetPerInstanceDefault(addr.back()));
-  return WifiExchangeView::MacAddressToString(addr);
-}
-
-}  // namespace
-
-DEFINE_string(guest_mac_address,
-              GetPerInstanceDefaultMacAddress("00:43:56:44:80:01"),
-              "MAC address of the wifi interface to be created on the guest.");
-
-DEFINE_string(host_mac_address,
-              "42:00:00:00:00:00",
-              "MAC address of the wifi interface running on the host.");
-
 void InitializeWifiRegion() {
   auto region = WifiExchangeView::GetInstance(vsoc::GetDomain().c_str());
+  auto config = vsoc::CuttlefishConfig::Get();
   if (!region) {
     LOG(FATAL) << "Wifi region not found";
     return;
   }
   WifiExchangeView::MacAddress guest_mac, host_mac;
-  if (!WifiExchangeView::ParseMACAddress(FLAGS_guest_mac_address, &guest_mac)) {
+  if (!WifiExchangeView::ParseMACAddress(config->wifi_guest_mac_addr(),
+                                         &guest_mac)) {
     LOG(FATAL) << "Unable to parse guest mac address: "
-               << FLAGS_guest_mac_address;
+               << config->wifi_guest_mac_addr();
     return;
   }
-  LOG(INFO) << "Setting guest mac to " << FLAGS_guest_mac_address;
+  LOG(INFO) << "Setting guest mac to " << config->wifi_guest_mac_addr();
   region->SetGuestMACAddress(guest_mac);
-  if (!WifiExchangeView::ParseMACAddress(FLAGS_host_mac_address, &host_mac)) {
+  if (!WifiExchangeView::ParseMACAddress(config->wifi_host_mac_addr(),
+                                         &host_mac)) {
     LOG(FATAL) << "Unable to parse guest mac address: "
-               << FLAGS_guest_mac_address;
+               << config->wifi_guest_mac_addr();
     return;
   }
-  LOG(INFO) << "Setting host mac to " << FLAGS_host_mac_address;
+  LOG(INFO) << "Setting host mac to " << config->wifi_host_mac_addr();
   region->SetHostMACAddress(host_mac);
 }
diff --git a/host/commands/record_audio/Android.bp b/host/commands/record_audio/Android.bp
index d380e23..b7bfe92 100644
--- a/host/commands/record_audio/Android.bp
+++ b/host/commands/record_audio/Android.bp
@@ -27,6 +27,7 @@
     ],
     static_libs: [
         "libcuttlefish_host_config",
+        "libjsoncpp",
         "libgflags",
     ],
     defaults: ["cuttlefish_host_only"],
diff --git a/host/commands/record_audio/main.cc b/host/commands/record_audio/main.cc
index 2655838..18466f3 100644
--- a/host/commands/record_audio/main.cc
+++ b/host/commands/record_audio/main.cc
@@ -17,7 +17,7 @@
 #include "common/vsoc/lib/audio_data_region_view.h"
 #include "common/vsoc/lib/circqueue_impl.h"
 #include "common/vsoc/lib/vsoc_audio_message.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 
 #include "WaveWriter.h"
 
diff --git a/host/commands/stop_cvd/Android.bp b/host/commands/stop_cvd/Android.bp
index 429fd6c..3607e8e 100644
--- a/host/commands/stop_cvd/Android.bp
+++ b/host/commands/stop_cvd/Android.bp
@@ -23,10 +23,16 @@
     ],
     shared_libs: [
         "libbase",
+        "libcuttlefish_fs",
+        "cuttlefish_auto_resources",
+        "libicuuc",
     ],
     static_libs: [
         "libcuttlefish_host_config",
+        "libcuttlefish_vm_manager",
+        "libjsoncpp",
         "libgflags",
+        "libxml2",
     ],
     defaults: ["cuttlefish_host_only"],
 }
diff --git a/host/commands/stop_cvd/main.cc b/host/commands/stop_cvd/main.cc
index 2c2baf7..08648b1 100644
--- a/host/commands/stop_cvd/main.cc
+++ b/host/commands/stop_cvd/main.cc
@@ -35,26 +35,15 @@
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 
-#include "host/libs/config/host_config.h"
-
-using vsoc::GetDefaultPerInstancePath;
-using vsoc::GetPerInstanceDefault;
-
-DECLARE_int32(instance);
-// TODO(b/78512938): These parameters should go away when the launcher work is
-// completed and the process monitor handles the shutdown.
-DEFINE_string(hypervisor_uri, "qemu:///system", "Hypervisor cannonical uri.");
-std::string g_default_mempath{GetPerInstanceDefault("/var/run/shm/cvd-")};
-DEFINE_string(mempath,
-              g_default_mempath.c_str(),
-              "Target location for the shmem file.");
+#include "host/libs/config/cuttlefish_config.h"
+#include "host/libs/vm_manager/libvirt_manager.h"
 
 namespace {
 void RunCommand(const char* command) {
-  LOG(INFO) << "Running: " << command;
   int rval = std::system(command);
   if (rval) {
-    LOG(ERROR) << "Unable to execute command: " << command;
+    LOG(ERROR) << "Unable to execute command: " << command
+               << ". Exit code: " << rval;
   }
 }
 }  // anonymous namespace
@@ -63,25 +52,28 @@
   ::android::base::InitLogging(argv, android::base::StderrLogger);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
+  int exit_code = 0;
+
   // TODO(b/78512938): Should ask the monitor to do the shutdown instead
-  std::ostringstream cvd_strm;
-  cvd_strm << "cvd-" << std::setfill('0') << std::setw(2) << FLAGS_instance;
-  auto cvd = cvd_strm.str();
-  std::string destroy_cmd = "virsh ";
-  destroy_cmd += "-c ";
-  destroy_cmd += FLAGS_hypervisor_uri;
-  destroy_cmd += " destroy ";
-  destroy_cmd += cvd;
-  RunCommand(destroy_cmd.c_str());
+  vm_manager::LibvirtManager libvirt_manager;
+  if (!libvirt_manager.Stop()) {
+    LOG(ERROR)
+        << "Error when stopping guest virtual machine. Is it still running?";
+    exit_code = 1;
+  }
+
+  auto config = vsoc::CuttlefishConfig::Get();
 
   // TODO(b/78512938): Shouldn't need sudo to shut down
-  std::string run_files = vsoc::GetDefaultPerInstanceDir() + "/*";
+  std::string run_files = config->PerInstancePath("*");
   std::string fuser_cmd = "sudo fuser -k ";
   fuser_cmd += run_files;
   fuser_cmd += " ";
-  fuser_cmd += FLAGS_mempath;
+  fuser_cmd += config->mempath();
   RunCommand(fuser_cmd.c_str());
   std::string delete_cmd = "rm -f ";
   delete_cmd += run_files;
   RunCommand(delete_cmd.c_str());
+
+  return exit_code;
 }
diff --git a/host/frontend/vnc_server/Android.bp b/host/frontend/vnc_server/Android.bp
index cf8a2c4..6508945 100644
--- a/host/frontend/vnc_server/Android.bp
+++ b/host/frontend/vnc_server/Android.bp
@@ -37,6 +37,7 @@
     ],
     static_libs: [
         "libcuttlefish_host_config",
+        "libjsoncpp",
         "libjpeg",
         "libgflags",
     ],
diff --git a/host/frontend/vnc_server/main.cpp b/host/frontend/vnc_server/main.cpp
index 2616202..eab7011 100644
--- a/host/frontend/vnc_server/main.cpp
+++ b/host/frontend/vnc_server/main.cpp
@@ -22,7 +22,7 @@
 #include "common/libs/glog/logging.h"
 #include "host/frontend/vnc_server/vnc_server.h"
 #include "host/frontend/vnc_server/vnc_utils.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 
 DEFINE_bool(agressive, false, "Whether to use agressive server");
 DEFINE_int32(port, 6444, "Port where to listen for connections");
diff --git a/host/frontend/vnc_server/simulated_hw_composer.cpp b/host/frontend/vnc_server/simulated_hw_composer.cpp
index 7141bd1..c8b7f03 100644
--- a/host/frontend/vnc_server/simulated_hw_composer.cpp
+++ b/host/frontend/vnc_server/simulated_hw_composer.cpp
@@ -17,7 +17,7 @@
 #include "host/frontend/vnc_server/simulated_hw_composer.h"
 
 #include "host/frontend/vnc_server/vnc_utils.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 #include "common/vsoc/lib/screen_region_view.h"
 
 using cvd::vnc::SimulatedHWComposer;
diff --git a/host/frontend/vnc_server/vnc_utils.h b/host/frontend/vnc_server/vnc_utils.h
index 558aa57..3eac9f3 100644
--- a/host/frontend/vnc_server/vnc_utils.h
+++ b/host/frontend/vnc_server/vnc_utils.h
@@ -23,7 +23,7 @@
 
 #include "common/libs/tcp_socket/tcp_socket.h"
 #include "common/vsoc/lib/screen_region_view.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 
 namespace cvd {
 namespace vnc {
diff --git a/host/libs/Android.bp b/host/libs/Android.bp
index 12fde97..540b9b4 100644
--- a/host/libs/Android.bp
+++ b/host/libs/Android.bp
@@ -20,4 +20,5 @@
     "ivserver",
     "vadb",
     "usbip",
+    "vm_manager",
 ]
diff --git a/host/libs/config/Android.bp b/host/libs/config/Android.bp
index df9f99b..9b70a07 100644
--- a/host/libs/config/Android.bp
+++ b/host/libs/config/Android.bp
@@ -16,9 +16,7 @@
 cc_library_host_static {
     name: "libcuttlefish_host_config",
     srcs: [
-        "file_partition.cpp",
-        "guest_config.cpp",
-        "host_config.cpp",
+        "cuttlefish_config.cpp"
     ],
     header_libs: [
         "cuttlefish_glog",
@@ -31,6 +29,7 @@
     static_libs: [
         "libxml2",
         "libgflags",
+        "libjsoncpp",
     ],
     defaults: ["cuttlefish_host_only"],
 }
diff --git a/host/libs/config/cuttlefish_config.cpp b/host/libs/config/cuttlefish_config.cpp
new file mode 100644
index 0000000..bd70a95
--- /dev/null
+++ b/host/libs/config/cuttlefish_config.cpp
@@ -0,0 +1,433 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "host/libs/config/cuttlefish_config.h"
+
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <json/json.h>
+
+DEFINE_string(config_file,
+              vsoc::GetDefaultPerInstanceDir() + "/cuttlefish_config.json",
+              "A file from where to load the config values. This flag is "
+              "ignored by the launcher");
+
+namespace {
+
+constexpr char kDefaultUuidPrefix[] = "699acfc4-c8c4-11e7-882b-5065f31dc1";
+
+int InstanceFromEnvironment() {
+  static constexpr char kInstanceEnvironmentVariable[] = "CUTTLEFISH_INSTANCE";
+  static constexpr char kVsocUserPrefix[] = "vsoc-";
+  static constexpr int kDefaultInstance = 1;
+
+  // CUTTLEFISH_INSTANCE environment variable
+  const char* instance_str = std::getenv(kInstanceEnvironmentVariable);
+  if (!instance_str) {
+    // Try to get it from the user instead
+    instance_str = std::getenv("USER");
+    if (!instance_str || std::strncmp(instance_str, kVsocUserPrefix,
+                                      sizeof(kVsocUserPrefix) - 1)) {
+      // No user or we don't recognize this user
+      return kDefaultInstance;
+    }
+    instance_str += sizeof(kVsocUserPrefix) - 1;
+    // Set the environment variable so that child processes see it
+    setenv(kInstanceEnvironmentVariable, instance_str, 0);
+  }
+
+  int instance = std::atoi(instance_str);
+  if (instance <= 0) {
+    instance = kDefaultInstance;
+  }
+
+  return instance;
+}
+const char* kSerialNumber = "serial_number";
+const char* kInstanceDir = "instance_dir";
+
+const char* kCpus = "cpus";
+const char* kMemoryMb = "memory_mb";
+const char* kDpi = "dpi";
+const char* kXRes = "x_res";
+const char* kYRes = "y_res";
+const char* kRefreshRateHz = "refresh_rate_hz";
+
+const char* kKernelImagePath = "kernel_image_path";
+const char* kKernelArgs = "kernel_args";
+const char* kRamdiskImagePath = "ramdisk_image_path";
+
+const char* kSystemImagePath = "system_image_path";
+const char* kCacheImagePath = "cache_image_path";
+const char* kDataImagePath = "data_image_path";
+const char* kVendorImagePath = "vendor_image_path";
+const char* kUsbV1SocketName = "usb_v1_socket_name";
+const char* kVhciPort = "vhci_port";
+const char* kUsbIpSocketName = "usb_ip_socket_name";
+const char* kKernelLogSocketName = "kernel_log_socket_name";
+const char* kConsolePath = "console_path";
+const char* kLogcatPath = "logcat_path";
+const char* kDtbPath = "dtb_path";
+
+const char* kMempath = "mempath";
+const char* kIvshmemQemuSocketPath = "ivshmem_qemu_socket_path";
+const char* kIvshmemClientSocketPath = "ivshmem_client_socket_path";
+const char* kIvshmemVectorCount = "ivshmem_vector_count";
+
+const char* kMobileBridgeName = "mobile_bridge_name";
+const char* kMobileTapName = "mobile_tap_name";
+const char* kWifiGuestMacAddr = "wifi_guest_mac_addr";
+const char* kWifiHostMacAddr = "wifi_host_mac_addr";
+const char* kEntropySource = "entropy_source";
+
+const char* kUuid = "uuid";
+const char* kDisableDacSecurity = "disable_dac_security";
+const char* kDisableAppArmorSecurity = "disable_app_armor_security";
+}  // namespace
+
+namespace vsoc {
+
+std::string CuttlefishConfig::instance_dir() const {
+  return (*dictionary_)[kInstanceDir].asString();
+}
+void CuttlefishConfig::set_instance_dir(const std::string& instance_dir) {
+  (*dictionary_)[kInstanceDir] = instance_dir;
+}
+
+std::string CuttlefishConfig::serial_number() const {
+  return (*dictionary_)[kSerialNumber].asString();
+}
+void CuttlefishConfig::set_serial_number(const std::string& serial_number) {
+  (*dictionary_)[kSerialNumber] = serial_number;
+}
+
+int CuttlefishConfig::cpus() const { return (*dictionary_)[kCpus].asInt(); }
+void CuttlefishConfig::set_cpus(int cpus) { (*dictionary_)[kCpus] = cpus; }
+
+int CuttlefishConfig::memory_mb() const {
+  return (*dictionary_)[kMemoryMb].asInt();
+}
+void CuttlefishConfig::set_memory_mb(int memory_mb) {
+  (*dictionary_)[kMemoryMb] = memory_mb;
+}
+
+int CuttlefishConfig::dpi() const { return (*dictionary_)[kDpi].asInt(); }
+void CuttlefishConfig::set_dpi(int dpi) { (*dictionary_)[kDpi] = dpi; }
+
+int CuttlefishConfig::x_res() const { return (*dictionary_)[kXRes].asInt(); }
+void CuttlefishConfig::set_x_res(int x_res) { (*dictionary_)[kXRes] = x_res; }
+
+int CuttlefishConfig::y_res() const { return (*dictionary_)[kYRes].asInt(); }
+void CuttlefishConfig::set_y_res(int y_res) { (*dictionary_)[kYRes] = y_res; }
+
+int CuttlefishConfig::refresh_rate_hz() const {
+  return (*dictionary_)[kRefreshRateHz].asInt();
+}
+void CuttlefishConfig::set_refresh_rate_hz(int refresh_rate_hz) {
+  (*dictionary_)[kRefreshRateHz] = refresh_rate_hz;
+}
+
+std::string CuttlefishConfig::kernel_image_path() const {
+  return (*dictionary_)[kKernelImagePath].asString();
+}
+void CuttlefishConfig::set_kernel_image_path(
+    const std::string& kernel_image_path) {
+  (*dictionary_)[kKernelImagePath] = kernel_image_path;
+}
+
+std::string CuttlefishConfig::kernel_args() const {
+  return (*dictionary_)[kKernelArgs].asString();
+}
+void CuttlefishConfig::set_kernel_args(const std::string& kernel_args) {
+  (*dictionary_)[kKernelArgs] = kernel_args;
+}
+
+std::string CuttlefishConfig::ramdisk_image_path() const {
+  return (*dictionary_)[kRamdiskImagePath].asString();
+}
+void CuttlefishConfig::set_ramdisk_image_path(
+    const std::string& ramdisk_image_path) {
+  (*dictionary_)[kRamdiskImagePath] = ramdisk_image_path;
+}
+
+std::string CuttlefishConfig::system_image_path() const {
+  return (*dictionary_)[kSystemImagePath].asString();
+}
+void CuttlefishConfig::set_system_image_path(
+    const std::string& system_image_path) {
+  (*dictionary_)[kSystemImagePath] = system_image_path;
+}
+
+std::string CuttlefishConfig::cache_image_path() const {
+  return (*dictionary_)[kCacheImagePath].asString();
+}
+void CuttlefishConfig::set_cache_image_path(
+    const std::string& cache_image_path) {
+  (*dictionary_)[kCacheImagePath] = cache_image_path;
+}
+
+std::string CuttlefishConfig::data_image_path() const {
+  return (*dictionary_)[kDataImagePath].asString();
+}
+void CuttlefishConfig::set_data_image_path(const std::string& data_image_path) {
+  (*dictionary_)[kDataImagePath] = data_image_path;
+}
+
+std::string CuttlefishConfig::vendor_image_path() const {
+  return (*dictionary_)[kVendorImagePath].asString();
+}
+void CuttlefishConfig::set_vendor_image_path(
+    const std::string& vendor_image_path) {
+  (*dictionary_)[kVendorImagePath] = vendor_image_path;
+}
+
+std::string CuttlefishConfig::dtb_path() const {
+  return (*dictionary_)[kDtbPath].asString();
+}
+void CuttlefishConfig::set_dtb_path(const std::string& dtb_path) {
+  (*dictionary_)[kDtbPath] = dtb_path;
+}
+
+std::string CuttlefishConfig::mempath() const {
+  return (*dictionary_)[kMempath].asString();
+}
+void CuttlefishConfig::set_mempath(const std::string& mempath) {
+  (*dictionary_)[kMempath] = mempath;
+}
+
+std::string CuttlefishConfig::ivshmem_qemu_socket_path() const {
+  return (*dictionary_)[kIvshmemQemuSocketPath].asString();
+}
+void CuttlefishConfig::set_ivshmem_qemu_socket_path(
+    const std::string& ivshmem_qemu_socket_path) {
+  (*dictionary_)[kIvshmemQemuSocketPath] = ivshmem_qemu_socket_path;
+}
+
+std::string CuttlefishConfig::ivshmem_client_socket_path() const {
+  return (*dictionary_)[kIvshmemClientSocketPath].asString();
+}
+void CuttlefishConfig::set_ivshmem_client_socket_path(
+    const std::string& ivshmem_client_socket_path) {
+  (*dictionary_)[kIvshmemClientSocketPath] = ivshmem_client_socket_path;
+}
+
+int CuttlefishConfig::ivshmem_vector_count() const {
+  return (*dictionary_)[kIvshmemVectorCount].asInt();
+}
+void CuttlefishConfig::set_ivshmem_vector_count(int ivshmem_vector_count) {
+  (*dictionary_)[kIvshmemVectorCount] = ivshmem_vector_count;
+}
+
+std::string CuttlefishConfig::usb_v1_socket_name() const {
+  return (*dictionary_)[kUsbV1SocketName].asString();
+}
+void CuttlefishConfig::set_usb_v1_socket_name(
+    const std::string& usb_v1_socket_name) {
+  (*dictionary_)[kUsbV1SocketName] = usb_v1_socket_name;
+}
+
+int CuttlefishConfig::vhci_port() const {
+  return (*dictionary_)[kVhciPort].asInt();
+}
+void CuttlefishConfig::set_vhci_port(int vhci_port) {
+  (*dictionary_)[kVhciPort] = vhci_port;
+}
+
+std::string CuttlefishConfig::usb_ip_socket_name() const {
+  return (*dictionary_)[kUsbIpSocketName].asString();
+}
+void CuttlefishConfig::set_usb_ip_socket_name(
+    const std::string& usb_ip_socket_name) {
+  (*dictionary_)[kUsbIpSocketName] = usb_ip_socket_name;
+}
+
+std::string CuttlefishConfig::kernel_log_socket_name() const {
+  return (*dictionary_)[kKernelLogSocketName].asString();
+}
+void CuttlefishConfig::set_kernel_log_socket_name(
+    const std::string& kernel_log_socket_name) {
+  (*dictionary_)[kKernelLogSocketName] = kernel_log_socket_name;
+}
+
+std::string CuttlefishConfig::console_path() const {
+  return (*dictionary_)[kConsolePath].asString();
+}
+void CuttlefishConfig::set_console_path(const std::string& console_path) {
+  (*dictionary_)[kConsolePath] = console_path;
+}
+
+std::string CuttlefishConfig::logcat_path() const {
+  return (*dictionary_)[kLogcatPath].asString();
+}
+void CuttlefishConfig::set_logcat_path(const std::string& logcat_path) {
+  (*dictionary_)[kLogcatPath] = logcat_path;
+}
+
+std::string CuttlefishConfig::mobile_bridge_name() const {
+  return (*dictionary_)[kMobileBridgeName].asString();
+}
+void CuttlefishConfig::set_mobile_bridge_name(
+    const std::string& mobile_bridge_name) {
+  (*dictionary_)[kMobileBridgeName] = mobile_bridge_name;
+}
+
+std::string CuttlefishConfig::wifi_guest_mac_addr() const {
+  return (*dictionary_)[kWifiGuestMacAddr].asString();
+}
+void CuttlefishConfig::set_wifi_guest_mac_addr(
+    const std::string& wifi_guest_mac_addr) {
+  (*dictionary_)[kWifiGuestMacAddr] = wifi_guest_mac_addr;
+}
+
+std::string CuttlefishConfig::wifi_host_mac_addr() const {
+  return (*dictionary_)[kWifiHostMacAddr].asString();
+}
+void CuttlefishConfig::set_wifi_host_mac_addr(
+    const std::string& wifi_host_mac_addr) {
+  (*dictionary_)[kWifiHostMacAddr] = wifi_host_mac_addr;
+}
+
+std::string CuttlefishConfig::mobile_tap_name() const {
+  return (*dictionary_)[kMobileTapName].asString();
+}
+void CuttlefishConfig::set_mobile_tap_name(const std::string& mobile_tap_name) {
+  (*dictionary_)[kMobileTapName] = mobile_tap_name;
+}
+
+std::string CuttlefishConfig::entropy_source() const {
+  return (*dictionary_)[kEntropySource].asString();
+}
+void CuttlefishConfig::set_entropy_source(const std::string& entropy_source) {
+  (*dictionary_)[kEntropySource] = entropy_source;
+}
+
+std::string CuttlefishConfig::uuid() const {
+  return (*dictionary_)[kUuid].asString();
+}
+void CuttlefishConfig::set_uuid(const std::string& uuid) {
+  (*dictionary_)[kUuid] = uuid;
+}
+
+bool CuttlefishConfig::disable_dac_security() const {
+  return (*dictionary_)[kDisableDacSecurity].asBool();
+}
+void CuttlefishConfig::set_disable_dac_security(bool disable_dac_security) {
+  (*dictionary_)[kDisableDacSecurity] = disable_dac_security;
+}
+
+bool CuttlefishConfig::disable_app_armor_security() const {
+  return (*dictionary_)[kDisableAppArmorSecurity].asBool();
+}
+void CuttlefishConfig::set_disable_app_armor_security(
+    bool disable_app_armor_security) {
+  (*dictionary_)[kDisableAppArmorSecurity] = disable_app_armor_security;
+}
+
+/*static*/ CuttlefishConfig* CuttlefishConfig::Get() {
+  static CuttlefishConfig config;
+  return &config;
+}
+
+CuttlefishConfig::CuttlefishConfig() : dictionary_(new Json::Value()) {
+  if (!FLAGS_config_file.empty()) {
+    LoadFromFile(FLAGS_config_file.c_str());
+  }
+}
+
+void CuttlefishConfig::LoadFromFile(const char* file) {
+  char real_file_path[PATH_MAX];
+  if (realpath(file, real_file_path) == nullptr) {
+    LOG(FATAL) << "Could not get real path for file " << file << ": "
+               << strerror(errno);
+  }
+
+  Json::Reader reader;
+  std::ifstream ifs(real_file_path);
+  if (!reader.parse(ifs, *dictionary_)) {
+    LOG(FATAL) << "Could not read config file " << file << ": "
+               << reader.getFormattedErrorMessages();
+  }
+}
+bool CuttlefishConfig::SaveToFile(const std::string& file) const {
+  std::ofstream ofs(file);
+  if (!ofs.is_open()) {
+    LOG(ERROR) << "Unable to write to file " << file;
+    return false;
+  }
+  ofs << *dictionary_;
+  return !ofs.fail();
+}
+
+std::string CuttlefishConfig::PerInstancePath(const char* file_name) const {
+  return (instance_dir() + "/") + file_name;
+}
+
+std::string CuttlefishConfig::instance_name() const {
+  return GetPerInstanceDefault("cvd-");
+}
+
+bool CuttlefishConfig::ReadKernelArgs(const std::string& cmdline_file,
+                                      const std::string& extra_args) {
+  std::ostringstream kernel_args;
+  std::ifstream cmd_stream(cmdline_file);
+  if (!cmd_stream) {
+    LOG(WARNING) << "Unable to open " << cmdline_file;
+    return false;
+  } else {
+    kernel_args << cmd_stream.rdbuf();
+    cmd_stream.close();
+  }
+  if (!extra_args.empty()) {
+    kernel_args << " " << extra_args;
+  }
+  set_kernel_args(kernel_args.str());
+  return true;
+}
+
+int GetInstance() {
+  static int instance_id = InstanceFromEnvironment();
+  return instance_id;
+}
+
+std::string GetDomain() {
+  return CuttlefishConfig::Get()->ivshmem_client_socket_path();
+}
+
+std::string GetPerInstanceDefault(const char* prefix) {
+  std::ostringstream stream;
+  stream << prefix << std::setfill('0') << std::setw(2) << GetInstance();
+  return stream.str();
+}
+int GetPerInstanceDefault(int base) { return base + GetInstance() - 1; }
+
+std::string GetDefaultPerInstanceDir() {
+  // TODO(79170615): Change to a directory in home once libvirt is no longer
+  // default.
+  std::ostringstream stream;
+  stream << "/var/run/libvirt-" << kDefaultUuidPrefix << std::setfill('0')
+         << std::setw(2) << GetInstance();
+  return stream.str();
+}
+
+}  // namespace vsoc
diff --git a/host/libs/config/cuttlefish_config.h b/host/libs/config/cuttlefish_config.h
new file mode 100644
index 0000000..50e8616
--- /dev/null
+++ b/host/libs/config/cuttlefish_config.h
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <memory>
+#include <string>
+
+namespace Json {
+class Value;
+}
+
+namespace vsoc {
+
+// Holds the configuration of the cuttlefish instances.
+class CuttlefishConfig {
+ public:
+  static CuttlefishConfig* Get();
+  ~CuttlefishConfig() = default;
+
+  // Saves the configuration object in a file, it can then be read in other
+  // processes by passing the --config_file option.
+  bool SaveToFile(const std::string& file) const ;
+
+  // Returns the path to a file with the given name in the instance directory..
+  std::string PerInstancePath(const char* file_name) const;
+
+  std::string instance_name() const;
+
+  void disable_usb_adb() {
+    // This seems to be the way usb is being disbled in the launcher
+    set_usb_v1_socket_name("");
+  }
+
+  // Reads the kernel command line from a file and appends extra arguments.
+  bool ReadKernelArgs(const std::string& cmdline_file,
+                      const std::string& extra_args);
+
+  std::string instance_dir() const;
+  void set_instance_dir(const std::string& instance_dir);
+
+  std::string serial_number() const;
+  void set_serial_number(const std::string& serial_number);
+
+  int cpus() const;
+  void set_cpus(int cpus);
+
+  int memory_mb() const;
+  void set_memory_mb(int memory_mb);
+
+  int dpi() const;
+  void set_dpi(int dpi);
+
+  int x_res() const;
+  void set_x_res(int x_res);
+
+  int y_res() const;
+  void set_y_res(int y_res);
+
+  int refresh_rate_hz() const;
+  void set_refresh_rate_hz(int refresh_rate_hz);
+
+  std::string kernel_image_path() const;
+  void set_kernel_image_path(const std::string& kernel_image_path);
+
+  std::string kernel_args() const;
+  void set_kernel_args(const std::string& kernel_args);
+
+  std::string ramdisk_image_path() const;
+  void set_ramdisk_image_path(const std::string& ramdisk_image_path);
+
+  std::string system_image_path() const;
+  void set_system_image_path(const std::string& system_image_path);
+
+  std::string cache_image_path() const;
+  void set_cache_image_path(const std::string& cache_image_path);
+
+  std::string data_image_path() const;
+  void set_data_image_path(const std::string& data_image_path);
+
+  std::string vendor_image_path() const;
+  void set_vendor_image_path(const std::string& vendor_image_path);
+
+  std::string dtb_path() const;
+  void set_dtb_path(const std::string& dtb_path);
+
+  std::string mempath() const;
+  void set_mempath(const std::string& mempath);
+
+  std::string ivshmem_qemu_socket_path() const;
+  void set_ivshmem_qemu_socket_path(
+      const std::string& ivshmem_qemu_socket_path);
+
+  std::string ivshmem_client_socket_path() const;
+  void set_ivshmem_client_socket_path(
+      const std::string& ivshmem_client_socket_path);
+
+  int ivshmem_vector_count() const;
+  void set_ivshmem_vector_count(int ivshmem_vector_count);
+
+  // The name of the socket that will be used to forward access to USB gadget.
+  // This is for V1 of the USB bus.
+  std::string usb_v1_socket_name() const;
+  void set_usb_v1_socket_name(const std::string& usb_v1_socket_name);
+
+  int vhci_port() const;
+  void set_vhci_port(int vhci_port);
+
+  std::string usb_ip_socket_name() const;
+  void set_usb_ip_socket_name(const std::string& usb_ip_socket_name);
+
+  std::string kernel_log_socket_name() const;
+  void set_kernel_log_socket_name(const std::string& kernel_log_socket_name);
+
+  std::string console_path() const;
+  void set_console_path(const std::string& console_path);
+
+  std::string logcat_path() const;
+  void set_logcat_path(const std::string& logcat_path);
+
+  std::string mobile_bridge_name() const;
+  void set_mobile_bridge_name(const std::string& mobile_bridge_name);
+
+  std::string mobile_tap_name() const;
+  void set_mobile_tap_name(const std::string& mobile_tap_name);
+
+  std::string wifi_guest_mac_addr() const;
+  void set_wifi_guest_mac_addr(const std::string& wifi_guest_mac_addr);
+
+  std::string wifi_host_mac_addr() const;
+  void set_wifi_host_mac_addr(const std::string& wifi_host_mac_addr);
+
+  std::string entropy_source() const;
+  void set_entropy_source(const std::string& entropy_source);
+
+  std::string uuid() const;
+  void set_uuid(const std::string& uuid);
+
+  bool disable_dac_security() const;
+  void set_disable_dac_security(bool disable_dac_security);
+
+  bool disable_app_armor_security() const;
+  void set_disable_app_armor_security(bool disable_app_armor_security);
+
+ private:
+  std::unique_ptr<Json::Value> dictionary_;
+
+  void LoadFromFile(const char* file);
+
+  CuttlefishConfig();
+  CuttlefishConfig(const CuttlefishConfig&) = delete;
+  CuttlefishConfig& operator=(const CuttlefishConfig&) = delete;
+};
+
+// Returns the instance number as obtained from the CUTTLEFISH_INSTANCE
+// environment variable or the username.
+int GetInstance();
+
+// Returns the path to the ivserver's client socket.
+std::string GetDomain();
+
+// These functions modify a given base value to make it different accross
+// different instances by appending the instance id in case of strings or adding
+// it in case of integers.
+std::string GetPerInstanceDefault(const char* prefix);
+int GetPerInstanceDefault(int base);
+
+std::string GetDefaultPerInstanceDir();
+
+}  // namespace vsoc
diff --git a/host/libs/config/file_partition.cpp b/host/libs/config/file_partition.cpp
deleted file mode 100644
index ede4870..0000000
--- a/host/libs/config/file_partition.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <errno.h>
-#include <limits.h>
-
-#include <sstream>
-
-#include <glog/logging.h>
-
-#include "common/libs/fs/shared_fd.h"
-#include "host/libs/config/file_partition.h"
-
-namespace config {
-namespace {
-constexpr char kTempFileSuffix[] = ".img";
-
-void Initialize(const std::string& path) {
-  std::string command = "/sbin/mkfs.ext4 -F '" + path + "' &>/dev/null";
-  CHECK(system(command.c_str()) == 0)
-      << "Could not initialize filesystem on partition image " << path << ": "
-      << strerror(errno);
-}
-}  // namespace
-
-FilePartition::~FilePartition() {
-  if (should_delete_) {
-    LOG(INFO) << "Deleting partition image file " << name_;
-    errno = 0;
-    unlink(name_.c_str());
-    if (errno != 0) {
-      LOG(WARNING) << "Could not delete partition image file: "
-                   << strerror(errno);
-    }
-  }
-}
-
-std::unique_ptr<FilePartition> FilePartition::ReuseExistingFile(
-    const std::string& path) {
-  return std::unique_ptr<FilePartition>(new FilePartition(path, false));
-}
-
-std::unique_ptr<FilePartition> FilePartition::CreateNewFile(
-    const std::string& path, int size_mb) {
-  {
-    cvd::SharedFD fd(cvd::SharedFD::Open(path.c_str(), O_CREAT | O_RDWR, 0600));
-    CHECK(fd->IsOpen()) << "Could not open file: " << path << ": "
-                        << fd->StrError();
-    CHECK(fd->Truncate(size_mb << 20) == 0)
-        << "Could not truncate file " << path << ": " << fd->StrError();
-  }
-
-  Initialize(path);
-  return std::unique_ptr<FilePartition>(new FilePartition(path, false));
-}
-
-// Create temporary FilePartition object using supplied prefix.
-// Newly created file will be deleted after this instance is destroyed.
-std::unique_ptr<FilePartition> FilePartition::CreateTemporaryFile(
-    const std::string& prefix, int size_mb) {
-  std::stringstream ss;
-  ss << prefix << "-XXXXXX" << kTempFileSuffix;
-  char path[PATH_MAX];
-  strncpy(&path[0], ss.str().c_str(), sizeof(path));
-
-  {
-    int raw_fd = mkostemps(&path[0], strlen(kTempFileSuffix), O_RDWR | O_CREAT);
-    CHECK(raw_fd > 0) << "Could not create temporary file: " << strerror(errno);
-    CHECK(ftruncate(raw_fd, size_mb << 20) == 0)
-        << "Could not truncate file " << path << ": " << strerror(errno);
-    close(raw_fd);
-  }
-
-  Initialize(path);
-  return std::unique_ptr<FilePartition>(new FilePartition(path, true));
-}
-
-}  // namespace config
diff --git a/host/libs/config/file_partition.h b/host/libs/config/file_partition.h
deleted file mode 100644
index 3c8e55b..0000000
--- a/host/libs/config/file_partition.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-#include <string>
-
-namespace config {
-// FilePartition class manages partition image files.
-// Partition image files can be reused or created on demand. Temporary images
-// are deleted when corresponding instances of FilePartition object are
-// destroyed.
-class FilePartition {
- public:
-  ~FilePartition();
-
-  // Create FilePartition object from existing file.
-  // Specified file will not be disposed of after this instance is destroyed.
-  static std::unique_ptr<FilePartition> ReuseExistingFile(
-      const std::string& path);
-
-  // Create FilePartition object at specified location and initialize content.
-  // Specified file will not be disposed of after this instance is destroyed.
-  static std::unique_ptr<FilePartition> CreateNewFile(const std::string& path,
-                                                      int size_mb);
-
-  // Create temporary FilePartition object using supplied prefix.
-  // Newly created file will be deleted after this instance is destroyed.
-  static std::unique_ptr<FilePartition> CreateTemporaryFile(
-      const std::string& prefix, int size_mb);
-
-  const std::string& GetName() const { return name_; }
-
- private:
-  std::string name_;
-  bool should_delete_ = false;
-
-  FilePartition(const std::string& name, bool should_delete)
-      : name_(name), should_delete_(should_delete) {}
-
-  FilePartition(const FilePartition&) = delete;
-  FilePartition& operator=(const FilePartition&) = delete;
-};
-
-}  // namespace config
diff --git a/host/libs/config/guest_config.h b/host/libs/config/guest_config.h
deleted file mode 100644
index ff7432f..0000000
--- a/host/libs/config/guest_config.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-#include <string>
-
-namespace config {
-// GuestConfig builds XML document describing target VM.
-// Documents built by GuestConfig can be directly used by libvirt to instantiate
-// new virtual machine.
-class GuestConfig {
- public:
-  GuestConfig() = default;
-  ~GuestConfig() = default;
-
-  // Set instance ID.
-  GuestConfig& SetID(int id) {
-    id_ = id;
-    return *this;
-  }
-
-  // Set number of virtual CPUs.
-  GuestConfig& SetVCPUs(int vcpus) {
-    vcpus_ = vcpus;
-    return *this;
-  }
-
-  // Set total memory amount it MB.
-  GuestConfig& SetMemoryMB(int mem_mb) {
-    memory_mb_ = mem_mb;
-    return *this;
-  }
-
-  // Set kernel path.
-  GuestConfig& SetKernelName(const std::string& kernel) {
-    kernel_name_ = kernel;
-    return *this;
-  }
-
-  // Set kernel cmdline arguments.
-  GuestConfig& SetKernelArgs(const std::string& args) {
-    kernel_args_ = args;
-    return *this;
-  }
-
-  // Set initrd path.
-  GuestConfig& SetInitRDName(const std::string& initrd) {
-    initrd_name_ = initrd;
-    return *this;
-  }
-
-  // Set Android system partition image path.
-  GuestConfig& SetSystemPartitionPath(const std::string& path) {
-    system_partition_path_ = path;
-    return *this;
-  }
-
-  // Set Android data partition image path.
-  GuestConfig& SetCachePartitionPath(const std::string& path) {
-    cache_partition_path_ = path;
-    return *this;
-  }
-
-  // Set Android data partition image path.
-  GuestConfig& SetDataPartitionPath(const std::string& path) {
-    data_partition_path_ = path;
-    return *this;
-  }
-
-  // Set Android vendor partition image path.
-  GuestConfig& SetVendorPartitionPath(const std::string& path) {
-    vendor_partition_path_ = path;
-    return *this;
-  }
-
-  // Set ivshmem server socket path.
-  GuestConfig& SetIVShMemSocketPath(const std::string& path) {
-    ivshmem_socket_path_ = path;
-    return *this;
-  }
-
-  // Set number of vectors supplied by ivserver.
-  GuestConfig& SetIVShMemVectorCount(int count) {
-    ivshmem_vector_count_ = count;
-    return *this;
-  }
-
-  // Set name of the mobile bridge, eg. br0
-  GuestConfig& SetMobileBridgeName(const std::string& name) {
-    mobile_bridge_name_ = name;
-    return *this;
-  }
-
-  // Set source of entropy, eg. /dev/urandom.
-  GuestConfig& SetEntropySource(const std::string& source) {
-    entropy_source_ = source;
-    return *this;
-  }
-
-  // Flags to disable the AppArmor security features of libvirt
-  GuestConfig& SetDisableAppArmorSecurity(bool value) {
-    disable_app_armor_security_ = value;
-    return *this;
-  }
-
-  // Flags to disable the DAC security features of libvirt
-  GuestConfig& SetDisableDACSecurity(bool value) {
-    disable_dac_security_ = value;
-    return *this;
-  }
-
-  // The UUID that libvirt uses to identify the instance
-  GuestConfig& SetUUID(const std::string& uuid) {
-    uuid_ = uuid;
-    return *this;
-  }
-
-  // GetInstanceName returns name of this newly created instance.
-  std::string GetInstanceName() const;
-
-  // GetUSBSocketName returns name of the USB socket that will be used to
-  // forward access to USB gadget. This is for V1 of the USB bus.
-  std::string GetUSBV1SocketName() const { return usb_v1_socket_name_; }
-
-  GuestConfig& SetUSBV1SocketName(const std::string& source) {
-    usb_v1_socket_name_ = source;
-    return *this;
-  }
-
-  std::string GetKernelLogSocketName() const { return kernel_log_socket_name_; }
-
-  GuestConfig& SetKernelLogSocketName(const std::string& source) {
-    kernel_log_socket_name_ = source;
-    return *this;
-  }
-
-  // Build document as formatted XML string.
-  std::string Build() const;
-
- private:
-  int id_;
-  int vcpus_;
-  int memory_mb_;
-
-  std::string kernel_name_;
-  std::string kernel_args_;
-  std::string initrd_name_;
-
-  std::string system_partition_path_;
-  std::string cache_partition_path_;
-  std::string data_partition_path_;
-  std::string vendor_partition_path_;
-  std::string usb_v1_socket_name_;
-  std::string kernel_log_socket_name_;
-
-  std::string ivshmem_socket_path_;
-  int ivshmem_vector_count_;
-
-  std::string mobile_bridge_name_;
-  std::string entropy_source_;
-
-  std::string uuid_;
-  bool disable_dac_security_;
-  bool disable_app_armor_security_;
-
-  GuestConfig(const GuestConfig&) = delete;
-  GuestConfig& operator=(const GuestConfig&) = delete;
-};
-
-}  // namespace config
diff --git a/host/libs/config/host_config.cpp b/host/libs/config/host_config.cpp
deleted file mode 100644
index df39bb6..0000000
--- a/host/libs/config/host_config.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "host/libs/config/host_config.h"
-
-#include <cstdlib>
-#include <cstring>
-#include <string>
-#include <iomanip>
-#include <sstream>
-
-#include <gflags/gflags.h>
-
-constexpr char kDefaultUuidPrefix[] = "699acfc4-c8c4-11e7-882b-5065f31dc1";
-
-DEFINE_string(domain, vsoc::GetDefaultShmClientSocketPath(),
-              "Path to the ivshmem client socket");
-DEFINE_int32(instance, vsoc::GetDefaultInstance(),
-             "Instance number. Must be unique.");
-DEFINE_string(uuid, vsoc::GetPerInstanceDefault(kDefaultUuidPrefix).c_str(),
-              "UUID to use for the device. Random if not specified");
-
-int vsoc::GetDefaultInstance() {
-  static constexpr char kVsocUserPrefix[] = "vsoc-";
-  const char* user = std::getenv("USER");
-  if (user && !std::strncmp(user, kVsocUserPrefix,
-                            sizeof(kVsocUserPrefix) - 1)) {
-    int temp = std::atoi(user + sizeof(kVsocUserPrefix) - 1);
-    if (temp > 0) {
-      return temp;
-    }
-  }
-  return 1;
-}
-
-std::string vsoc::GetPerInstanceDefault(const char* prefix) {
-  std::ostringstream stream;
-  stream << prefix << std::setfill('0') << std::setw(2)
-         << GetDefaultInstance();
-  return stream.str();
-}
-
-int vsoc::GetPerInstanceDefault(int base) {
-  return base + GetDefaultInstance() - 1;
-}
-
-std::string vsoc::GetDefaultPerInstanceDir() {
-  std::ostringstream stream;
-  stream << "/var/run/libvirt-" << kDefaultUuidPrefix;
-  return vsoc::GetPerInstanceDefault(stream.str().c_str());
-}
-
-std::string vsoc::GetDefaultPerInstancePath(const std::string& basename) {
-  std::ostringstream stream;
-  stream << GetDefaultPerInstanceDir() << "/" << basename;
-  return stream.str();
-}
-
-std::string vsoc::GetDefaultShmClientSocketPath() {
-  return vsoc::GetDefaultPerInstancePath("ivshmem_socket_client");
-}
-
-std::string vsoc::GetDomain() {
-  return FLAGS_domain;
-}
diff --git a/host/libs/vm_manager/Android.bp b/host/libs/vm_manager/Android.bp
new file mode 100644
index 0000000..1c23f0a
--- /dev/null
+++ b/host/libs/vm_manager/Android.bp
@@ -0,0 +1,37 @@
+//
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+cc_library_host_static {
+    name: "libcuttlefish_vm_manager",
+    srcs: [
+        "libvirt_manager.cpp",
+    ],
+    header_libs: [
+        "cuttlefish_glog",
+    ],
+    shared_libs: [
+        "libcuttlefish_fs",
+        "cuttlefish_auto_resources",
+        "libbase",
+        "libicuuc",
+    ],
+    static_libs: [
+        "libxml2",
+        "libgflags",
+        "libcuttlefish_host_config",
+        "libjsoncpp",
+    ],
+    defaults: ["cuttlefish_host_only"],
+}
\ No newline at end of file
diff --git a/host/libs/config/guest_config.cpp b/host/libs/vm_manager/libvirt_manager.cpp
similarity index 75%
rename from host/libs/config/guest_config.cpp
rename to host/libs/vm_manager/libvirt_manager.cpp
index a812966..6c6f4a1 100644
--- a/host/libs/config/guest_config.cpp
+++ b/host/libs/vm_manager/libvirt_manager.cpp
@@ -14,41 +14,26 @@
  * limitations under the License.
  */
 
-#include "host/libs/config/guest_config.h"
+#include "host/libs/vm_manager/libvirt_manager.h"
+
+#include <stdio.h>
+#include <cstdlib>
 #include <iomanip>
 #include <sstream>
 
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 #include <libxml/tree.h>
-#include "host/libs/config/host_config.h"
 
-namespace {
-std::string StringFromEnv(const char* varname, std::string defval) {
-  const char* const valstr = getenv(varname);
-  if (!valstr) {
-    return defval;
-  }
-  return valstr;
-}
-}  // namespace
+DEFINE_string(hypervisor_uri, "qemu:///system", "Hypervisor cannonical uri.");
+DEFINE_bool(log_xml, false, "Log the XML machine configuration");
 
-
-std::string g_default_libvirt_domain{vsoc::GetPerInstanceDefault("cvd-")};
-//TODO(b/72969289) This should be generated
-DEFINE_string(dtb,
-              StringFromEnv("ANDROID_HOST_OUT", StringFromEnv("HOME", ".")) +
-                  "/config/cuttlefish.dtb",
-              "Location of the cuttlefish.dtb file.");
-DEFINE_string(libvirt_domain, g_default_libvirt_domain.c_str(),
-              "Domain name to use with libvirt");
-
-// This class represents libvirt guest configuration.
 // A lot of useful information about the document created here can be found on
 // these websites:
 // - https://libvirt.org/formatdomain.html
 // - https://wiki.libvirt.org/page/Virtio
-namespace config {
+namespace vm_manager {
+
 namespace {
 // This trivial no-op helper function serves purpose of making libxml2 happy.
 // Apparently, *most* (not all!) string literals in libxml2 have to be of
@@ -120,7 +105,7 @@
 // This section configures target os (<os>).
 void ConfigureOperatingSystem(xmlNode* root, const std::string& kernel,
                               const std::string& initrd,
-                              const std::string& args) {
+                              const std::string& args, const std::string& dtb) {
   auto os = xmlNewChild(root, nullptr, xc("os"), nullptr);
 
   auto type = xmlNewChild(os, nullptr, xc("type"), xc("hvm"));
@@ -130,7 +115,7 @@
   xmlNewChild(os, nullptr, xc("kernel"), xc(kernel.c_str()));
   xmlNewChild(os, nullptr, xc("initrd"), xc(initrd.c_str()));
   xmlNewChild(os, nullptr, xc("cmdline"), xc(args.c_str()));
-  xmlNewChild(os, nullptr, xc("dtb"), xc(FLAGS_dtb.c_str()));
+  xmlNewChild(os, nullptr, xc("dtb"), xc(dtb.c_str()));
 }
 
 // Configure QEmu specific arguments.
@@ -210,7 +195,9 @@
 // This section adds <channel> elements to <devices> node.
 void ConfigureVirtioChannel(xmlNode* devices, int port, const std::string& name,
                             DeviceSourceType type, const std::string& path) {
-  if (path.empty()) { return; }
+  if (path.empty()) {
+    return;
+  }
   auto vch = xmlNewChild(devices, nullptr, xc("channel"), nullptr);
   ConfigureDeviceSource(vch, type, path);
 
@@ -262,14 +249,19 @@
   xmlNewProp(bend, xc("model"), xc("random"));
 }
 
-}  // namespace
-
-std::string GuestConfig::GetInstanceName() const {
-  return FLAGS_libvirt_domain;
+std::string GetLibvirtCommand() {
+  std::string cmd = "virsh";
+  if (!FLAGS_hypervisor_uri.empty()) {
+    cmd += " -c " + FLAGS_hypervisor_uri;
+  }
+  return cmd;
 }
 
-std::string GuestConfig::Build() const {
-  std::string instance_name = GetInstanceName();
+}  // namespace
+
+std::string LibvirtManager::BuildXmlConfig() const {
+  auto config = vsoc::CuttlefishConfig::Get();
+  std::string instance_name = config->instance_name();
 
   std::unique_ptr<xmlDoc, void (*)(xmlDocPtr)> xml{xmlNewDoc(xc("1.0")),
                                                    xmlFreeDoc};
@@ -277,23 +269,27 @@
   xmlDocSetRootElement(xml.get(), root);
   xmlNewProp(root, xc("type"), xc("kvm"));
 
-  ConfigureVM(root, instance_name, vcpus_, memory_mb_, uuid_);
+  ConfigureVM(root, instance_name, config->cpus(), config->memory_mb(),
+              config->uuid());
   ConfigureVMFeatures(root, {"acpi", "apic", "hap"});
-  ConfigureOperatingSystem(root, kernel_name_, initrd_name_, kernel_args_);
+  ConfigureOperatingSystem(root, config->kernel_image_path(),
+                           config->ramdisk_image_path(), config->kernel_args(),
+                           config->dtb_path());
   ConfigureQEmuSpecificOptions(
-      root,
-      {"-chardev", concat("socket,path=", ivshmem_socket_path_, ",id=ivsocket"),
-       "-device",
-       concat("ivshmem-doorbell,chardev=ivsocket,vectors=",
-              ivshmem_vector_count_),
-       "-cpu", "host"});
+      root, {"-chardev",
+             concat("socket,path=", config->ivshmem_qemu_socket_path(),
+                    ",id=ivsocket"),
+             "-device",
+             concat("ivshmem-doorbell,chardev=ivsocket,vectors=",
+                    config->ivshmem_vector_count()),
+             "-cpu", "host"});
 
-  if (disable_app_armor_security_) {
+  if (config->disable_app_armor_security()) {
     auto seclabel = xmlNewChild(root, nullptr, xc("seclabel"), nullptr);
     xmlNewProp(seclabel, xc("type"), xc("none"));
     xmlNewProp(seclabel, xc("model"), xc("apparmor"));
   }
-  if (disable_dac_security_) {
+  if (config->disable_dac_security()) {
     auto seclabel = xmlNewChild(root, nullptr, xc("seclabel"), nullptr);
     xmlNewProp(seclabel, xc("type"), xc("none"));
     xmlNewProp(seclabel, xc("model"), xc("dac"));
@@ -302,30 +298,65 @@
   auto devices = xmlNewChild(root, nullptr, xc("devices"), nullptr);
 
   ConfigureSerialPort(devices, 0, DeviceSourceType::kUnixSocketClient,
-                      GetKernelLogSocketName());
+                      config->kernel_log_socket_name());
   ConfigureSerialPort(devices, 1, DeviceSourceType::kUnixSocketServer,
-                      vsoc::GetDefaultPerInstancePath("console"));
+                      config->console_path());
   ConfigureVirtioChannel(devices, 1, "cf-logcat", DeviceSourceType::kFile,
-                         vsoc::GetDefaultPerInstancePath("logcat"));
+                         config->logcat_path());
   ConfigureVirtioChannel(devices, 2, "cf-gadget-usb-v1",
                          DeviceSourceType::kUnixSocketClient,
-                         GetUSBV1SocketName());
+                         config->usb_v1_socket_name());
 
-  ConfigureDisk(devices, "vda", system_partition_path_);
-  ConfigureDisk(devices, "vdb", data_partition_path_);
-  ConfigureDisk(devices, "vdc", cache_partition_path_);
-  ConfigureDisk(devices, "vdd", vendor_partition_path_);
+  ConfigureDisk(devices, "vda", config->system_image_path());
+  ConfigureDisk(devices, "vdb", config->data_image_path());
+  ConfigureDisk(devices, "vdc", config->cache_image_path());
+  ConfigureDisk(devices, "vdd", config->vendor_image_path());
 
-  ConfigureNIC(devices, concat("amobile", id_), mobile_bridge_name_, id_, 1);
-  ConfigureHWRNG(devices, entropy_source_);
+  ConfigureNIC(devices, config->mobile_tap_name(), config->mobile_bridge_name(),
+               vsoc::GetInstance(), 1);
+  ConfigureHWRNG(devices, config->entropy_source());
 
   xmlChar* tgt;
   int tgt_len;
 
   xmlDocDumpFormatMemoryEnc(xml.get(), &tgt, &tgt_len, "utf-8", true);
-  std::string out(reinterpret_cast<const char*>(tgt), tgt_len);
+  std::string out((const char*)(tgt), tgt_len);
   xmlFree(tgt);
   return out;
 }
 
-}  // namespace config
+bool LibvirtManager::Start() const {
+  std::string start_command = GetLibvirtCommand();
+  start_command += " create /dev/fd/0";
+
+  std::string xml = BuildXmlConfig();
+  if (FLAGS_log_xml) {
+    LOG(INFO) << "Using XML:\n" << xml;
+  }
+
+  FILE* launch = popen(start_command.c_str(), "w");
+  if (!launch) {
+    LOG(FATAL) << "Unable to execute " << start_command;
+    return false;
+  }
+  int rval = fputs(xml.c_str(), launch);
+  if (rval == EOF) {
+    LOG(FATAL) << "Launch command exited while accepting XML";
+    return false;
+  }
+  int exit_code = pclose(launch);
+  if (exit_code != 0) {
+    LOG(FATAL) << "Launch command exited with status " << exit_code;
+    return false;
+  }
+  return true;
+}
+
+bool LibvirtManager::Stop() const {
+  auto config = vsoc::CuttlefishConfig::Get();
+  auto stop_command = GetLibvirtCommand();
+  stop_command += " destroy " + config->instance_name();
+  return std::system(stop_command.c_str()) == 0;
+}
+
+}  // namespace vm_manager
diff --git a/host/libs/config/host_config.h b/host/libs/vm_manager/libvirt_manager.h
similarity index 62%
rename from host/libs/config/host_config.h
rename to host/libs/vm_manager/libvirt_manager.h
index 15d2059..dbe7dcf 100644
--- a/host/libs/config/host_config.h
+++ b/host/libs/vm_manager/libvirt_manager.h
@@ -1,5 +1,3 @@
-#pragma once
-
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -15,17 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-/* Host-specific values associated with RegionControl. */
+#pragma once
 
 #include <string>
 
-namespace vsoc {
-int GetDefaultInstance();
-std::string GetPerInstanceDefault(const char* prefix);
-int GetPerInstanceDefault(int base);
-std::string GetDefaultPerInstanceDir();
-std::string GetDefaultPerInstancePath(const std::string& basename);
-std::string GetDefaultShmClientSocketPath();
-std::string GetDomain();
-}  // namespace vsoc
+#include "host/libs/config/cuttlefish_config.h"
+
+namespace vm_manager {
+
+class LibvirtManager {
+ public:
+  LibvirtManager() = default;
+  ~LibvirtManager() = default;
+
+  bool Start() const;
+  bool Stop() const;
+
+ protected:
+  std::string BuildXmlConfig() const;
+};
+
+}  // namespace vm_manager
diff --git a/host/vsoc/lib/host_region_e2e_test.cpp b/host/vsoc/lib/host_region_e2e_test.cpp
index cab1bc7..1366838 100644
--- a/host/vsoc/lib/host_region_e2e_test.cpp
+++ b/host/vsoc/lib/host_region_e2e_test.cpp
@@ -20,7 +20,7 @@
 
 #include <gtest/gtest.h>
 #include "common/vsoc/lib/e2e_test_region_view.h"
-#include "host/libs/config/host_config.h"
+#include "host/libs/config/cuttlefish_config.h"
 
 // Here is a summary of the two regions interrupt and write test:
 // 1. Write our strings to the first region