diff --git a/libweave/examples/ubuntu/file_config_store.cc b/libweave/examples/ubuntu/file_config_store.cc
index 66dd80f..d28f817 100644
--- a/libweave/examples/ubuntu/file_config_store.cc
+++ b/libweave/examples/ubuntu/file_config_store.cc
@@ -77,8 +77,8 @@
   })"}};
 }
 
-std::map<std::string, std::string> FileConfigStore::LoadStateDefs() {
-  return {{kCategory, R"({"_greeter": {"_greetings_counter":"integer"}})"}};
+std::vector<std::string> FileConfigStore::LoadStateDefs() {
+  return {R"({"_greeter": {"_greetings_counter":"integer"}})"};
 }
 
 std::vector<std::string> FileConfigStore::LoadStateDefaults() {
diff --git a/libweave/examples/ubuntu/file_config_store.h b/libweave/examples/ubuntu/file_config_store.h
index f89636d..53e56f1 100644
--- a/libweave/examples/ubuntu/file_config_store.h
+++ b/libweave/examples/ubuntu/file_config_store.h
@@ -22,7 +22,7 @@
   std::string LoadSettings() override;
   void SaveSettings(const std::string& settings) override;
   std::map<std::string, std::string> LoadCommandDefs() override;
-  std::map<std::string, std::string> LoadStateDefs() override;
+  std::vector<std::string> LoadStateDefs() override;
   std::vector<std::string> LoadStateDefaults() override;
 
  private:
diff --git a/libweave/include/weave/provider/config_store.h b/libweave/include/weave/provider/config_store.h
index 30f289c..64975a7 100644
--- a/libweave/include/weave/provider/config_store.h
+++ b/libweave/include/weave/provider/config_store.h
@@ -41,10 +41,10 @@
   // Value is JSON with command definition.
   virtual std::map<std::string, std::string> LoadCommandDefs() = 0;
 
-  // Returns device state definitions as JSON.
-  virtual std::map<std::string, std::string> LoadStateDefs() = 0;
+  // Returns device state definitions as array of JSONs.
+  virtual std::vector<std::string> LoadStateDefs() = 0;
 
-  // Returns device state defaults as JSON.
+  // Returns device state defaults as array of JSONs.
   virtual std::vector<std::string> LoadStateDefaults() = 0;
 
  protected:
diff --git a/libweave/include/weave/provider/test/mock_config_store.h b/libweave/include/weave/provider/test/mock_config_store.h
index b6ca69f..30027f3 100644
--- a/libweave/include/weave/provider/test/mock_config_store.h
+++ b/libweave/include/weave/provider/test/mock_config_store.h
@@ -43,7 +43,7 @@
   MOCK_METHOD1(SaveSettings, void(const std::string&));
 
   MOCK_METHOD0(LoadCommandDefs, std::map<std::string, std::string>());
-  MOCK_METHOD0(LoadStateDefs, std::map<std::string, std::string>());
+  MOCK_METHOD0(LoadStateDefs, std::vector<std::string>());
   MOCK_METHOD0(LoadStateDefaults, std::vector<std::string>());
 };
 
diff --git a/libweave/src/base_api_handler_unittest.cc b/libweave/src/base_api_handler_unittest.cc
index 1f1fc75..25a07f6 100644
--- a/libweave/src/base_api_handler_unittest.cc
+++ b/libweave/src/base_api_handler_unittest.cc
@@ -53,8 +53,8 @@
         'localPairingEnabled': false
       }
     })");
-    ASSERT_TRUE(state_manager_->LoadStateDefinition(*state_definition, "base",
-                                                    nullptr));
+    ASSERT_TRUE(
+        state_manager_->LoadStateDefinition(*state_definition, nullptr));
     ASSERT_TRUE(state_manager_->LoadStateDefaults(*state_defaults, nullptr));
     std::unique_ptr<Config> config{new Config{&config_store_}};
     config->Load();
