diff --git a/buffet/buffet_client.cc b/buffet/buffet_client.cc
index ca76a89..79e7cdf 100644
--- a/buffet/buffet_client.cc
+++ b/buffet/buffet_client.cc
@@ -38,7 +38,6 @@
 void usage() {
   printf(R"(Possible commands:
   - TestMethod <message>
-  - StartDevice
   - CheckDeviceRegistered
   - GetDeviceInfo
   - RegisterDevice param1=val1&param2=val2...
@@ -177,11 +176,6 @@
         message = args.back();
       job = base::Bind(&Daemon::CallTestMethod, weak_factory_.GetWeakPtr(),
                        message);
-    } else if (command.compare("StartDevice") == 0 ||
-               command.compare("sd") == 0) {
-      if (!CheckArgs(command, args, 0))
-        return EX_USAGE;
-      job = base::Bind(&Daemon::CallStartDevice, weak_factory_.GetWeakPtr());
     } else if (command.compare("CheckDeviceRegistered") == 0 ||
                command.compare("cr") == 0) {
       if (!CheckArgs(command, args, 0))
@@ -286,14 +280,6 @@
     OnJobComplete();
   }
 
-  void CallStartDevice(ManagerProxy* manager_proxy) {
-    ErrorPtr error;
-    if (!manager_proxy->StartDevice(&error)) {
-      return ReportError(error.get());
-    }
-    OnJobComplete();
-  }
-
   void CallCheckDeviceRegistered(ManagerProxy* manager_proxy) {
     ErrorPtr error;
     std::string device_id;
diff --git a/buffet/dbus_bindings/org.chromium.Buffet.Manager.xml b/buffet/dbus_bindings/org.chromium.Buffet.Manager.xml
index ea5e574..ff73108 100644
--- a/buffet/dbus_bindings/org.chromium.Buffet.Manager.xml
+++ b/buffet/dbus_bindings/org.chromium.Buffet.Manager.xml
@@ -8,9 +8,6 @@
       interfaces which affect the entire device such as device registration and
       device state.
     </tp:docstring>
-    <method name="StartDevice">
-      <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
-    </method>
     <method name="CheckDeviceRegistered">
       <arg name="device_id" type="s" direction="out"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
diff --git a/buffet/device_registration_info.cc b/buffet/device_registration_info.cc
index 72d6d67..9036ed8 100644
--- a/buffet/device_registration_info.cc
+++ b/buffet/device_registration_info.cc
@@ -58,6 +58,9 @@
 
 namespace {
 
+const int kMaxStartDeviceRetryDelayMinutes{1};
+const int64_t kMinStartDeviceRetryDelaySeconds{5};
+
 std::pair<std::string, std::string> BuildAuthHeader(
     const std::string& access_token_type,
     const std::string& access_token) {
@@ -110,9 +113,19 @@
 void IgnoreCloudError(const chromeos::Error*) {
 }
 
+void IgnoreCloudErrorWithCallback(const base::Closure& cb,
+                                  const chromeos::Error*) {
+  cb.Run();
+}
+
 void IgnoreCloudResult(const base::DictionaryValue&) {
 }
 
+void IgnoreCloudResultWithCallback(const base::Closure& cb,
+                                   const base::DictionaryValue&) {
+  cb.Run();
+}
+
 }  // anonymous namespace
 
 namespace buffet {
@@ -229,8 +242,16 @@
   description_          = description;
   location_             = location;
 
-  if (HaveRegistrationCredentials(nullptr))
+  if (HaveRegistrationCredentials(nullptr)) {
     SetRegistrationStatus(RegistrationStatus::kOffline);
+    // Wait a significant amount of time for local daemons to publish their
+    // state to Buffet before publishing it to the cloud.
+    // TODO(wiley) We could do a lot of things here to either expose this
+    //             timeout as a configurable knob or allow local
+    //             daemons to signal that their state is up to date so that
+    //             we need not wait for them.
+    ScheduleStartDevice(base::TimeDelta::FromSeconds(5));
+  }
 
   return true;
 }
@@ -259,10 +280,18 @@
   base::MessageLoop* current = base::MessageLoop::current();
   if (!current)
     return;  // Assume we're in unittests
+  base::TimeDelta max_delay =
+      base::TimeDelta::FromMinutes(kMaxStartDeviceRetryDelayMinutes);
+  base::TimeDelta min_delay =
+      base::TimeDelta::FromSeconds(kMinStartDeviceRetryDelaySeconds);
+  base::TimeDelta retry_delay = later * 2;
+  if (retry_delay > max_delay) { retry_delay = max_delay; }
+  if (retry_delay < min_delay) { retry_delay = min_delay; }
   current->PostDelayedTask(
       FROM_HERE,
       base::Bind(&DeviceRegistrationInfo::StartDevice,
-                 weak_factory_.GetWeakPtr(), nullptr),
+                 weak_factory_.GetWeakPtr(), nullptr,
+                 retry_delay),
       later);
 }
 
@@ -718,22 +747,35 @@
                          error_callackback_with_reauthorization);
 }
 
