diff --git a/buffet/buffet.gyp b/buffet/buffet.gyp
index 0174e5b..2197989 100644
--- a/buffet/buffet.gyp
+++ b/buffet/buffet.gyp
@@ -25,6 +25,9 @@
       'sources': [
         'any.cc',
         'async_event_sequencer.cc',
+        'commands/command_definition.cc',
+        'commands/command_dictionary.cc',
+        'commands/command_manager.cc',
         'commands/object_schema.cc',
         'commands/prop_constraints.cc',
         'commands/prop_types.cc',
@@ -82,6 +85,9 @@
         'any_internal_impl_unittest.cc',
         'async_event_sequencer_unittest.cc',
         'buffet_testrunner.cc',
+        'commands/command_definition_unittest.cc',
+        'commands/command_dictionary_unittest.cc',
+        'commands/command_manager_unittest.cc',
         'commands/object_schema_unittest.cc',
         'commands/schema_utils_unittest.cc',
         'commands/unittest_utils.cc',
diff --git a/buffet/commands/command_definition.cc b/buffet/commands/command_definition.cc
new file mode 100644
index 0000000..f24b22d
--- /dev/null
+++ b/buffet/commands/command_definition.cc
@@ -0,0 +1,15 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "buffet/commands/command_definition.h"
+
+namespace buffet {
+
+CommandDefinition::CommandDefinition(
+    const std::string& category,
+    const std::shared_ptr<const ObjectSchema>& parameters)
+        : category_(category), parameters_(parameters) {
+}
+
+}  // namespace buffet
diff --git a/buffet/commands/command_definition.h b/buffet/commands/command_definition.h
new file mode 100644
index 0000000..36ba554
--- /dev/null
+++ b/buffet/commands/command_definition.h
@@ -0,0 +1,42 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BUFFET_COMMANDS_COMMAND_DEFINITION_H_
+#define BUFFET_COMMANDS_COMMAND_DEFINITION_H_
+
+#include <memory>
+#include <string>
+
+#include <base/basictypes.h>
+
+#include "buffet/commands/object_schema.h"
+
+namespace buffet {
+
+// A simple GCD command definition. This class contains the command category
+// and a full object schema describing the command parameter types and
+// constraints. See comments for CommandDefinitions::LoadCommands for the
+// detailed description of what command categories are and what they are used
+// for.
+class CommandDefinition {
+ public:
+  CommandDefinition(const std::string& category,
+                    const std::shared_ptr<const ObjectSchema>& parameters);
+
+  // Gets the category this command belongs to.
+  const std::string& GetCategory() const { return category_; }
+  // Gets the object schema for command parameters.
+  const std::shared_ptr<const ObjectSchema>& GetParameters() const {
+    return parameters_;
+  }
+
+ private:
+  std::string category_;  // Cmd category. Could be "powerd" for "base.reboot".
+  std::shared_ptr<const ObjectSchema> parameters_;  // Command parameter def.
+  DISALLOW_COPY_AND_ASSIGN(CommandDefinition);
+};
+
+}  // namespace buffet
+
+#endif  // BUFFET_COMMANDS_COMMAND_DEFINITION_H_
diff --git a/buffet/commands/command_definition_unittest.cc b/buffet/commands/command_definition_unittest.cc
new file mode 100644
index 0000000..76212af
--- /dev/null
+++ b/buffet/commands/command_definition_unittest.cc
@@ -0,0 +1,14 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <gtest/gtest.h>
+
+#include "buffet/commands/command_definition.h"
+
+TEST(CommandDefinition, Test) {
+  auto params = std::make_shared<buffet::ObjectSchema>();
+  buffet::CommandDefinition def("powerd", params);
+  EXPECT_EQ("powerd", def.GetCategory());
+  EXPECT_EQ(params, def.GetParameters());
+}
diff --git a/buffet/commands/command_dictionary.cc b/buffet/commands/command_dictionary.cc
new file mode 100644
index 0000000..69f9e2b
--- /dev/null
+++ b/buffet/commands/command_dictionary.cc
@@ -0,0 +1,125 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "buffet/commands/command_dictionary.h"
+
+#include <base/values.h>
+
+#include "buffet/commands/command_definition.h"
+#include "buffet/commands/schema_constants.h"
+#include "buffet/string_utils.h"
+
+namespace buffet {
+
+std::vector<std::string> CommandDictionary::GetCommandNamesByCategory(
+    const std::string& category) const {
+  std::vector<std::string> names;
+  for (const auto& pair : definitions_) {
+    if (pair.second->GetCategory() == category)
+      names.push_back(pair.first);
+  }
+  return names;
+}
+
+bool CommandDictionary::LoadCommands(const base::DictionaryValue& json,
+                                     const std::string& category,
+                                     ErrorPtr* error) {
+  std::map<std::string, std::shared_ptr<const CommandDefinition>> new_defs;
+
+  // |json| contains a list of nested objects with the following structure:
+  // {"<pkg_name>": {"<cmd_name>": {"parameters": {object_schema}}, ...}, ...}
+  // Iterate over packages
+  base::DictionaryValue::Iterator package_iter(json);
+  while (!package_iter.IsAtEnd()) {
+    std::string package = package_iter.key();
+    const base::DictionaryValue* package_value = nullptr;
+    if (!package_iter.value().GetAsDictionary(&package_value)) {
+      Error::AddToPrintf(error, commands::errors::kDomain,
+                         commands::errors::kTypeMismatch,
+                         "Expecting an object for package '%s'",
+                         package.c_str());
+      return false;
+    }
+    // Iterate over command definitions within the current package.
+    base::DictionaryValue::Iterator command_iter(*package_value);
+    while (!command_iter.IsAtEnd()) {
+      std::string command = command_iter.key();
+      const base::DictionaryValue* command_value = nullptr;
+      if (!command_iter.value().GetAsDictionary(&command_value)) {
+        Error::AddToPrintf(error, commands::errors::kDomain,
+                           commands::errors::kTypeMismatch,
+                           "Expecting an object for command '%s'",
+                           command.c_str());
+        return false;
+      }
+      // Construct the compound command name as "pkg_name.cmd_name".
+      std::string command_name = string_utils::Join('.', package, command);
+      // Get the "parameters" definition of the command and read it into
+      // an object schema.
+      const base::DictionaryValue* command_schema_def = nullptr;
+      if (!command_value->GetDictionaryWithoutPathExpansion(
+          commands::attributes::kCommand_Parameters, &command_schema_def)) {
+        Error::AddToPrintf(error, commands::errors::kDomain,
+                           commands::errors::kPropertyMissing,
+                           "Command definition '%s' is missing property '%s'",
+                           command_name.c_str(),
+                           commands::attributes::kCommand_Parameters);
+        return false;
+      }
+      auto command_schema = std::make_shared<ObjectSchema>();
+      if (!command_schema->FromJson(command_schema_def, nullptr, error)) {
+        Error::AddToPrintf(error, commands::errors::kDomain,
+                           commands::errors::kInvalidObjectSchema,
+                           "Invalid definition for command '%s'",
+                           command_name.c_str());
+        return false;
+      }
+      auto command_def = std::make_shared<CommandDefinition>(category,
+                                                             command_schema);
+      new_defs.insert(std::make_pair(command_name, command_def));
+
+      command_iter.Advance();
+    }
+    package_iter.Advance();
+  }
+
+  // Verify that newly loaded command definitions do not override existing
+  // definitions in another category. This is unlikely, but we don't want to let
+  // one vendor daemon to define the same commands already handled by another
+  // daemon on the same device.
+  for (const auto& pair : new_defs) {
+    auto iter = definitions_.find(pair.first);
+    if (iter != definitions_.end()) {
+        Error::AddToPrintf(error, commands::errors::kDomain,
+                           commands::errors::kDuplicateCommandDef,
+                           "Definition for command '%s' overrides an earlier "
+                           "definition in category '%s'",
+                           pair.first.c_str(),
+                           iter->second->GetCategory().c_str());
+        return false;
+    }
+  }
+
+  // Now that we successfully loaded all the command definitions,
+  // remove previous definitions of commands from the same category.
+  std::vector<std::string> names = GetCommandNamesByCategory(category);
+  for (const std::string& name : names)
+    definitions_.erase(name);
+
+  // Insert new definitions into the global map.
+  definitions_.insert(new_defs.begin(), new_defs.end());
+  return true;
+}
+
+const CommandDefinition* CommandDictionary::FindCommand(
+    const std::string& command_name) const {
+  auto pair = definitions_.find(command_name);
+  return (pair != definitions_.end()) ? pair->second.get() : nullptr;
+}
+
+void CommandDictionary::Clear() {
+  definitions_.clear();
+}
+
+}  // namespace buffet
diff --git a/buffet/commands/command_dictionary.h b/buffet/commands/command_dictionary.h
new file mode 100644
index 0000000..11295c9
--- /dev/null
+++ b/buffet/commands/command_dictionary.h
@@ -0,0 +1,72 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BUFFET_COMMANDS_COMMAND_DICTIONARY_H_
+#define BUFFET_COMMANDS_COMMAND_DICTIONARY_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/basictypes.h>
+
+#include "buffet/error.h"
+
+namespace base {
+class Value;
+class DictionaryValue;
+}  // namespace base
+
+namespace buffet {
+
+class CommandDefinition;
+
+// CommandDictionary is a wrapper around a map of command name and the
+// corresponding command definition schema. The command name (the key in
+// the map) is a compound name in a form of "package_name.command_name",
+// where "package_name" is a name of command package such as "base", "printers",
+// and others. So the full command name could be "base.reboot", for example.
+class CommandDictionary {
+ public:
+  CommandDictionary() = default;
+
+  // Gets the list of names of commands that belong to the given category.
+  std::vector<std::string> GetCommandNamesByCategory(
+      const std::string& category) const;
+
+  // Loads command definitions from a JSON object. This is done at the daemon
+  // startup and whenever a device daemon decides to update its command list.
+  // |json| is a JSON dictionary that describes the complete commands contained
+  // in a particular |category|. Usually, |categories| are 1:1 with daemons on
+  // a device. For instance, the power manager daemon might provide a category
+  // "power_man" that provides the "base.reboot" and "base.shutdown" commands.
+  // However, nothing prohibits a daemon providing commands in two categories.
+  // When LoadCommands is called, all previous definitions of commands from the
+  // same category are removed, effectively replacing all the commands in the
+  // given category.
+  // Returns false on failure and |error| provides additional error information
+  // when provided.
+  bool LoadCommands(const base::DictionaryValue& json,
+                    const std::string& category, ErrorPtr* error);
+  // Returns the number of command definitions in the dictionary.
+  size_t GetSize() const { return definitions_.size(); }
+  // Checks if the dictionary has no command definitions.
+  bool IsEmpty() const { return definitions_.empty(); }
+  // Remove all the command definitions from the dictionary.
+  void Clear();
+  // Finds a definition for the given command.
+  const CommandDefinition* FindCommand(const std::string& command_name) const;
+
+ private:
+  using CommandMap = std::map<std::string,
+                              std::shared_ptr<const CommandDefinition>>;
+
+  CommandMap definitions_;  // List of all available command definitions.
+  DISALLOW_COPY_AND_ASSIGN(CommandDictionary);
+};
+
+}  // namespace buffet
+
+#endif  // BUFFET_COMMANDS_COMMAND_DICTIONARY_H_
diff --git a/buffet/commands/command_dictionary_unittest.cc b/buffet/commands/command_dictionary_unittest.cc
new file mode 100644
index 0000000..f345019
--- /dev/null
+++ b/buffet/commands/command_dictionary_unittest.cc
@@ -0,0 +1,97 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <gtest/gtest.h>
+
+#include "buffet/commands/command_dictionary.h"
+#include "buffet/commands/unittest_utils.h"
+
+using buffet::unittests::CreateDictionaryValue;
+
+TEST(CommandDictionary, Empty) {
+  buffet::CommandDictionary dict;
+  EXPECT_TRUE(dict.IsEmpty());
+  EXPECT_EQ(nullptr, dict.FindCommand("robot.jump"));
+  EXPECT_TRUE(dict.GetCommandNamesByCategory("robotd").empty());
+}
+
+TEST(CommandDictionary, LoadCommands) {
+  auto json = CreateDictionaryValue(R"({
+    'robot': {
+      'jump': {
+        'parameters': {
+          'height': 'integer',
+          '_jumpType': ['_withAirFlip', '_withSpin', '_withKick']
+        }
+      }
+    }
+  })");
+  buffet::CommandDictionary dict;
+  EXPECT_TRUE(dict.LoadCommands(*json, "robotd", nullptr));
+  EXPECT_EQ(1, dict.GetSize());
+  EXPECT_NE(nullptr, dict.FindCommand("robot.jump"));
+  json = CreateDictionaryValue(R"({
+    'base': {
+      'reboot': {
+        'parameters': {'delay': 'integer'}
+      },
+      'shutdown': {
+        'parameters': {}
+      }
+    }
+  })");
+  EXPECT_TRUE(dict.LoadCommands(*json, "powerd", nullptr));
+  EXPECT_EQ(3, dict.GetSize());
+  EXPECT_NE(nullptr, dict.FindCommand("robot.jump"));
+  EXPECT_NE(nullptr, dict.FindCommand("base.reboot"));
+  EXPECT_NE(nullptr, dict.FindCommand("base.shutdown"));
+  EXPECT_EQ(nullptr, dict.FindCommand("foo.bar"));
+  std::vector<std::string> expected_commands{"base.reboot", "base.shutdown"};
+  EXPECT_EQ(expected_commands, dict.GetCommandNamesByCategory("powerd"));
+}
+
+TEST(CommandDictionary, LoadCommands_Failures) {
+  buffet::CommandDictionary dict;
+  buffet::ErrorPtr error;
+
+  // Command definition missing 'parameters' property.
+  auto json = CreateDictionaryValue("{'robot':{'jump':{}}}");
+  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", &error));
+  EXPECT_EQ("parameter_missing", error->GetCode());
+  EXPECT_EQ("Command definition 'robot.jump' is missing property 'parameters'",
+            error->GetMessage());
+  error.reset();
+
+  // Command definition is not an object.
+  json = CreateDictionaryValue("{'robot':{'jump':0}}");
+  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", &error));
+  EXPECT_EQ("type_mismatch", error->GetCode());
+  EXPECT_EQ("Expecting an object for command 'jump'", error->GetMessage());
+  error.reset();
+
+  // Package definition is not an object.
+  json = CreateDictionaryValue("{'robot':'blah'}");
+  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", &error));
+  EXPECT_EQ("type_mismatch", error->GetCode());
+  EXPECT_EQ("Expecting an object for package 'robot'", error->GetMessage());
+  error.reset();
+
+  // Invalid command definition is not an object.
+  json = CreateDictionaryValue("{'robot':{'jump':{'parameters':{'flip':0}}}}");
+  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", &error));
+  EXPECT_EQ("invalid_object_schema", error->GetCode());
+  EXPECT_EQ("Invalid definition for command 'robot.jump'", error->GetMessage());
+  EXPECT_NE(nullptr, error->GetInnerError());  // Must have additional info.
+  error.reset();
+
+  // Redefine commands in different category.
+  json = CreateDictionaryValue("{'robot':{'jump':{'parameters':{}}}}");
+  dict.Clear();
+  dict.LoadCommands(*json, "category1", &error);
+  EXPECT_FALSE(dict.LoadCommands(*json, "category2", &error));
+  EXPECT_EQ("duplicate_command_definition", error->GetCode());
+  EXPECT_EQ("Definition for command 'robot.jump' overrides an earlier "
+            "definition in category 'category1'", error->GetMessage());
+  error.reset();
+}
diff --git a/buffet/commands/command_manager.cc b/buffet/commands/command_manager.cc
new file mode 100644
index 0000000..fc04b2d
--- /dev/null
+++ b/buffet/commands/command_manager.cc
@@ -0,0 +1,13 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "buffet/commands/command_manager.h"
+
+namespace buffet {
+
+const CommandDictionary& CommandManager::GetCommandDictionary() const {
+  return dictionary_;
+}
+
+}  // namespace buffet
diff --git a/buffet/commands/command_manager.h b/buffet/commands/command_manager.h
new file mode 100644
index 0000000..1700712
--- /dev/null
+++ b/buffet/commands/command_manager.h
@@ -0,0 +1,31 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BUFFET_COMMANDS_COMMAND_MANAGER_H_
+#define BUFFET_COMMANDS_COMMAND_MANAGER_H_
+
+#include <base/basictypes.h>
+
+#include "buffet/commands/command_dictionary.h"
+
+namespace buffet {
+
+// CommandManager class that will have a list of all the device command
+// schemas as well as the live command queue of pending command instances
+// dispatched to the device.
+class CommandManager {
+ public:
+  CommandManager() = default;
+
+  // Get the command definitions for the device.
+  const CommandDictionary& GetCommandDictionary() const;
+
+ private:
+  CommandDictionary dictionary_;  // Command definitions/schemas.
+  DISALLOW_COPY_AND_ASSIGN(CommandManager);
+};
+
+}  // namespace buffet
+
+#endif  // BUFFET_COMMANDS_COMMAND_MANAGER_H_
diff --git a/buffet/commands/command_manager_unittest.cc b/buffet/commands/command_manager_unittest.cc
new file mode 100644
index 0000000..1a0bfec
--- /dev/null
+++ b/buffet/commands/command_manager_unittest.cc
@@ -0,0 +1,12 @@
+// Copyright 2014 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <gtest/gtest.h>
+
+#include "buffet/commands/command_manager.h"
+
+TEST(CommandManager, Empty) {
+  buffet::CommandManager manager;
+  EXPECT_TRUE(manager.GetCommandDictionary().IsEmpty());
+}
diff --git a/buffet/commands/schema_constants.cc b/buffet/commands/schema_constants.cc
index d8ec689..6504c5d 100644
--- a/buffet/commands/schema_constants.cc
+++ b/buffet/commands/schema_constants.cc
@@ -20,6 +20,7 @@
 const char kPropertyMissing[] = "parameter_missing";
 const char kUnknownProperty[] = "unexpected_parameter";
 const char kInvalidObjectSchema[] = "invalid_object_schema";