diff --git a/libweave/src/states/state_manager.cc b/libweave/src/states/state_manager.cc
index 7fd9715..cd94736 100644
--- a/libweave/src/states/state_manager.cc
+++ b/libweave/src/states/state_manager.cc
@@ -61,8 +61,8 @@
   CHECK(LoadBaseStateDefinition(kBaseStateDefs, nullptr));
 
   // Load component-specific device state definitions.
-  for (const auto& pair : config_store->LoadStateDefs())
-    CHECK(LoadStateDefinition(pair.second, pair.first, nullptr));
+  for (const auto& state_def : config_store->LoadStateDefs())
+    CHECK(LoadStateDefinition(state_def, nullptr));
 
   // Load standard device state defaults.
   CHECK(LoadStateDefaults(kBaseStateDefaults, nullptr));
@@ -175,7 +175,6 @@
 }
 
 bool StateManager::LoadStateDefinition(const base::DictionaryValue& dict,
-                                       const std::string& category,
                                        ErrorPtr* error) {
   base::DictionaryValue::Iterator iter(dict);
   while (!iter.IsAtEnd()) {
@@ -199,26 +198,16 @@
       return false;
     iter.Advance();
   }
-  if (category != kDefaultCategory)
-    categories_.insert(category);
 
   return true;
 }
 
 bool StateManager::LoadStateDefinition(const std::string& json,
-                                       const std::string& category,
                                        ErrorPtr* error) {
   std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
   if (!dict)
     return false;
-  if (category == kDefaultCategory) {
-    Error::AddToPrintf(error, FROM_HERE, errors::kErrorDomain,
-                       errors::kInvalidCategoryError,
-                       "Invalid state category: '%s'", category.c_str());
-    return false;
-  }
-
-  if (!LoadStateDefinition(*dict, category, error)) {
+  if (!LoadStateDefinition(*dict, error)) {
     Error::AddToPrintf(error, FROM_HERE, errors::kErrorDomain,
                        errors::kSchemaError,
                        "Failed to load state definition: '%s'", json.c_str());
@@ -232,7 +221,7 @@
   std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
   if (!dict)
     return false;
-  if (!LoadStateDefinition(*dict, kDefaultCategory, error)) {
+  if (!LoadStateDefinition(*dict, error)) {
     Error::AddToPrintf(
         error, FROM_HERE, errors::kErrorDomain, errors::kSchemaError,
         "Failed to load base state definition: '%s'", json.c_str());
diff --git a/libweave/src/states/state_manager.h b/libweave/src/states/state_manager.h
index 1513781..5a64d78 100644
--- a/libweave/src/states/state_manager.h
+++ b/libweave/src/states/state_manager.h
@@ -51,11 +51,6 @@
   // Called by Buffet daemon at startup.
   void Startup(provider::ConfigStore* config_store);
 
-  // Returns all the categories the state properties are registered from.
-  // As with GCD command handling, the category normally represent a device
-  // service (daemon) that is responsible for a set of properties.
-  const std::set<std::string>& GetCategories() const { return categories_; }
-
   // Returns the recorded state changes since last time this method has been
   // called.
   std::pair<StateChangeQueueInterface::UpdateID, std::vector<StateChange>>
@@ -80,16 +75,12 @@
                         const base::Time& timestamp,
                         ErrorPtr* error);
 
-  // Loads a device state fragment from a JSON object. |category| represents
-  // a device daemon providing the state fragment or empty string for the
-  // base state fragment.
+  // Loads a device state fragment from a JSON object.
   bool LoadStateDefinition(const base::DictionaryValue& dict,
-                           const std::string& category,
                            ErrorPtr* error);
 
   // Loads a device state fragment JSON.
   bool LoadStateDefinition(const std::string& json,
-                           const std::string& category,
                            ErrorPtr* error);
 
   // Loads the base device state fragment JSON. This state fragment
@@ -111,7 +102,6 @@
 
   StateChangeQueueInterface* state_change_queue_;  // Owned by Manager.
   std::map<std::string, std::unique_ptr<StatePackage>> packages_;
-  std::set<std::string> categories_;
 
   std::vector<base::Closure> on_changed_;
 
diff --git a/libweave/src/states/state_manager_unittest.cc b/libweave/src/states/state_manager_unittest.cc
index 421fe2f..522e0e6 100644
--- a/libweave/src/states/state_manager_unittest.cc
+++ b/libweave/src/states/state_manager_unittest.cc
@@ -68,15 +68,14 @@
     mgr_->AddChangedCallback(
         base::Bind(&StateManagerTest::OnStateChanged, base::Unretained(this)));
 
-    LoadStateDefinition(GetTestSchema().get(), "default", nullptr);
+    LoadStateDefinition(GetTestSchema().get(), nullptr);
     ASSERT_TRUE(mgr_->LoadStateDefaults(*GetTestValues().get(), nullptr));
   }
   void TearDown() override { mgr_.reset(); }
 
   void LoadStateDefinition(const base::DictionaryValue* json,
-                           const std::string& category,
                            ErrorPtr* error) {
-    ASSERT_TRUE(mgr_->LoadStateDefinition(*json, category, error));
+    ASSERT_TRUE(mgr_->LoadStateDefinition(*json, error));
   }
 
   bool SetPropertyValue(const std::string& name,
@@ -95,11 +94,9 @@
 TEST(StateManager, Empty) {
   testing::StrictMock<MockStateChangeQueueInterface> mock_state_change_queue;
   StateManager manager(&mock_state_change_queue);
-  EXPECT_TRUE(manager.GetCategories().empty());
 }
 
 TEST_F(StateManagerTest, Initialized) {
-  EXPECT_EQ(std::set<std::string>{"default"}, mgr_->GetCategories());
   auto expected = R"({
     'base': {
       'manufacturer': 'Test Factory',
@@ -118,9 +115,7 @@
       'battery_level':'integer'
     }
   })");
-  LoadStateDefinition(dict.get(), "powerd", nullptr);
-  EXPECT_EQ((std::set<std::string>{"default", "powerd"}),
-            mgr_->GetCategories());
+  LoadStateDefinition(dict.get(), nullptr);
 
   auto expected = R"({
     'base': {
@@ -142,12 +137,12 @@
   StateManager manager(&mock_state_change_queue_);
 
   EXPECT_CALL(config_store, LoadStateDefs())
-      .WillOnce(Return(std::map<std::string, std::string>{
-          {"powerd", R"({"power": {"battery_level":"integer"}})"}}));
+      .WillOnce(Return(std::vector<std::string>{
+          {R"({"power": {"battery_level":"integer"}})"}}));
 
   EXPECT_CALL(config_store, LoadStateDefaults())
-      .WillOnce(Return(std::vector<std::string>{
-          R"({"power": {"battery_level":44}})"}));
+      .WillOnce(Return(
+          std::vector<std::string>{{R"({"power": {"battery_level":44}})"}}));
 
   manager.Startup(&config_store);
 
diff --git a/libweave/src/weave_unittest.cc b/libweave/src/weave_unittest.cc
index 28edb82..e731803 100644
--- a/libweave/src/weave_unittest.cc
+++ b/libweave/src/weave_unittest.cc
@@ -165,11 +165,10 @@
             std::map<std::string, std::string>{{kCategory, kCommandDefs}}));
 
     EXPECT_CALL(config_store_, LoadStateDefs())
-        .WillOnce(Return(
-            std::map<std::string, std::string>{{kCategory, kStateDefs}}));
+        .WillOnce(Return(std::vector<std::string>{{kStateDefs}}));
 
     EXPECT_CALL(config_store_, LoadStateDefaults())
-        .WillOnce(Return(std::vector<std::string>{kStateDefaults}));
+        .WillOnce(Return(std::vector<std::string>{{kStateDefaults}}));
   }
 
   void InitNetwork() {