-void DeviceRegistrationInfo::StartDevice(chromeos::ErrorPtr* error) {
+void DeviceRegistrationInfo::StartDevice(
+    chromeos::ErrorPtr* error,
+    const base::TimeDelta& retry_delay) {
   if (!HaveRegistrationCredentials(error))
     return;
-
-  base::Bind(
-      &DeviceRegistrationInfo::UpdateDeviceResource,
-      base::Unretained(this),
-      base::Bind(
-          &DeviceRegistrationInfo::FetchCommands,
-          base::Unretained(this),
-          base::Bind(
-              &DeviceRegistrationInfo::AbortLimboCommands,
-              base::Unretained(this),
-              base::Bind(
-                  &DeviceRegistrationInfo::PeriodicallyPollCommands,
-                  base::Unretained(this))))).Run();
+  auto handle_start_device_failure_cb = base::Bind(
+      &IgnoreCloudErrorWithCallback,
+      base::Bind(&DeviceRegistrationInfo::ScheduleStartDevice,
+                 weak_factory_.GetWeakPtr(),
+                 retry_delay));
+  // "Starting" a device just means that we:
+  //   1) push an updated device resource
+  //   2) fetch an initial set of outstanding commands
+  //   3) abort any commands that we've previously marked as "in progress"
+  //      or as being in an error state.
+  //   4) Initiate periodic polling for commands.
+  auto periodically_poll_commands_cb = base::Bind(
+      &DeviceRegistrationInfo::PeriodicallyPollCommands,
+      weak_factory_.GetWeakPtr());
+  auto abort_commands_cb = base::Bind(
+      &DeviceRegistrationInfo::AbortLimboCommands,
+      weak_factory_.GetWeakPtr(),
+      periodically_poll_commands_cb);
+  auto fetch_commands_cb = base::Bind(
+      &DeviceRegistrationInfo::FetchCommands,
+      weak_factory_.GetWeakPtr(),
+      abort_commands_cb,
+      handle_start_device_failure_cb);
+  UpdateDeviceResource(fetch_commands_cb, handle_start_device_failure_cb);
 }
 
 void DeviceRegistrationInfo::UpdateCommand(
@@ -746,7 +788,9 @@
       base::Bind(&IgnoreCloudResult), base::Bind(&IgnoreCloudError));
 }
 
-void DeviceRegistrationInfo::UpdateDeviceResource(base::Closure callback) {
+void DeviceRegistrationInfo::UpdateDeviceResource(
+    const base::Closure& on_success,
+    const CloudRequestErrorCallback& on_failure) {
   std::unique_ptr<base::DictionaryValue> device_resource =
       BuildDeviceResource(nullptr);
   if (!device_resource)
@@ -756,33 +800,38 @@
       chromeos::http::request_type::kPut,
       GetDeviceURL(),
       device_resource.get(),
-      base::Bind([callback](const base::DictionaryValue&){
-        base::MessageLoop::current()->PostTask(FROM_HERE, callback);
-      }),
-      // TODO(antonm): Failure to update device resource probably deserves
-      // some additional actions.
-      base::Bind(&IgnoreCloudError));
+      base::Bind(&IgnoreCloudResultWithCallback, on_success),
+      on_failure);
 }
 
+namespace {
+
+void HandleFetchCommandsResult(
+    const base::Callback<void(const base::ListValue&)>& callback,
+    const base::DictionaryValue& json) {
+  const base::ListValue* commands{nullptr};
+  if (!json.GetList("commands", &commands)) {
+    VLOG(1) << "No commands in the response.";
+  }
+  const base::ListValue empty;
+  callback.Run(commands ? *commands : empty);
+}
+
+}  // namespace
+
 void DeviceRegistrationInfo::FetchCommands(
-    base::Callback<void(const base::ListValue&)> callback) {
+    const base::Callback<void(const base::ListValue&)>& on_success,
+    const CloudRequestErrorCallback& on_failure) {
   DoCloudRequest(
       chromeos::http::request_type::kGet,
       GetServiceURL("commands/queue", {{"deviceId", device_id_}}),
       nullptr,
-      base::Bind([callback](const base::DictionaryValue& json) {
-        const base::ListValue* commands{nullptr};
-        if (!json.GetList("commands", &commands)) {
-          VLOG(1) << "No commands in the response.";
-        }
-        const base::ListValue empty;
-        callback.Run(commands ? *commands : empty);
-      }),
-      base::Bind(&IgnoreCloudError));
+      base::Bind(&HandleFetchCommandsResult, on_success),
+      on_failure);
 }
 
 void DeviceRegistrationInfo::AbortLimboCommands(
-    base::Closure callback, const base::ListValue& commands) {
+    const base::Closure& callback, const base::ListValue& commands) {
   const size_t size{commands.GetSize()};
   for (size_t i = 0; i < size; ++i) {
     const base::DictionaryValue* command{nullptr};
@@ -809,6 +858,7 @@
 
     std::unique_ptr<base::DictionaryValue> command_copy{command->DeepCopy()};
     command_copy->SetString("state", "aborted");
+    // TODO(wiley) We could consider handling this error case more gracefully.
     DoCloudRequest(
         chromeos::http::request_type::kPut,
         GetServiceURL("commands/" + command_id),
@@ -827,7 +877,8 @@
           &DeviceRegistrationInfo::FetchCommands,
           base::Unretained(this),
           base::Bind(&DeviceRegistrationInfo::PublishCommands,
-                     base::Unretained(this))),
+                     base::Unretained(this)),
+          base::Bind(&IgnoreCloudError)),
       base::TimeDelta::FromSeconds(7));
   // TODO(antonm): Use better trigger: when StateManager registers new updates,
   // it should call closure which will post a task, probably with some
