diff --git a/buffet/buffet_client.cc b/buffet/buffet_client.cc
index 3edbbc3..ca91cee 100644
--- a/buffet/buffet_client.cc
+++ b/buffet/buffet_client.cc
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <iostream>  // NOLINT(readability/streams)
 #include <memory>
 #include <string>
 #include <sysexits.h>
@@ -10,8 +9,10 @@
 #include <base/command_line.h>
 #include <base/logging.h>
 #include <base/memory/ref_counted.h>
+#include <base/strings/stringprintf.h>
 #include <base/values.h>
 #include <chromeos/any.h>
+#include <chromeos/daemons/dbus_daemon.h>
 #include <chromeos/data_encoding.h>
 #include <chromeos/dbus/data_serialization.h>
 #include <chromeos/dbus/dbus_method_invoker.h>
@@ -24,137 +25,183 @@
 #include <dbus/values_util.h>
 
 #include "buffet/dbus-proxies.h"
-#include "buffet/libbuffet/dbus_constants.h"
 
-using namespace buffet::dbus_constants;  // NOLINT(build/namespaces)
-
-using chromeos::dbus_utils::CallMethodAndBlock;
-using chromeos::dbus_utils::CallMethodAndBlockWithTimeout;
-using chromeos::dbus_utils::ExtractMethodCallResults;
-using chromeos::VariantDictionary;
+using chromeos::Error;
 using chromeos::ErrorPtr;
 
 namespace {
 
 void usage() {
-  std::cerr << "Possible commands:" << std::endl;
-  std::cerr << "  " << kManagerTestMethod << " <message>" << std::endl;
-  std::cerr << "  " << kManagerStartDevice << std::endl;
-  std::cerr << "  " << kManagerCheckDeviceRegistered << std::endl;
-  std::cerr << "  " << kManagerGetDeviceInfo << std::endl;
-  std::cerr << "  " << kManagerRegisterDevice
-                    << " param1 = val1&param2 = val2..." << std::endl;
-  std::cerr << "  " << kManagerAddCommand
-                    << " '{\"name\":\"command_name\",\"parameters\":{}}'"
-                    << std::endl;
-  std::cerr << "  " << kManagerUpdateStateMethod
-                    << " prop_name prop_value" << std::endl;
-  std::cerr << "  " << dbus::kObjectManagerGetManagedObjects << std::endl;
+  printf(R"(Possible commands:
+  - TestMethod <message>
+  - StartDevice
+  - CheckDeviceRegistered
+  - GetDeviceInfo
+  - RegisterDevice param1=val1&param2=val2...
+  - AddCommand '{"name":"command_name","parameters":{}}'
+  - UpdateStateMethod prop_name prop_value
+  - PendingCommands
+)");
 }
 
-class BuffetHelperProxy {
+class Daemon : public chromeos::DBusDaemon {
  public:
-  int Init() {
-    dbus::Bus::Options options;
-    options.bus_type = dbus::Bus::SYSTEM;
-    bus_ = new dbus::Bus(options);
+  Daemon() = default;
+
+ protected:
+  int OnInit() override {
+    int return_code = chromeos::DBusDaemon::OnInit();
+    if (return_code != EX_OK)
+      return return_code;
+
+    object_manager_.reset(new org::chromium::Buffet::ObjectManagerProxy{bus_});
     manager_proxy_.reset(new org::chromium::Buffet::ManagerProxy{bus_});
-    root_proxy_ = bus_->GetObjectProxy(
-        kServiceName,
-        dbus::ObjectPath(kRootServicePath));
-  return EX_OK;
+
+    auto args = CommandLine::ForCurrentProcess()->GetArgs();
+
+    // Pop the command off of the args list.
+    std::string command = args.front();
+    args.erase(args.begin());
+
+    if (command.compare("TestMethod") == 0) {
+      if (args.empty() || CheckArgs(command, args, 1)) {
+        std::string message;
+        if (!args.empty())
+          message = args.back();
+        PostTask(&Daemon::CallTestMethod, message);
+      }
+    } else if (command.compare("StartDevice") == 0 ||
+               command.compare("sd") == 0) {
+      if (CheckArgs(command, args, 0))
+        PostTask(&Daemon::CallStartDevice);
+    } else if (command.compare("CheckDeviceRegistered") == 0 ||
+               command.compare("cr") == 0) {
+      if (CheckArgs(command, args, 0))
+        PostTask(&Daemon::CallCheckDeviceRegistered);
+    } else if (command.compare("GetDeviceInfo") == 0 ||
+               command.compare("di") == 0) {
+      if (CheckArgs(command, args, 0))
+        PostTask(&Daemon::CallGetDeviceInfo);
+    } else if (command.compare("RegisterDevice") == 0 ||
+               command.compare("rd") == 0) {
+      if (args.empty() || CheckArgs(command, args, 1)) {
+        std::string dict;
+        if (!args.empty())
+          dict = args.back();
+        PostTask(&Daemon::CallRegisterDevice, dict);
+      }
+    } else if (command.compare("UpdateState") == 0 ||
+               command.compare("us") == 0) {
+      if (CheckArgs(command, args, 2))
+        PostTask(&Daemon::CallUpdateState, args.front(), args.back());
+    } else if (command.compare("AddCommand") == 0 ||
+               command.compare("ac") == 0) {
+      if (CheckArgs(command, args, 1))
+        PostTask(&Daemon::CallAddCommand, args.back());
+    } else if (command.compare("PendingCommands") == 0 ||
+               command.compare("pc") == 0) {
+      if (CheckArgs(command, args, 0))
+        // CallGetPendingCommands relies on ObjectManager but it is being
+        // initialized asynchronously without a way to get a callback when
+        // it is ready to be used. So, just wait a bit before calling its
+        // methods.
+        PostDelayedTask(&Daemon::CallGetPendingCommands,
+                        base::TimeDelta::FromMilliseconds(100));
+    } else {
+      fprintf(stderr, "Unknown command: '%s'\n", command.c_str());
+      usage();
+      Quit();
+      return EX_USAGE;
+    }
+    return EX_OK;
   }
 
-  int CallTestMethod(const CommandLine::StringVector& args) {
-    std::string message;
-    if (!args.empty())
-      message = args.front();
+  void OnShutdown(int* return_code) override {
+    if (*return_code == EX_OK)
+      *return_code = exit_code_;
+  }
 
+ private:
+  void ReportError(Error* error) {
+    fprintf(stderr, "Failed to receive a response: %s\n",
+            error->GetMessage().c_str());
+    exit_code_ = EX_UNAVAILABLE;
+    Quit();
+  }
+
+  bool CheckArgs(const std::string& command,
+                 const std::vector<std::string>& args,
+                 size_t expected_arg_count) {
+    if (args.size() == expected_arg_count)
+      return true;
+    fprintf(stderr, "Invalid number of arguments for command '%s'\n",
+            command.c_str());
+    usage();
+    exit_code_ = EX_USAGE;
+    Quit();
+    return false;
+  }
+
+  template<typename... Args>
+  void PostTask(void (Daemon::*fn)(const Args&...), const Args&... args) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(fn, base::Unretained(this), args...));
+  }
+
+  template<typename... Args>
+  void PostDelayedTask(void (Daemon::*fn)(const Args&...),
+                       const base::TimeDelta& delay,
+                       const Args&... args) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(fn, base::Unretained(this), args...), delay);
+  }
+
+  void CallTestMethod(const std::string& message) {
     ErrorPtr error;
     std::string response_message;
     if (!manager_proxy_->TestMethod(message, &response_message, &error)) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
+      return ReportError(error.get());
     }
-
-    std::cout << "Received a response: " << response_message << std::endl;
-    return EX_OK;
+    printf("Received a response: %s\n", response_message.c_str());
+    Quit();
   }
 
