diff --git a/Android.mk b/Android.mk
index 252ffcf..775bdc2 100644
--- a/Android.mk
+++ b/Android.mk
@@ -21,12 +21,14 @@
 BRILLO_USE_HWID_OVERRIDE ?= 0
 BRILLO_USE_MTD ?= 0
 BRILLO_USE_POWER_MANAGEMENT ?= 0
+BRILLO_USE_WEAVE ?= 0
 
 ue_common_cflags := \
     -DUSE_DBUS=$(BRILLO_USE_DBUS) \
     -DUSE_HWID_OVERRIDE=$(BRILLO_USE_HWID_OVERRIDE) \
     -DUSE_MTD=$(BRILLO_USE_MTD) \
     -DUSE_POWER_MANAGEMENT=$(BRILLO_USE_POWER_MANAGEMENT) \
+    -DUSE_WEAVE=$(BRILLO_USE_WEAVE) \
     -D_FILE_OFFSET_BITS=64 \
     -D_POSIX_C_SOURCE=199309L \
     -Wa,--noexecstack \
@@ -247,6 +249,10 @@
     libcutils \
     $(ue_libpayload_consumer_exported_shared_libraries) \
     $(ue_update_metadata_protos_exported_shared_libraries)
+ifeq ($(BRILLO_USE_WEAVE),1)
+ue_libupdate_engine_exported_shared_libraries += \
+    libweaved
+endif  # BRILLO_USE_WEAVE == 1
 
 include $(CLEAR_VARS)
 LOCAL_MODULE := libupdate_engine
@@ -308,7 +314,12 @@
     update_manager/real_updater_provider.cc \
     update_manager/state_factory.cc \
     update_manager/update_manager.cc \
-    update_status_utils.cc
+    update_status_utils.cc \
+    weave_service_factory.cc
+ifeq ($(BRILLO_USE_WEAVE),1)
+LOCAL_SRC_FILES += \
+    weave_service.cc
+endif  # BRILLO_USE_WEAVE == 1
 include $(BUILD_STATIC_LIBRARY)
 
 endif  # BRILLO_USE_DBUS == 1
@@ -322,6 +333,9 @@
 LOCAL_REQUIRED_MODULES := \
     bspatch \
     cacerts_google
+ifeq ($(BRILLO_USE_WEAVE),1)
+LOCAL_REQUIRED_MODULES += updater.json
+endif  # BRILLO_USE_WEAVE == 1
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_CLANG := true
 LOCAL_CFLAGS := $(ue_common_cflags)
@@ -561,6 +575,15 @@
 
 endif  # BRILLO_USE_DBUS == 1
 
+# Weave schema files
+# ========================================================
+include $(CLEAR_VARS)
+LOCAL_MODULE := updater.json
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/weaved/traits
+LOCAL_SRC_FILES := weaved/traits/$(LOCAL_MODULE)
+include $(BUILD_PREBUILT)
+
 # Update payload signing public key.
 # ========================================================
 include $(CLEAR_VARS)
diff --git a/fake_system_state.h b/fake_system_state.h
index 75ef315..12d9239 100644
--- a/fake_system_state.h
+++ b/fake_system_state.h
@@ -85,6 +85,8 @@
     return update_attempter_;
   }
 
+  inline WeaveServiceInterface* weave_service() override { return nullptr; }
+
   inline OmahaRequestParams* request_params() override {
     return request_params_;
   }
diff --git a/real_system_state.cc b/real_system_state.cc
index 3a90292..ffb2193 100644
--- a/real_system_state.cc
+++ b/real_system_state.cc
@@ -16,6 +16,8 @@
 
 #include "update_engine/real_system_state.h"
 
+#include <string>
+
 #include <base/files/file_util.h>
 #include <base/time/time.h>
 #include <brillo/make_unique_ptr.h>
@@ -26,11 +28,13 @@
 #include "update_engine/common/hardware.h"
 #include "update_engine/common/utils.h"
 #include "update_engine/update_manager/state_factory.h"
+#include "update_engine/weave_service_factory.h"
 
 namespace chromeos_update_engine {
 
 RealSystemState::RealSystemState(const scoped_refptr<dbus::Bus>& bus)
-    : debugd_proxy_(bus),
+    : bus_(bus),
+      debugd_proxy_(bus),
       power_manager_proxy_(bus),
       session_manager_proxy_(bus),
       shill_proxy_(bus),
@@ -121,6 +125,8 @@
                           &debugd_proxy_));
   update_attempter_->Init();
 