+const char kDuplicateCommandDef[] = "duplicate_command_definition";
 }  // namespace errors
 
 namespace attributes {
@@ -37,6 +38,8 @@
 const char kOneOf_MetaSchema[] = "schema";
 
 const char kObject_Properties[] = "properties";
+
+const char kCommand_Parameters[] = "parameters";
 }  // namespace attributes
 
 }  // namespace commands
diff --git a/buffet/commands/schema_constants.h b/buffet/commands/schema_constants.h
index 087f53b..d709e59 100644
--- a/buffet/commands/schema_constants.h
+++ b/buffet/commands/schema_constants.h
@@ -23,6 +23,7 @@
 extern const char kPropertyMissing[];
 extern const char kUnknownProperty[];
 extern const char kInvalidObjectSchema[];
+extern const char kDuplicateCommandDef[];
 }  // namespace errors
 
 namespace attributes {
@@ -41,6 +42,8 @@
 extern const char kOneOf_MetaSchema[];
 
 extern const char kObject_Properties[];
+
+extern const char kCommand_Parameters[];
 }  // namespace attributes
 
 }  // namespace commands
diff --git a/buffet/commands/unittest_utils.h b/buffet/commands/unittest_utils.h
index e14e4d1..665a2d1 100644
--- a/buffet/commands/unittest_utils.h
+++ b/buffet/commands/unittest_utils.h
@@ -16,7 +16,7 @@
 // Helper method to create base::Value from a string as a smart pointer.
 // For ease of definition in C++ code, double-quotes in the source definition
 // are replaced with apostrophes.
-  std::unique_ptr<base::Value> CreateValue(const char* json);
+std::unique_ptr<base::Value> CreateValue(const char* json);
 
 // Helper method to create a JSON dictionary object from a string.
 std::unique_ptr<base::DictionaryValue> CreateDictionaryValue(const char* json);