-  int CallManagerStartDevice(const CommandLine::StringVector& args) {
-    if (!args.empty()) {
-      std::cerr << "Invalid number of arguments for "
-                << "Manager." << kManagerStartDevice << std::endl;
-      usage();
-      return EX_USAGE;
-    }
-
+  void CallStartDevice() {
     ErrorPtr error;
     if (!manager_proxy_->StartDevice(&error)) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
+      return ReportError(error.get());
     }
-
-    return EX_OK;
+    Quit();
   }
 
-  int CallManagerCheckDeviceRegistered(const CommandLine::StringVector& args) {
-    if (!args.empty()) {
-      std::cerr << "Invalid number of arguments for "
-                << "Manager." << kManagerCheckDeviceRegistered << std::endl;
-      usage();
-      return EX_USAGE;
-    }
-
+  void CallCheckDeviceRegistered() {
     ErrorPtr error;
     std::string device_id;
     if (!manager_proxy_->CheckDeviceRegistered(&device_id, &error)) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
+      return ReportError(error.get());
     }
 
-    std::cout << "Device ID: "
-              << (device_id.empty() ? std::string("<unregistered>") : device_id)
-              << std::endl;
-    return EX_OK;
+    printf("Device ID: %s\n",
+           device_id.empty() ? "<unregistered>" : device_id.c_str());
+    Quit();
   }
 