diff --git a/buffet/device_registration_info.h b/buffet/device_registration_info.h
index c96c09c..7d64d31 100644
--- a/buffet/device_registration_info.h
+++ b/buffet/device_registration_info.h
@@ -106,9 +106,6 @@
   // Loads the device registration information from cache.
   bool Load();
 
-  // Cause DeviceRegistrationInfo to attempt to StartDevice on its own later.
-  void ScheduleStartDevice(const base::TimeDelta& later);
-
   // Checks for the valid device registration as well as refreshes
   // the device access token, if available.
   bool CheckRegistration(chromeos::ErrorPtr* error);
@@ -128,12 +125,6 @@
     const std::map<std::string, std::string>& params,
     chromeos::ErrorPtr* error);
 
-  // Starts device execution.
-  // Device will do required start up chores and then start to listen
-  // to new commands.
-  // TODO(antonm): Consider moving into some other class.
-  void StartDevice(chromeos::ErrorPtr* error);
-
   // Updates a command.
   // TODO(antonm): Should solve the issues with async vs. sync.
   // TODO(antonm): Consider moving some other class.
@@ -141,6 +132,16 @@
                      const base::DictionaryValue& command_patch);
 
  private:
+  // Cause DeviceRegistrationInfo to attempt to StartDevice on its own later.
+  void ScheduleStartDevice(const base::TimeDelta& later);
+
+  // Starts device execution.
+  // Device will do required start up chores and then start to listen
+  // to new commands.
+  // TODO(antonm): Consider moving into some other class.
+  void StartDevice(chromeos::ErrorPtr* error,
+                   const base::TimeDelta& retry_delay);
+
   // Saves the device registration to cache.
   bool Save() const;
 
@@ -181,11 +182,14 @@
       const CloudRequestCallback& success_callback,
       const CloudRequestErrorCallback& error_callback);
 
-  void UpdateDeviceResource(base::Closure callback);
+  void UpdateDeviceResource(const base::Closure& on_success,
+                            const CloudRequestErrorCallback& on_failure);
 
-  void FetchCommands(base::Callback<void(const base::ListValue&)> callback);
+  void FetchCommands(
+      const base::Callback<void(const base::ListValue&)>& on_success,
+      const CloudRequestErrorCallback& on_failure);
 
-  void AbortLimboCommands(base::Closure callback,
+  void AbortLimboCommands(const base::Closure& callback,
                           const base::ListValue& commands);
 
   void PeriodicallyPollCommands();
diff --git a/buffet/manager.cc b/buffet/manager.cc
index c8c6974..d02c96b 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -73,28 +73,10 @@
                      base::Unretained(this))));
   device_info_->Load();
   OnRegistrationStatusChange(device_info_->GetRegistrationStatus());
-  // Wait a significant amount of time for local daemons to publish their
-  // state to Buffet before publishing it to the cloud.
-  // TODO(wiley) We could do a lot of things here to either expose this
-  //             timeout as a configurable knob or allow local
-  //             daemons to signal that their state is up to date so that
-  //             we need not wait for them.
-  device_info_->ScheduleStartDevice(base::TimeDelta::FromSeconds(15));
   dbus_adaptor_.RegisterWithDBusObject(&dbus_object_);
   dbus_object_.RegisterAsync(cb);
 }
 
-void Manager::StartDevice(DBusMethodResponse<> response) {
-  LOG(INFO) << "Received call to Manager.StartDevice()";
-
-  chromeos::ErrorPtr error;
-  device_info_->StartDevice(&error);
-  if (error)
-    response->ReplyWithError(error.get());
-  else
-    response->Return();
-}
-
 void Manager::CheckDeviceRegistered(DBusMethodResponse<std::string> response) {
   LOG(INFO) << "Received call to Manager.CheckDeviceRegistered()";
   chromeos::ErrorPtr error;
diff --git a/buffet/manager.h b/buffet/manager.h
index 1c891ec..03bd68a 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -55,8 +55,6 @@
 
  private:
   // DBus methods:
-  // Handles calls to org.chromium.Buffet.Manager.StartDevice().
-  void StartDevice(DBusMethodResponse<> response) override;
   // Handles calls to org.chromium.Buffet.Manager.CheckDeviceRegistered().
   void CheckDeviceRegistered(DBusMethodResponse<std::string> response) override;
   // Handles calls to org.chromium.Buffet.Manager.GetDeviceInfo().