+  weave_service_ = ConstructWeaveService(bus_, update_attempter_.get());
+
   // Initialize the Update Manager using the default state factory.
   chromeos_update_manager::State* um_state =
       chromeos_update_manager::DefaultStateFactory(
diff --git a/real_system_state.h b/real_system_state.h
index 8ca1abc..d7ee712 100644
--- a/real_system_state.h
+++ b/real_system_state.h
@@ -38,6 +38,7 @@
 #include "update_engine/shill_proxy.h"
 #include "update_engine/update_attempter.h"
 #include "update_engine/update_manager/update_manager.h"
+#include "update_engine/weave_service_interface.h"
 
 namespace chromeos_update_engine {
 
@@ -92,6 +93,10 @@
     return update_attempter_.get();
   }
 
+  inline WeaveServiceInterface* weave_service() override {
+    return weave_service_.get();
+  }
+
   inline OmahaRequestParams* request_params() override {
     return &request_params_;
   }
@@ -110,6 +115,9 @@
   inline bool system_rebooted() override { return system_rebooted_; }
 
  private:
+  // Reference to the DBus bus.
+  scoped_refptr<dbus::Bus> bus_;
+
   // Real DBus proxies using the DBus connection.
   org::chromium::debugdProxy debugd_proxy_;
   org::chromium::PowerManagerProxy power_manager_proxy_;
@@ -158,6 +166,8 @@
 
   std::unique_ptr<P2PManager> p2p_manager_;
 
+  std::unique_ptr<WeaveServiceInterface> weave_service_;
+
   std::unique_ptr<chromeos_update_manager::UpdateManager> update_manager_;
 
   policy::PolicyProvider policy_provider_;
diff --git a/system_state.h b/system_state.h
index 2ba0272..7923217 100644
--- a/system_state.h
+++ b/system_state.h
@@ -51,6 +51,7 @@
 class PayloadStateInterface;
 class PrefsInterface;
 class UpdateAttempter;
+class WeaveServiceInterface;
 
 // An interface to global system context, including platform resources,
 // the current state of the system, high-level objects whose lifetime is same
@@ -98,6 +99,9 @@
   // Returns a pointer to the update attempter object.
   virtual UpdateAttempter* update_attempter() = 0;
 
+  // Returns a pointer to the WeaveServiceInterface class or nullptr if none.
+  virtual WeaveServiceInterface* weave_service() = 0;
+
   // Returns a pointer to the object that stores the parameters that are
   // common to all Omaha requests.
   virtual OmahaRequestParams* request_params() = 0;
diff --git a/update_attempter.cc b/update_attempter.cc
index 5704731..bc06502 100644
--- a/update_attempter.cc
+++ b/update_attempter.cc
@@ -762,7 +762,7 @@
   }
 
   vector<BootControlInterface::Slot> bootable_slots;