-  int CallManagerGetDeviceInfo(const CommandLine::StringVector& args) {
-    if (!args.empty()) {
-      std::cerr << "Invalid number of arguments for "
-                << "Manager." << kManagerGetDeviceInfo << std::endl;
-      usage();
-      return EX_USAGE;
-    }
-
+  void CallGetDeviceInfo() {
     ErrorPtr error;
     std::string device_info;
     if (!manager_proxy_->GetDeviceInfo(&device_info, &error)) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
+      return ReportError(error.get());
     }
 
-    std::cout << "Device Info: "
-      << (device_info.empty() ? std::string("<unregistered>") : device_info)
-      << std::endl;
-    return EX_OK;
+    printf("Device Info: %s\n",
+           device_info.empty() ? "<unregistered>" : device_info.c_str());
+    Quit();
   }
 
-  int CallManagerRegisterDevice(const CommandLine::StringVector& args) {
-    if (args.size() > 1) {
-      std::cerr << "Invalid number of arguments for "
-                << "Manager." << kManagerRegisterDevice << std::endl;
-      usage();
-      return EX_USAGE;
-    }
-
-    VariantDictionary params;
+  void CallRegisterDevice(const std::string& args) {
+    chromeos::VariantDictionary params;
     if (!args.empty()) {
-      auto key_values = chromeos::data_encoding::WebParamsDecode(args.front());
+      auto key_values = chromeos::data_encoding::WebParamsDecode(args);
       for (const auto& pair : key_values) {
         params.insert(std::make_pair(pair.first, chromeos::Any(pair.second)));
       }
@@ -163,79 +210,50 @@
     ErrorPtr error;
     std::string device_id;
     if (!manager_proxy_->RegisterDevice(params, &device_id, &error)) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
+      return ReportError(error.get());
     }
 
-    std::cout << "Device registered: " << device_id << std::endl;
-    return EX_OK;
+    printf("Device registered: %s\n", device_id.c_str());
+    Quit();
   }
 
-  int CallManagerUpdateState(const CommandLine::StringVector& args) {
-    if (args.size() != 2) {
-      std::cerr << "Invalid number of arguments for "
-                << "Manager." << kManagerUpdateStateMethod << std::endl;
-      usage();
-      return EX_USAGE;
-    }
-
+  void CallUpdateState(const std::string& prop, const std::string& value) {
     ErrorPtr error;
-    VariantDictionary property_set{{args.front(), args.back()}};
+    chromeos::VariantDictionary property_set{{prop, value}};
     if (!manager_proxy_->UpdateState(property_set, &error)) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
+      return ReportError(error.get());
     }
-    return EX_OK;
+    Quit();
   }
 
-  int CallManagerAddCommand(const CommandLine::StringVector& args) {
-    if (args.size() != 1) {
-      std::cerr << "Invalid number of arguments for "
-                << "Manager." << kManagerAddCommand << std::endl;
-      usage();
-      return EX_USAGE;
-    }
-
+  void CallAddCommand(const std::string& command) {
     ErrorPtr error;
-    if (!manager_proxy_->AddCommand(args.front(), &error)) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
+    if (!manager_proxy_->AddCommand(command, &error)) {
+      return ReportError(error.get());
     }
-    return EX_OK;
+    Quit();
   }
 
-  int CallRootGetManagedObjects(const CommandLine::StringVector& args) {
-    if (!args.empty()) {
-      std::cerr << "Invalid number of arguments for "
-                << dbus::kObjectManagerGetManagedObjects << std::endl;
-      usage();
-      return EX_USAGE;
+  void CallGetPendingCommands() {
+    printf("Pending commands:\n");
+    for (auto* cmd : object_manager_->GetCommandInstances()) {
+      printf("%10s (%-3d) - '%s' (id:%s)\n",
+             cmd->status().c_str(),
+             cmd->progress(),
+             cmd->name().c_str(),
+             cmd->id().c_str());
     }
-
-    ErrorPtr error;
-    auto response = CallMethodAndBlock(
-        root_proxy_,
-        dbus::kObjectManagerInterface, dbus::kObjectManagerGetManagedObjects,
-        &error);
-    if (!response) {
-      std::cout << "Failed to receive a response:"
-                << error->GetMessage() << std::endl;
-      return EX_UNAVAILABLE;
-    }
-    std::cout << response->ToString() << std::endl;
-    return EX_OK;
+    Quit();
   }
 
- private:
-  scoped_refptr<dbus::Bus> bus_;
+  std::unique_ptr<org::chromium::Buffet::ObjectManagerProxy> object_manager_;
   std::unique_ptr<org::chromium::Buffet::ManagerProxy> manager_proxy_;
-  dbus::ObjectProxy* root_proxy_{nullptr};
+  int exit_code_ = EX_OK;
+
+  DISALLOW_COPY_AND_ASSIGN(Daemon);
 };
 
-}  // namespace
+}  // anonymous namespace
 
 int main(int argc, char** argv) {
   CommandLine::Init(argc, argv);
@@ -246,48 +264,6 @@
     return EX_USAGE;
   }
 
-  // Pop the command off of the args list.
-  std::string command = args.front();
-  args.erase(args.begin());
-  int err = EX_USAGE;
-  BuffetHelperProxy helper;
-  err = helper.Init();
-  if (err) {
-    std::cerr << "Error initializing proxies." << std::endl;
-    return err;
-  }
-
-  if (command.compare(kManagerTestMethod) == 0) {
-    err = helper.CallTestMethod(args);
-  } else if (command.compare(kManagerStartDevice) == 0 ||
-             command.compare("sd") == 0) {
-    err = helper.CallManagerStartDevice(args);
-  } else if (command.compare(kManagerCheckDeviceRegistered) == 0 ||
-             command.compare("cr") == 0) {
-    err = helper.CallManagerCheckDeviceRegistered(args);
-  } else if (command.compare(kManagerGetDeviceInfo) == 0 ||
-             command.compare("di") == 0) {
-    err = helper.CallManagerGetDeviceInfo(args);
-  } else if (command.compare(kManagerRegisterDevice) == 0 ||
-             command.compare("rd") == 0) {
-    err = helper.CallManagerRegisterDevice(args);
-  } else if (command.compare(kManagerUpdateStateMethod) == 0 ||
-             command.compare("us") == 0) {
-    err = helper.CallManagerUpdateState(args);
-  } else if (command.compare(kManagerAddCommand) == 0 ||
-             command.compare("ac") == 0) {
-    err = helper.CallManagerAddCommand(args);
-  } else if (command.compare(dbus::kObjectManagerGetManagedObjects) == 0) {
-    err = helper.CallRootGetManagedObjects(args);
-  } else {
-    std::cerr << "Unknown command: " << command << std::endl;
-    usage();
-  }
-
-  if (err) {
-    std::cerr << "Done, with errors." << std::endl;
-  } else {
-    std::cout << "Done." << std::endl;
-  }
-  return err;
+  Daemon daemon;
+  return daemon.Run();
 }