-  for(BootControlInterface::Slot slot = 0; slot < num_slots; slot++) {
+  for (BootControlInterface::Slot slot = 0; slot < num_slots; slot++) {
     if (slot != current_slot &&
         system_state_->boot_control()->IsSlotBootable(slot)) {
       LOG(INFO) << "Found bootable slot "
@@ -1083,6 +1083,42 @@
   system_state_->payload_state()->DownloadComplete();
 }
 
+bool UpdateAttempter::OnCheckForUpdates(brillo::ErrorPtr* error) {
+  CheckForUpdate(
+      "" /* app_version */, "" /* omaha_url */, true /* interactive */);
+  return true;
+}
+
+bool UpdateAttempter::OnTrackChannel(const string& channel,
+                                     brillo::ErrorPtr* error) {
+  LOG(INFO) << "Setting destination channel to: " << channel;
+  string error_message;
+  if (!system_state_->request_params()->SetTargetChannel(
+          channel, false /* powerwash_allowed */, &error_message)) {
+    brillo::Error::AddTo(error,
+                         FROM_HERE,
+                         brillo::errors::dbus::kDomain,
+                         "_set_target_error",
+                         error_message);
+    return false;
+  }
+  return true;
+}
+
+bool UpdateAttempter::GetWeaveState(int64_t* last_checked_time,
+                                    double* progress,
+                                    UpdateStatus* update_status,
+                                    string* current_channel,
+                                    string* tracking_channel) {
+  *last_checked_time = last_checked_time_;
+  *progress = download_progress_;
+  *update_status = status_;
+  OmahaRequestParams* rp = system_state_->request_params();
+  *current_channel = rp->current_channel();
+  *tracking_channel = rp->target_channel();
+  return true;
+}
+
 bool UpdateAttempter::ResetStatus() {
   LOG(INFO) << "Attempting to reset state from "
             << UpdateStatusToString(status_) << " to UpdateStatus::IDLE";
@@ -1172,6 +1208,9 @@
 }
 
 void UpdateAttempter::BroadcastStatus() {
+  if (system_state_->weave_service())
+    system_state_->weave_service()->UpdateWeaveState();
+
   if (!dbus_adaptor_)
     return;
   last_notify_time_ = TimeTicks::Now();
diff --git a/update_attempter.h b/update_attempter.h
index cfe3e32..3a2c30d 100644
--- a/update_attempter.h
+++ b/update_attempter.h
@@ -41,6 +41,7 @@
 #include "update_engine/system_state.h"
 #include "update_engine/update_manager/policy.h"
 #include "update_engine/update_manager/update_manager.h"
+#include "update_engine/weave_service_interface.h"
 
 class MetricsLibraryInterface;
 
@@ -54,7 +55,8 @@
 
 class UpdateAttempter : public ActionProcessorDelegate,
                         public DownloadActionDelegate,
-                        public CertificateChecker::Observer {
+                        public CertificateChecker::Observer,
+                        public WeaveServiceInterface::DelegateInterface {
  public:
   using UpdateStatus = update_engine::UpdateStatus;
   static const int kMaxDeltaUpdateFailures;
@@ -93,6 +95,16 @@
                        AbstractAction* action,
                        ErrorCode code) override;
 
+  // WeaveServiceInterface::DelegateInterface overrides.
+  bool OnCheckForUpdates(brillo::ErrorPtr* error) override;
+  bool OnTrackChannel(const std::string& channel,
+                      brillo::ErrorPtr* error) override;
+  bool GetWeaveState(int64_t* last_checked_time,
+                     double* progress,
+                     UpdateStatus* update_status,
+                     std::string* current_channel,
+                     std::string* tracking_channel) override;
+
   // Resets the current state to UPDATE_STATUS_IDLE.
   // Used by update_engine_client for restarting a new update without
   // having to reboot once the previous update has reached
diff --git a/update_engine.gyp b/update_engine.gyp
index 01d691d..5490a2a 100644
--- a/update_engine.gyp
+++ b/update_engine.gyp
@@ -27,6 +27,7 @@
       'USE_hwid_override%': '0',
       'USE_mtd%': '0',
       'USE_power_management%': '0',
+      'USE_buffet%': '0',
     },
     'cflags': [
       '-g',
@@ -50,6 +51,7 @@
       'USE_HWID_OVERRIDE=<(USE_hwid_override)',
       'USE_MTD=<(USE_mtd)',
       'USE_POWER_MANAGEMENT=<(USE_power_management)',
+      'USE_WEAVE=<(USE_buffet)',
     ],
     'include_dirs': [
       # We need this include dir because we include all the local code as
@@ -272,6 +274,19 @@
         'update_manager/state_factory.cc',
         'update_manager/update_manager.cc',
         'update_status_utils.cc',
+        'weave_service_factory.cc',
+      ],
+      'conditions': [
+        ['USE_buffet == 1', {
+          'sources': [
+            'weave_service.cc',
+          ],
+          'variables': {
+            'exported_deps': [
+              'libweave-<(libbase_ver)',
+            ],
+          },
+        }],
       ],
     },
     # update_engine daemon.
diff --git a/update_status_utils.cc b/update_status_utils.cc
index ff039b8..9685853 100644
--- a/update_status_utils.cc
+++ b/update_status_utils.cc
@@ -20,6 +20,21 @@
 
 using update_engine::UpdateStatus;
 
+namespace {
+
+const char kWeaveStatusIdle[] = "idle";
+const char kWeaveStatusCheckingForUpdate[] = "checkingForUpdate";
+const char kWeaveStatusUpdateAvailable[] = "updateAvailable";
+const char kWeaveStatusDownloading[] = "downloading";
+const char kWeaveStatusVerifying[] = "verifying";
+const char kWeaveStatusFinalizing[] = "finalizing";
+const char kWeaveStatusUpdatedNeedReboot[] = "updatedNeedReboot";
+const char kWeaveStatusReportingErrorEvent[] = "reportingErrorEvent";
+const char kWeaveStatusAttemptingRollback[] = "attemptingRollback";
+const char kWeaveStatusDisabled[] = "disabled";
+
+}  // namespace
+
 namespace chromeos_update_engine {
 
 const char* UpdateStatusToString(const UpdateStatus& status) {
@@ -50,6 +65,34 @@
   return nullptr;
 }
 
+const char* UpdateStatusToWeaveStatus(const UpdateStatus& status) {
+  switch (status) {
+    case UpdateStatus::IDLE:
+      return kWeaveStatusIdle;
+    case UpdateStatus::CHECKING_FOR_UPDATE:
+      return kWeaveStatusCheckingForUpdate;
+    case UpdateStatus::UPDATE_AVAILABLE:
+      return kWeaveStatusUpdateAvailable;
+    case UpdateStatus::DOWNLOADING:
+      return kWeaveStatusDownloading;
+    case UpdateStatus::VERIFYING:
+      return kWeaveStatusVerifying;
+    case UpdateStatus::FINALIZING:
+      return kWeaveStatusFinalizing;
+    case UpdateStatus::UPDATED_NEED_REBOOT:
+      return kWeaveStatusUpdatedNeedReboot;
+    case UpdateStatus::REPORTING_ERROR_EVENT:
+      return kWeaveStatusReportingErrorEvent;
+    case UpdateStatus::ATTEMPTING_ROLLBACK:
+      return kWeaveStatusAttemptingRollback;
+    case UpdateStatus::DISABLED:
+      return kWeaveStatusDisabled;
+  }
+
+  NOTREACHED();
+  return nullptr;
+}
+
 bool StringToUpdateStatus(const std::string& s,
                           UpdateStatus* status) {
   if (s == update_engine::kUpdateStatusIdle) {
diff --git a/update_status_utils.h b/update_status_utils.h
index 30ae53b..9d85144 100644
--- a/update_status_utils.h
+++ b/update_status_utils.h
@@ -25,6 +25,10 @@
 
 const char* UpdateStatusToString(const update_engine::UpdateStatus& status);
 
+// Convert the UpdateStatus |status| to the string reported in the weave status.
+const char* UpdateStatusToWeaveStatus(
+    const update_engine::UpdateStatus& status);
+
 bool StringToUpdateStatus(const std::string& update_status_as_string,
                           update_engine::UpdateStatus* status);
 
diff --git a/weave_service.cc b/weave_service.cc
new file mode 100644
index 0000000..367359a
--- /dev/null
+++ b/weave_service.cc
@@ -0,0 +1,119 @@
+//
+// Copyright (C) 2015 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 "update_engine/weave_service.h"
+
+#include <cmath>
+#include <string>
+
+#include <base/bind.h>
+#include <base/values.h>
+#include <brillo/errors/error.h>
+
+#include "update_engine/update_status_utils.h"
+
+using std::string;
+
+namespace {
+
+const char kWeaveComponent[] = "updater";
+
+}  // namespace
+
+namespace chromeos_update_engine {
+
+bool WeaveService::Init(scoped_refptr<dbus::Bus> bus,
+                        DelegateInterface* delegate) {
+  delegate_ = delegate;
+  device_ = weaved::Device::CreateInstance(
+      bus, base::Bind(&WeaveService::UpdateWeaveState, base::Unretained(this)));
+  device_->AddComponent(kWeaveComponent, {"_updater"});
+  device_->AddCommandHandler(
+      kWeaveComponent,
+      "_updater.checkForUpdates",
+      base::Bind(&WeaveService::OnCheckForUpdates, base::Unretained(this)));
+  device_->AddCommandHandler(
+      kWeaveComponent,
+      "_updater.trackChannel",
+      base::Bind(&WeaveService::OnTrackChannel, base::Unretained(this)));
+
+  return true;
+}
+
+void WeaveService::UpdateWeaveState() {
+  if (!device_ || !delegate_)
+    return;
+
+  int64_t last_checked_time;
+  double progress;
+  update_engine::UpdateStatus update_status;
+  string current_channel;
+  string tracking_channel;
+
+  if (!delegate_->GetWeaveState(&last_checked_time,
+                                &progress,
+                                &update_status,
+                                &current_channel,
+                                &tracking_channel))
+    return;
+
+  // Round to progress to 1% (0.01) to avoid excessive and meaningless state
+  // changes.
+  progress = std::floor(progress * 100.) / 100.;
+
+  brillo::VariantDictionary state{
+      {"_updater.currentChannel", current_channel},
+      {"_updater.trackingChannel", tracking_channel},
+      {"_updater.status", UpdateStatusToWeaveStatus(update_status)},
+      {"_updater.progress", progress},
+      {"_updater.lastUpdateCheckTimestamp",
+       static_cast<double>(last_checked_time)},
+  };
+
+  if (!device_->SetStateProperties(kWeaveComponent, state, nullptr)) {
+    LOG(ERROR) << "Failed to update _updater state.";
+  }
+}
+
+void WeaveService::OnCheckForUpdates(
+    const std::weak_ptr<weaved::Command>& cmd) {
+  auto command = cmd.lock();
+  if (!command)
+    return;
+
+  brillo::ErrorPtr error;
+  if (!delegate_->OnCheckForUpdates(&error)) {
+    command->Abort(error->GetCode(), error->GetMessage(), nullptr);
+    return;
+  }
+  command->Complete({}, nullptr);
+}
+
+void WeaveService::OnTrackChannel(const std::weak_ptr<weaved::Command>& cmd) {
+  auto command = cmd.lock();
+  if (!command)
+    return;
+
+  string channel = command->GetParameter<string>("channel");
+  brillo::ErrorPtr error;
+  if (!delegate_->OnTrackChannel(channel, &error)) {
+    command->Abort(error->GetCode(), error->GetMessage(), nullptr);
+    return;
+  }
+  command->Complete({}, nullptr);
+}
+
+}  // namespace chromeos_update_engine
diff --git a/weave_service.h b/weave_service.h
new file mode 100644
index 0000000..6790d54
--- /dev/null
+++ b/weave_service.h
@@ -0,0 +1,53 @@
+//
+// Copyright (C) 2015 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.
+//
+
+#ifndef UPDATE_ENGINE_WEAVE_SERVICE_H_
+#define UPDATE_ENGINE_WEAVE_SERVICE_H_
+
+#include <memory>
+
+#include <dbus/bus.h>
+#include <libweaved/command.h>
+#include <libweaved/device.h>
+
+#include "update_engine/weave_service_interface.h"
+
+namespace chromeos_update_engine {
+
+class WeaveService : public WeaveServiceInterface {
+ public:
+  WeaveService() = default;
+  ~WeaveService() override = default;
+
+  bool Init(scoped_refptr<dbus::Bus> bus, DelegateInterface* delegate);
+
+  // WeaveServiceInterface override.
+  void UpdateWeaveState() override;
+
+ private:
+  // Weave command handlers. These are called from the message loop whenever a
+  // command is received and dispatch the synchronous call to the |delegate_|.
+  void OnCheckForUpdates(const std::weak_ptr<weaved::Command>& cmd);
+  void OnTrackChannel(const std::weak_ptr<weaved::Command>& cmd);
+
+  WeaveServiceInterface::DelegateInterface* delegate_{nullptr};
+
+  std::unique_ptr<weaved::Device> device_;
+};
+
+}  // namespace chromeos_update_engine
+
+#endif  // UPDATE_ENGINE_WEAVE_SERVICE_H_
diff --git a/weave_service_factory.cc b/weave_service_factory.cc
new file mode 100644
index 0000000..793e906
--- /dev/null
+++ b/weave_service_factory.cc
@@ -0,0 +1,41 @@
+//
+// Copyright (C) 2015 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 "update_engine/weave_service_factory.h"
+
+#if USE_WEAVE
+#include "update_engine/weave_service.h"
+#endif
+
+namespace chromeos_update_engine {
+
+std::unique_ptr<WeaveServiceInterface> ConstructWeaveService(
+    const scoped_refptr<dbus::Bus>& bus,
+    WeaveServiceInterface::DelegateInterface* delegate) {
+  std::unique_ptr<WeaveServiceInterface> result;
+  if (!delegate || !bus.get())
+    return result;
+
+#if USE_WEAVE
+  WeaveService* weave_service = new WeaveService();
+  result.reset(weave_service);
+  if (!weave_service->Init(bus, delegate))
+    result.reset();
+#endif
+  return result;
+}
+
+}  // namespace chromeos_update_engine
diff --git a/weave_service_factory.h b/weave_service_factory.h
new file mode 100644
index 0000000..b32e0b7
--- /dev/null
+++ b/weave_service_factory.h
@@ -0,0 +1,37 @@
+//
+// Copyright (C) 2015 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.
+//
+
+#ifndef UPDATE_ENGINE_WEAVE_SERVICE_FACTORY_H_
+#define UPDATE_ENGINE_WEAVE_SERVICE_FACTORY_H_
+
+#include <memory>
+
+#include <base/memory/ref_counted.h>
+#include <dbus/bus.h>
+
+#include "update_engine/weave_service_interface.h"
+
+namespace chromeos_update_engine {
+
+// Create a new WeaveServiceInterface instance. In case of error or when weaved
+// is disabled, returns an empty pointer.
+std::unique_ptr<WeaveServiceInterface> ConstructWeaveService(
+    const scoped_refptr<dbus::Bus>& bus,
+    WeaveServiceInterface::DelegateInterface* delegate);
+
+}  // namespace chromeos_update_engine
+
+#endif  // UPDATE_ENGINE_WEAVE_SERVICE_FACTORY_H_
diff --git a/weave_service_interface.h b/weave_service_interface.h
new file mode 100644
index 0000000..baaa9db
--- /dev/null
+++ b/weave_service_interface.h
@@ -0,0 +1,64 @@
+//
+// Copyright (C) 2015 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.
+//
+
+#ifndef UPDATE_ENGINE_WEAVE_SERVICE_INTERFACE_H_
+#define UPDATE_ENGINE_WEAVE_SERVICE_INTERFACE_H_
+
+#include <string>
+
+#include <brillo/errors/error.h>
+
+#include "update_engine/client_library/include/update_engine/update_status.h"
+
+namespace chromeos_update_engine {
+
+// A WeaveServiceInterface instance allows to register the daemon with weaved,
+// handle commands and update the weave status. This class only handles the
+// registration with weaved and the connection, the actual work to handle the
+// commands is implemented by the DelegateInterface, which will be called from
+// this class.
+class WeaveServiceInterface {
+ public:
+  // The delegate class that actually handles the command execution from
+  class DelegateInterface {
+   public:
+    virtual ~DelegateInterface() = default;
+
+    virtual bool OnCheckForUpdates(brillo::ErrorPtr* error) = 0;
+
+    virtual bool OnTrackChannel(const std::string& channel,
+                                brillo::ErrorPtr* error) = 0;
+
+    // Return the current status.
+    virtual bool GetWeaveState(int64_t* last_checked_time,
+                               double* progress,
+                               update_engine::UpdateStatus* update_status,
+                               std::string* current_channel,
+                               std::string* tracking_channel) = 0;
+  };
+
+  virtual ~WeaveServiceInterface() = default;
+
+  // Force a weave state update.
+  virtual void UpdateWeaveState() = 0;
+
+ protected:
+  WeaveServiceInterface() = default;
+};
+
+}  // namespace chromeos_update_engine
+
+#endif  // UPDATE_ENGINE_WEAVE_SERVICE_INTERFACE_H_
diff --git a/weaved/traits/updater.json b/weaved/traits/updater.json
new file mode 100644
index 0000000..52b1a55
--- /dev/null
+++ b/weaved/traits/updater.json
@@ -0,0 +1,52 @@
+{
+  "_updater": {
+    "commands": {
+      "checkForUpdates": {
+        "minimalRole": "manager",
+        "parameters": {}
+      },
+      "trackChannel": {
+        "minimalRole": "manager",
+        "parameters": {
+          "channel": {
+            "type": "string",
+            "enum": ["stable-channel", "beta-channel", "dev-channel", "canary-channel"]
+          }
+        }
+      }
+    },
+    "state": {
+      "currentChannel": {
+        "type": "string",
+        "enum": ["stable-channel", "beta-channel", "dev-channel", "canary-channel"]
+      },
+      "trackingChannel": {
+        "type": "string",
+        "enum": ["stable-channel", "beta-channel", "dev-channel", "canary-channel"]
+      },
+      "status": {
+        "type": "string",
+        "enum": [
+          "idle",
+          "checkingForUpdate",
+          "updateAvailable",
+          "downloading",
+          "verifying",
+          "finalizing",
+          "updatedNeedReboot",
+          "reportingErrorEvent",
+          "attemptingRollback",
+          "disabled"
+        ]
+      },
+      "progress": {
+        "type": "number",
+        "minimum": 0,
+        "maximum": 1
+      },
+      "lastUpdateCheckTimestamp": {
+        "type": "number"
+      }
+    }
+  }
+}