diff --git a/configure.ac b/configure.ac
index b48c5c0761fa09..9c060bf0b7bb7b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2231,6 +2231,8 @@ src/inet/Makefile
 src/inet/tests/Makefile
 src/lib/Makefile
 src/lib/core/tests/Makefile
+src/lib/datamodel/Makefile
+src/lib/datamodel/tests/Makefile
 src/lib/shell/Makefile
 src/lib/shell/tests/Makefile
 src/lib/support/Makefile
diff --git a/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp b/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp
index 1428c770658635..43a7a83c7a163b 100644
--- a/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp
+++ b/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp
@@ -25,6 +25,7 @@
 
 #include "EchoDeviceCallbacks.h"
 #include "esp_log.h"
+#include <lib/datamodel/ClusterServer.h>
 #include <platform/CHIPDeviceLayer.h>
 #include <support/CodeUtils.h>
 
@@ -34,6 +35,7 @@
 static const char * TAG = "echo-devicecallbacks";
 using namespace ::chip::Inet;
 using namespace ::chip::DeviceLayer;
+using namespace ::chip::DataModel;
 
 extern LEDWidget statusLED; // In wifi-echo.cpp
 
@@ -70,22 +72,17 @@ void EchoDeviceCallbacks::DeviceEventCallback(const ChipDeviceEvent * event, int
     }
 }
 
+extern ClusterServer server;
+/* This function can be eliminated, and instead its contents will get executed */
 void EchoDeviceCallbacks::PostAttributeChangeCallback(uint8_t endpoint, ChipZclClusterId clusterId, ChipZclAttributeId attributeId,
                                                       uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size,
                                                       uint8_t * value)
 {
-    if (clusterId != CHIP_ZCL_CLUSTER_ON_OFF)
-    {
-        ESP_LOGI(TAG, "Unknown cluster ID: %d", clusterId);
-        return;
-    }
-
-    if (attributeId != CHIP_ZCL_CLUSTER_ON_OFF_SERVER_ATTRIBUTE_ON_OFF)
-    {
-        ESP_LOGI(TAG, "Unknown attribute ID: %d", attributeId);
-        return;
-    }
-    ESP_LOGI(TAG, "Got the post attribute callback");
     // At this point we can assume that value points to a boolean value.
-    statusLED.Set(*value);
+    printf("endpoint: %d, clusterId: %d, attrId: %d type: %d\n", endpoint, clusterId, attributeId, type);
+    Value cValue(kCHIPValueType_Bool);
+    memcpy((void *) &cValue.Int64, (void *) value, size);
+    printf("Value is %lld type is %d\n", cValue.Int64, type);
+
+    server.SetValue(endpoint, clusterId, attributeId, cValue);
 }
diff --git a/examples/wifi-echo/server/esp32/main/LEDWidget.cpp b/examples/wifi-echo/server/esp32/main/LEDWidget.cpp
index 502a4b0a4f1899..0540d0fbe23cc2 100644
--- a/examples/wifi-echo/server/esp32/main/LEDWidget.cpp
+++ b/examples/wifi-echo/server/esp32/main/LEDWidget.cpp
@@ -31,6 +31,7 @@
 #include "esp_log.h"
 #include "esp_system.h"
 #include "esp_timer.h"
+#include <lib/datamodel/ClusterOnOff.h>
 
 #if CONFIG_HAVE_DISPLAY
 // The Y position of the LED Status message on screen as a
@@ -46,7 +47,7 @@ static const char * onMsg  = "LIGHT: ON";
 static const char * offMsg = "LIGHT: OFF";
 
 #endif
-
+using namespace ::chip::DataModel;
 extern const char * TAG;
 
 void LEDWidget::Init(gpio_num_t gpioNum)
@@ -71,6 +72,19 @@ void LEDWidget::Set(bool state)
 {
     mBlinkOnTimeMS = mBlinkOffTimeMS = 0;
     DoSet(state);
+    Cluster::Set(kAttributeIdOnOff, ValueBool(state));
+}
+
+CHIP_ERROR LEDWidget::Set(uint16_t attrId, const Value & value)
+{
+    if (attrId == kAttributeIdOnOff)
+    {
+        printf("Setting value to %d\n", ValueToBool(value));
+        DoSet(ValueToBool(value));
+        /* Update our internal data model as well */
+        Cluster::Set(attrId, value);
+    }
+    return CHIP_NO_ERROR;
 }
 
 void LEDWidget::Blink(uint32_t changeRateMS)
diff --git a/examples/wifi-echo/server/esp32/main/include/LEDWidget.h b/examples/wifi-echo/server/esp32/main/include/LEDWidget.h
index 9941845adfd61c..f9e815ac390de9 100644
--- a/examples/wifi-echo/server/esp32/main/include/LEDWidget.h
+++ b/examples/wifi-echo/server/esp32/main/include/LEDWidget.h
@@ -27,12 +27,14 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/timers.h"
+#include <lib/datamodel/ClusterOnOff.h>
 
-class LEDWidget
+class LEDWidget : public chip::DataModel::ClusterOnOff
 {
 public:
     void Init(gpio_num_t gpioNum);
     void Set(bool state);
+    int Set(uint16_t attrId, const chip::DataModel::Value & value);
     void Blink(uint32_t changeRateMS);
     void Blink(uint32_t onTimeMS, uint32_t offTimeMS);
     void BlinkOnError();
diff --git a/examples/wifi-echo/server/esp32/main/wifi-echo.cpp b/examples/wifi-echo/server/esp32/main/wifi-echo.cpp
index 3410e1d12dd3db..69d83bd0aa8179 100644
--- a/examples/wifi-echo/server/esp32/main/wifi-echo.cpp
+++ b/examples/wifi-echo/server/esp32/main/wifi-echo.cpp
@@ -42,6 +42,7 @@
 #include <vector>
 
 #include <crypto/CHIPCryptoPAL.h>
+#include <lib/datamodel/ClusterServer.h>
 #include <platform/CHIPDeviceLayer.h>
 #include <setup_payload/QRCodeSetupPayloadGenerator.h>
 #include <support/ErrorStr.h>
@@ -49,6 +50,7 @@
 
 using namespace ::chip;
 using namespace ::chip::DeviceLayer;
+using namespace ::chip::DataModel;
 
 extern void startServer();
 
@@ -104,6 +106,11 @@ LEDWidget statusLED;
 const char * TAG = "wifi-echo-demo";
 
 static EchoDeviceCallbacks EchoCallbacks;
+const uint8_t ZCLVersion         = 10;
+const uint8_t applicationVersion = 20;
+const uint8_t stackVersion       = 1;
+const uint8_t HWVersion          = 1;
+ClusterServer server(ZCLVersion, applicationVersion, stackVersion, HWVersion);
 
 namespace {
 
@@ -111,37 +118,37 @@ std::vector<Button> buttons          = { Button(), Button(), Button() };
 std::vector<gpio_num_t> button_gpios = { BUTTON_1_GPIO_NUM, BUTTON_2_GPIO_NUM, BUTTON_3_GPIO_NUM };
 
 // Pretend these are devices with endpoints with clusters with attributes
-typedef std::tuple<std::string, std::string> Attribute;
-typedef std::vector<Attribute> Attributes;
-typedef std::tuple<std::string, Attributes> Cluster;
-typedef std::vector<Cluster> Clusters;
-typedef std::tuple<std::string, Clusters> Endpoint;
-typedef std::vector<Endpoint> Endpoints;
-typedef std::tuple<std::string, Endpoints> Device;
+typedef std::tuple<std::string, std::string> AppAttribute;
+typedef std::vector<AppAttribute> AppAttributes;
+typedef std::tuple<std::string, AppAttributes> AppCluster;
+typedef std::vector<AppCluster> AppClusters;
+typedef std::tuple<std::string, AppClusters> AppEndpoint;
+typedef std::vector<AppEndpoint> AppEndpoints;
+typedef std::tuple<std::string, AppEndpoints> Device;
 typedef std::vector<Device> Devices;
 Devices devices;
 
 void AddAttribute(std::string name, std::string value)
 {
-    Attribute attribute = std::make_tuple(std::move(name), std::move(value));
+    AppAttribute attribute = std::make_tuple(std::move(name), std::move(value));
     std::get<1>(std::get<1>(std::get<1>(devices.back()).back()).back()).emplace_back(std::move(attribute));
 }
 
 void AddCluster(std::string name)
 {
-    Cluster cluster = std::make_tuple(std::move(name), std::move(Attributes()));
+    AppCluster cluster = std::make_tuple(std::move(name), std::move(AppAttributes()));
     std::get<1>(std::get<1>(devices.back()).back()).emplace_back(std::move(cluster));
 }
 
 void AddEndpoint(std::string name)
 {
-    Endpoint endpoint = std::make_tuple(std::move(name), std::move(Clusters()));
+    AppEndpoint endpoint = std::make_tuple(std::move(name), std::move(AppClusters()));
     std::get<1>(devices.back()).emplace_back(std::move(endpoint));
 }
 
 void AddDevice(std::string name)
 {
-    Device device = std::make_tuple(std::move(name), std::move(Endpoints()));
+    Device device = std::make_tuple(std::move(name), std::move(AppEndpoints()));
     devices.emplace_back(std::move(device));
 }
 
@@ -352,6 +359,30 @@ std::string createSetupPayload()
 
 } // namespace
 
+void PrintDataModel(ClusterServer & server)
+{
+    printf("Server:\n");
+    int endpointId = 1;
+
+    /* Endpoints */
+    server.mEndpoints.Foreach([&endpointId](Endpoint * endpoint) -> void {
+        printf("  EndPoint: %d\n", endpointId++);
+
+        /* Clusters */
+        endpoint->mClusters.Foreach([](Cluster * cluster) -> void {
+            printf("    ClusterId: 0x%04x\n", cluster->mClusterId);
+
+            /* Attributes */
+            cluster->mAttrs.Foreach([](Attribute * attr) -> void {
+                printf("      Attribute: 0x%04x\n", attr->mAttrId);
+                char printstr[20];
+                attr->mValue.ValueToStr(printstr, sizeof(printstr));
+                printf("              Value: %s\n", printstr);
+            });
+        });
+    });
+}
+
 extern "C" void app_main()
 {
     ESP_LOGI(TAG, "WiFi Echo Demo!");
@@ -396,6 +427,10 @@ extern "C" void app_main()
 
     statusLED.Init(STATUS_LED_GPIO_NUM);
 
+    /* Add a cluster to the primary endpoint of our cluster server */
+    server.AddCluster(&statusLED);
+    PrintDataModel(server);
+
     // Start the Echo Server
     InitDataModelHandler();
     startServer();
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index eed6946b89f5f1..6d4d4213e277d9 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -27,6 +27,7 @@ SUBDIRS                             =                         \
     shell                                                     \
     support                                                   \
     core/tests                                                \
+    datamodel                                                 \
     $(NULL)
 
 # Pull in the sources that comprise the CHIP library.
@@ -37,6 +38,7 @@ include ../inet/InetLayer.am
 include ../system/SystemLayer.am
 include ../transport/TransportLayer.am
 include core/CoreLayer.am
+include datamodel/DataModel.am
 include support/SupportLayer.am
 include profiles/ProfilesLayer.am
 include ../crypto/Crypto.am
@@ -46,6 +48,10 @@ include ../app/DataModel.am
 CoreLayer_dir=$(includedir)/core
 dist_CoreLayer__HEADERS=$(CHIP_BUILD_CORE_LAYER_HEADER_FILES)
 
+# install headers for datamodel layer
+DataModel_dir=$(includedir)/datamodel
+dist_DataModel__HEADERS=$(CHIP_BUILD_DATAMODEL_HEADER_FILES)
+
 # install headers for DeviceController
 Controller_dir=$(includedir)/controller
 dist_Controller__HEADERS=$(CHIP_BUILD_DEVICE_CONTROLLER_HEADER_FILES)
@@ -73,6 +79,7 @@ libCHIP_a_CPPFLAGS                  =                         \
 libCHIP_a_SOURCES                   = $(CHIP_BUILD_SYSTEM_LAYER_SOURCE_FILES)
 libCHIP_a_SOURCES                  += $(CHIP_BUILD_INET_LAYER_SOURCE_FILES)
 libCHIP_a_SOURCES                  += $(CHIP_BUILD_CORE_LAYER_SOURCE_FILES)
+libCHIP_a_SOURCES                  += $(CHIP_BUILD_DATAMODEL_SOURCE_FILES)
 libCHIP_a_SOURCES                  += $(CHIP_BUILD_SUPPORT_LAYER_SOURCE_FILES)
 libCHIP_a_SOURCES                  += $(CHIP_BUILD_DEVICE_CONTROLLER_SOURCE_FILES)
 libCHIP_a_SOURCES                  += $(CHIP_BUILD_DATA_MODEL_SOURCE_FILES)
diff --git a/src/lib/datamodel/Attribute.h b/src/lib/datamodel/Attribute.h
new file mode 100644
index 00000000000000..c27923c6497d2f
--- /dev/null
+++ b/src/lib/datamodel/Attribute.h
@@ -0,0 +1,117 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file contains definitions for working with CHIP values.
+ *
+ */
+
+#ifndef CHIP_ATTRIBUTE_H_
+#define CHIP_ATTRIBUTE_H_
+
+#include <datamodel/Deque.h>
+#include <datamodel/Value.h>
+
+#include <core/CHIPError.h>
+
+namespace chip {
+namespace DataModel {
+
+/**
+ * @brief
+ *   This class implements a single attribute.
+ */
+class Attribute
+{
+private:
+    Deque<Attribute> mDeque;
+    friend class Cluster;
+
+public:
+    uint16_t mAttrId;
+    Value mValue;
+    Value mMin;
+    Value mMax;
+
+    Attribute(uint16_t attrId, ValueTypes type) : mDeque(this), mAttrId(attrId), mValue(type), mMin(type), mMax(type) {}
+    Attribute(uint16_t attrId, Value value) : mDeque(this), mAttrId(attrId), mValue(value), mMin(value.mType), mMax(value.mType) {}
+    Attribute(uint16_t attrId, ValueTypes type, uint64_t min, uint64_t max) :
+        mDeque(this), mAttrId(attrId), mValue(type), mMin(type, min), mMax(type, max)
+    {}
+
+    /**
+     * @brief
+     *   Set this attribute to a value
+     *
+     * @param value  the new value that this attribute should be updated with
+     */
+    CHIP_ERROR Set(const Value & newValue)
+    {
+        /* We have to check the element type match in this case */
+        if (mValue.mType != newValue.mType)
+        {
+            return CHIP_ERROR_INTERNAL;
+        }
+        if (withinRange(newValue))
+        {
+            mValue = newValue;
+            return CHIP_NO_ERROR;
+        }
+        return CHIP_ERROR_INTERNAL;
+    }
+
+    /* Need to define the behaviour when Value contains pointers
+     * to allocated data
+     */
+    /**
+     * @brief
+     *   Get the value of this attribute
+     *
+     */
+    Value Get() { return mValue; }
+
+protected:
+    bool withinRange(const uint64_t & value) { return (value >= mMin.Int64) && (value <= mMax.Int64); }
+
+    bool withinRange(const Value value)
+    {
+        switch (mValue.mType)
+        {
+        case kCHIPValueType_Int8:
+        case kCHIPValueType_Int16:
+        case kCHIPValueType_Int32:
+        case kCHIPValueType_Int64:
+        case kCHIPValueType_UInt8:
+        case kCHIPValueType_UInt16:
+        case kCHIPValueType_UInt32:
+        case kCHIPValueType_UInt64:
+            return withinRange(value.Int64);
+            break;
+        case kCHIPValueType_Bool:
+            return true;
+        default:
+            return false;
+        }
+        return false;
+    }
+};
+
+} // namespace DataModel
+} // namespace chip
+
+#endif /* CHIP_ATTRIBUTE_H_ */
diff --git a/src/lib/datamodel/Cluster.h b/src/lib/datamodel/Cluster.h
new file mode 100644
index 00000000000000..1ecd813ef6e03f
--- /dev/null
+++ b/src/lib/datamodel/Cluster.h
@@ -0,0 +1,93 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file contains base class for CHIP Clusters
+ *
+ */
+
+#ifndef CHIPBASECLUSTER_H_
+#define CHIPBASECLUSTER_H_
+
+#include <datamodel/Attribute.h>
+#include <datamodel/Deque.h>
+
+namespace chip {
+namespace DataModel {
+
+/**
+ * @brief
+ *   This class implements the cluster object that maintains its attributes. Typically specific
+ *   cluster definitions will derive from this class and implement their functionality.
+ */
+class Cluster : public Deque<Cluster>
+{
+public:
+    uint16_t mClusterId;
+    Deque<Attribute> mAttrs;
+
+    Cluster(uint16_t clusterId) : Deque(this), mClusterId(clusterId), mAttrs(nullptr) {}
+
+    virtual ~Cluster() {}
+
+    /**
+     * @brief
+     *   Add attributes to this cluster
+     *
+     * @param attr Pointer to the attribute object being added
+     */
+    CHIP_ERROR AddAttribute(Attribute * attr)
+    {
+        mAttrs.Insert(&attr->mDeque);
+        return CHIP_NO_ERROR;
+    }
+
+    /**
+     * @brief
+     *   Get pointer to the attribute object
+     *
+     * @param attrId the attribute identifer that we are looking for
+     */
+    Attribute * GetAttribute(uint16_t attrId)
+    {
+        return mAttrs.Find([attrId](Attribute * item) -> bool { return (item->mAttrId == attrId); });
+    }
+
+    /**
+     * @brief
+     *   Set an attribute to a value
+     *
+     * @param attrId the attribute identifer that should be set
+     * @param value  the new value that the attribute should be updated with
+     */
+    virtual CHIP_ERROR Set(uint16_t attrId, const Value & value)
+    {
+        /* Just hand-off to update the value internally */
+        auto attr = GetAttribute(attrId);
+        if (attr != nullptr)
+        {
+            return attr->Set(value);
+        }
+        return CHIP_ERROR_INTERNAL;
+    }
+};
+
+} // namespace DataModel
+} // namespace chip
+
+#endif /* CHIPBASECLUSTER_H_ */
diff --git a/src/lib/datamodel/ClusterBasic.h b/src/lib/datamodel/ClusterBasic.h
new file mode 100644
index 00000000000000..3f535d985b4d1c
--- /dev/null
+++ b/src/lib/datamodel/ClusterBasic.h
@@ -0,0 +1,71 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file contains definitions for CHIP Cluster Basic
+ *
+ */
+
+#ifndef CHIPCLUSTERBASIC_H_
+#define CHIPCLUSTERBASIC_H_
+
+#include <datamodel/Cluster.h>
+
+namespace chip {
+namespace DataModel {
+
+/* Cluster ID */
+static const uint16_t kClusterIdBase = 0x0000;
+
+/* Attribute IDs */
+static const uint16_t kAttributeIdZCLVersion         = 0x0000;
+static const uint16_t kAttributeIdApplicationVersion = 0x0001;
+static const uint16_t kAttributeIdStackVersion       = 0x0002;
+static const uint16_t kAttributeIdHWVersion          = 0x0003;
+
+/**
+ * @brief
+ *   This class implements the Base cluster as defined in the CHIP specification.
+ */
+class ClusterBasic : public Cluster
+{
+private:
+    Attribute mZCLVersion;
+    Attribute mApplicationVersion;
+    Attribute mStackVersion;
+    Attribute mHWVersion;
+
+public:
+    ClusterBasic(uint8_t ZCLVersion, uint8_t applicationVersion, uint8_t stackVersion, uint8_t HWVersion) :
+        Cluster(kClusterIdBase),
+        /* Attributes */
+        mZCLVersion(kAttributeIdZCLVersion, ValueUInt8(ZCLVersion)),
+        mApplicationVersion(kAttributeIdApplicationVersion, ValueUInt8(applicationVersion)),
+        mStackVersion(kAttributeIdStackVersion, ValueUInt8(stackVersion)), mHWVersion(kAttributeIdHWVersion, ValueUInt8(HWVersion))
+    {
+        AddAttribute(&mZCLVersion);
+        AddAttribute(&mApplicationVersion);
+        AddAttribute(&mStackVersion);
+        AddAttribute(&mHWVersion);
+    }
+};
+
+} // namespace DataModel
+} // namespace chip
+
+#endif /* CHIPCLUSTERBASIC_H_ */
diff --git a/src/lib/datamodel/ClusterOnOff.h b/src/lib/datamodel/ClusterOnOff.h
new file mode 100644
index 00000000000000..1d598911bf886a
--- /dev/null
+++ b/src/lib/datamodel/ClusterOnOff.h
@@ -0,0 +1,70 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file contains definitions for CHIP Cluster OnOff
+ *
+ */
+
+#ifndef CHIPCLUSTERONOFF_H_
+#define CHIPCLUSTERONOFF_H_
+
+#include <datamodel/Cluster.h>
+
+namespace chip {
+namespace DataModel {
+
+/* Cluster ID */
+static const uint16_t kClusterIdOnOff = 0x0006;
+
+/* Attribute IDs */
+static const uint16_t kAttributeIdOnOff              = 0x0000;
+static const uint16_t kAttributeIdGlobalSceneControl = 0x4000;
+static const uint16_t kAttributeIdOnTime             = 0x4001;
+static const uint16_t kAttributeIdOffWaitTime        = 0x4002;
+
+/**
+ * @brief
+ *   This class implements the OnOff cluster as defined in the CHIP specification.
+ */
+class ClusterOnOff : public Cluster
+{
+    // TODO: these should
+private:
+    Attribute mOnOff;
+    Attribute mGlobalSceneControl;
+    Attribute mOnTime;
+    Attribute mOffWaitTime;
+
+public:
+    ClusterOnOff() :
+        Cluster(kClusterIdOnOff), mOnOff(kAttributeIdOnOff, kCHIPValueType_Bool),
+        mGlobalSceneControl(kAttributeIdGlobalSceneControl, kCHIPValueType_Bool),
+        mOnTime(kAttributeIdOnTime, kCHIPValueType_UInt16), mOffWaitTime(kAttributeIdOffWaitTime, kCHIPValueType_UInt16)
+    {
+        AddAttribute(&mOnOff);
+        AddAttribute(&mGlobalSceneControl);
+        AddAttribute(&mOnTime);
+        AddAttribute(&mOffWaitTime);
+    }
+};
+
+} // namespace DataModel
+} // namespace chip
+
+#endif /* CHIPCLUSTERONOFF_H_ */
diff --git a/src/lib/datamodel/ClusterServer.h b/src/lib/datamodel/ClusterServer.h
new file mode 100644
index 00000000000000..05ed63d4c8a863
--- /dev/null
+++ b/src/lib/datamodel/ClusterServer.h
@@ -0,0 +1,192 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file contains the Cluster Server class. The Cluster Server maintains all the cluster
+ *      servers that this devices exposes.
+ *
+ */
+
+#ifndef CHIPCLUSTERSERVER_H_
+#define CHIPCLUSTERSERVER_H_
+
+#include <datamodel/Deque.h>
+#include <datamodel/Endpoint.h>
+
+namespace chip {
+namespace DataModel {
+
+/**
+ * @brief
+ *   This class implements the Cluster Server that maintains all the server endpoints of this
+ *   device.
+ */
+class ClusterServer
+{
+public:
+    Endpoint mEndpoints;
+
+    ClusterServer(uint8_t ZCLVersion, uint8_t applicationVersion, uint8_t stackVersion, uint8_t HWVersion) :
+        mEndpoints(ZCLVersion, applicationVersion, stackVersion, HWVersion)
+    {}
+
+    virtual ~ClusterServer() {}
+
+    /**
+     * @brief
+     *   Add clusters to endpointId 1 of this Cluster Server
+     *
+     * @param cluster Pointer to the cluster object being added
+     */
+    CHIP_ERROR AddCluster(Cluster * cluster) { return mEndpoints.AddCluster(cluster); }
+
+    /**
+     * @brief
+     *   Add a new endpoint to this Cluster Server
+     *
+     * @param cluster Pointer to the endpoint object being added
+     */
+    CHIP_ERROR AddEndpoint(Endpoint * endpoint)
+    {
+        mEndpoints.Insert(endpoint);
+        return CHIP_NO_ERROR;
+    }
+
+    /**
+     * @brief
+     *   Retrieve a pointer to the corresponding Endpoint, if any
+     *
+     * @param endpointId the index of the desired Endpoint
+     * @return pointer to the Endpoint or null if not found
+     */
+    Endpoint * GetEndpoint(uint8_t endpointId)
+    {
+        /* Endpoint #0 is reserved, until we handle that properly, we will offset everything by 1 */
+        endpointId--;
+        auto * p = mEndpoints.Find([&endpointId](Endpoint * item) -> bool { return (endpointId-- == 0); });
+        return p;
+    }
+
+    /**
+     * @brief
+     *   Retrieve a pointer to the corresponding Cluster, if any
+     *
+     * @param endpointId the index of the Endpoint with the Cluster
+     * @param clusterId the id of desired Cluster
+     *
+     * @return pointer to the Cluster or null if not found
+     */
+    Cluster * GetCluster(uint8_t endPointId, uint16_t clusterId)
+    {
+        Cluster * cluster = nullptr;
+
+        auto endpoint = GetEndpoint(endPointId);
+        if (endpoint != nullptr)
+        {
+            cluster = endpoint->GetCluster(clusterId);
+        }
+        return cluster;
+    }
+
+    /**
+     * @brief
+     *   Retrieve a pointer to the corresponding Attribute, if any
+     *
+     * @param endpointId the index of the desired Endpoint
+     * @param clusterId the id of desired Cluster
+     * @param attrId the id of desired Attribute
+     *
+     * @return pointer to the Attribute or null if not found
+     */
+    Attribute * GetAttribute(uint8_t endPointId, uint16_t clusterId, uint16_t attrId)
+    {
+        Attribute * attr = nullptr;
+
+        auto cluster = GetCluster(endPointId, clusterId);
+        if (cluster != nullptr)
+        {
+            attr = cluster->GetAttribute(attrId);
+        }
+        return attr;
+    }
+
+    /**
+     * @brief
+     *   Find and set an Attribute's Value
+     *
+     * @param endpointId the index of the desired Endpoint
+     * @param clusterId the id of desired Cluster
+     * @param attrId the id of desired Attribute
+     * @param value the Value to set
+     *
+     * @return CHIP_NO_ERROR on success or a failure-specific error code otherwise
+     */
+    CHIP_ERROR SetValue(uint8_t endPointId, uint16_t clusterId, uint16_t attrId, Value & value)
+    {
+        auto endpoint = GetEndpoint(endPointId);
+
+        if (endpoint != nullptr)
+        {
+            auto cluster = endpoint->GetCluster(clusterId);
+
+            if (cluster != nullptr)
+            {
+                return cluster->Set(attrId, value);
+            }
+        }
+        return CHIP_ERROR_INTERNAL;
+    }
+
+    /**
+     * @brief
+     *   Find and read an Attribute's Value
+     *
+     * @param endpointId the index of the desired Endpoint
+     * @param clusterId the id of desired Cluster
+     * @param attrId the id of desired Attribute
+     * @param value the Value to populate with the Attribute's value
+     *
+     * @return CHIP_NO_ERROR on success or a failure-specific error code otherwise
+     */
+    CHIP_ERROR GetValue(uint8_t endPointId, uint16_t clusterId, uint16_t attrId, Value & value)
+    {
+        auto endpoint = GetEndpoint(endPointId);
+
+        if (endpoint != nullptr)
+        {
+            auto cluster = endpoint->GetCluster(clusterId);
+
+            if (cluster != nullptr)
+            {
+                auto attr = cluster->GetAttribute(attrId);
+
+                if (attr != nullptr)
+                {
+                    value = attr->mValue;
+                    return CHIP_NO_ERROR;
+                }
+            }
+        }
+        return CHIP_ERROR_INTERNAL;
+    }
+};
+
+} // namespace DataModel
+} // namespace chip
+
+#endif /* CHIPCLUSTERSERVER_H_ */
diff --git a/src/lib/datamodel/DataModel.am b/src/lib/datamodel/DataModel.am
new file mode 100644
index 00000000000000..e2856c5dffdd3e
--- /dev/null
+++ b/src/lib/datamodel/DataModel.am
@@ -0,0 +1,39 @@
+#
+#    Copyright (c) 2020 Project CHIP Authors
+#
+#    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.
+#
+
+#
+#    Description:
+#      This file is the GNU automake template for the CHIP 
+#      library DataModel sources.
+#
+#      These sources are shared by other SDK makefiles and consequently
+#      must be anchored relative to the top build directory.
+#
+
+CHIP_BUILD_DATAMODEL_SOURCE_FILES                         = \
+    @top_builddir@/src/lib/datamodel/Endpoint.cpp       \
+    $(NULL)
+
+CHIP_BUILD_DATAMODEL_HEADER_FILES                              = \
+    @top_builddir@/src/lib/datamodel/Attribute.h         \
+    @top_builddir@/src/lib/datamodel/Cluster.h           \
+    @top_builddir@/src/lib/datamodel/ClusterServer.h         \
+    @top_builddir@/src/lib/datamodel/Endpoint.h              \
+    @top_builddir@/src/lib/datamodel/Value.h                \
+    @top_builddir@/src/lib/datamodel/Deque.h                \
+    @top_builddir@/src/lib/datamodel/ClusterBasic.h    \
+    @top_builddir@/src/lib/datamodel/ClusterOnOff.h      \
+    $(NULL)
diff --git a/src/lib/datamodel/Deque.h b/src/lib/datamodel/Deque.h
new file mode 100644
index 00000000000000..a44a97df45ae61
--- /dev/null
+++ b/src/lib/datamodel/Deque.h
@@ -0,0 +1,186 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *  @file
+ *    basic double-ended queue.  Two intended use models:
+ *    1. used as a raw templated type
+ *     of an object or used as a base class
+ */
+
+#ifndef CHIP_DEQUE_H
+#define CHIP_DEQUE_H
+
+#include <functional>
+#include <stddef.h>
+
+namespace chip {
+
+/**
+ *  @class Deque
+ *
+ *  embed-able double-ended queue item with a recovery pointer
+ *
+ */
+template <class T>
+class Deque
+{
+
+public:
+    Deque(T * me) : mMe(me) { mNext = mPrev = this; };
+    ~Deque() { Remove(); };
+
+    Deque * Next() { return mNext; }
+    Deque * Prev() { return mPrev; }
+    T * Me() { return mMe; }
+
+    void Remove()
+    {
+        mNext->mPrev = mPrev;
+        mPrev->mNext = mNext;
+        mNext = mPrev = this;
+    }
+
+    /**
+     * @brief iterate over the list, starting from
+     *     this item, until fn() returns true.  Returns
+     *     item->mMe of the match or NULL if no match.
+     *  Mutation of the list during fn() should be avoided
+     */
+    T * Find(std::function<bool(T *)> fn)
+    {
+        Deque * next = nullptr;
+        for (Deque * item = this; next != this; item = next)
+        {
+            next = item->mNext;
+
+            // skip any "head" node we encounter
+            if (item->mMe != nullptr)
+            {
+                if (fn(item->mMe))
+                {
+                    return item->mMe;
+                }
+            }
+            item = next;
+        }
+        return nullptr;
+    }
+
+    /**
+     * @brief iterate over the list, starting from
+     *     this item, until fn() returns true.  Returns
+     *     item->mMe of the match or NULL if no match.
+     *  Mutation of the list during fn() should be avoided
+     */
+    T * FindR(std::function<bool(T *)> fn)
+    {
+        Deque * prev = nullptr;
+        for (Deque * item = mPrev; prev != mPrev; item = prev)
+        {
+            prev = item->mPrev;
+            // skip any "head" node we encounter
+            if (item->mMe != nullptr)
+            {
+                if (fn(item->mMe))
+                {
+                    return item;
+                }
+            }
+            item = prev;
+        }
+    }
+
+    /**
+     * @brief iterate over items in the list, starting from
+     *     this item.
+     *  Mutation of the list during fn() should be avoided
+     */
+    void Foreach(std::function<void(T *)> fn)
+    {
+        Deque * next = nullptr;
+        for (Deque * item = this; next != this; item = next)
+        {
+            next = item->mNext;
+            if (item->mMe != nullptr)
+            {
+                fn(item->mMe);
+            }
+            item = next;
+        }
+    }
+
+    /**
+     * @brief iterate over items in the list, starting from
+     *    the last item
+     *  Mutation of the list during fn() should be avoided
+     */
+    void ForeachR(std::function<void(T *)> fn)
+    {
+        Deque * prev = nullptr;
+        for (Deque * item = mPrev; prev != mPrev; item = prev)
+        {
+            prev = item->mPrev;
+            if (item->mMe != nullptr)
+            {
+                fn(item->mMe);
+            }
+            item = prev;
+        }
+    }
+
+    /**
+     * @brief insert item (might be a list) as this node's
+     *   previous pointer. This is logically equivalent to
+     *   Append() or PushBack() when the subject Deque is
+     *   the head of the list.
+     *
+     * if item is a head pointer, skip the head pointer
+     */
+    void Insert(Deque * item)
+    {
+        if (item->mMe == nullptr)
+        {
+            if (item->mNext == item)
+            {
+                // empty list
+                return;
+            }
+
+            // pull the items off old head
+            Deque * head = item;
+
+            item = item->mNext;
+            head->Remove();
+        }
+        Deque * prev = mPrev; // save off my prev
+
+        prev->mNext  = item;        // last node's next gets item
+        mPrev        = item->mPrev; // back pointer gets end of new list
+        item->mPrev  = prev;        // item's prev gets my last node
+        mPrev->mNext = this;        // fix tail node
+    }
+
+private:
+    Deque * mNext;
+    Deque * mPrev;
+    T * mMe; // when null, is treated as a "head" node
+};
+
+} // namespace chip
+
+#endif /* CHIP_DEQUE */
diff --git a/src/lib/datamodel/Endpoint.cpp b/src/lib/datamodel/Endpoint.cpp
new file mode 100644
index 00000000000000..5fcbbb0f5dd287
--- /dev/null
+++ b/src/lib/datamodel/Endpoint.cpp
@@ -0,0 +1,30 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file implements the Endpoint class
+ *
+ */
+
+#include <datamodel/Endpoint.h>
+
+namespace chip {
+namespace DataModel {
+
+} // namespace DataModel
+} // namespace chip
diff --git a/src/lib/datamodel/Endpoint.h b/src/lib/datamodel/Endpoint.h
new file mode 100644
index 00000000000000..4fe36124e76d87
--- /dev/null
+++ b/src/lib/datamodel/Endpoint.h
@@ -0,0 +1,80 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file contains the Endpoint class
+ *
+ */
+
+#ifndef CHIPENDPOINT_H_
+#define CHIPENDPOINT_H_
+
+#include <datamodel/Attribute.h>
+#include <datamodel/ClusterBasic.h>
+#include <datamodel/Deque.h>
+
+namespace chip {
+namespace DataModel {
+
+/* TODO: To be converted to a template version or Kconfig later on */
+static const uint8_t kMaxClustersPerEndpoint = 5;
+
+/**
+ * @brief
+ *   This class implements the endpoint that maintains all the clusters supported by this endpoint.
+ */
+class Endpoint : public Deque<Endpoint>
+{
+
+public:
+    ClusterBasic mClusters; // head pointer is a BasicCluster
+
+    Endpoint(uint8_t ZCLVersion, uint8_t applicationVersion, uint8_t stackVersion, uint8_t HWVersion) :
+        Deque(this), mClusters(ZCLVersion, applicationVersion, stackVersion, HWVersion)
+    {}
+
+    virtual ~Endpoint() {}
+
+    /**
+     * @brief
+     *   Add clusters to this endpoint
+     *
+     * @param cluster Pointer to the cluster object being added
+     */
+    CHIP_ERROR AddCluster(Cluster * cluster)
+    {
+        mClusters.Insert(cluster);
+        return CHIP_NO_ERROR;
+    }
+
+    /**
+     * @brief
+     *   Get pointer to the cluster object
+     *
+     * @param clusterId the cluster identifer that we are looking for
+     */
+    Cluster * GetCluster(uint8_t clusterId)
+    {
+        return mClusters.Find([clusterId](Cluster * item) -> bool { return (item->mClusterId == clusterId); });
+    }
+};
+
+} // namespace DataModel
+} // namespace chip
+
+#endif /* CHIPENDPOINT_H_ */
diff --git a/src/lib/datamodel/Makefile.am b/src/lib/datamodel/Makefile.am
new file mode 100644
index 00000000000000..23015ba9785ab2
--- /dev/null
+++ b/src/lib/datamodel/Makefile.am
@@ -0,0 +1,48 @@
+#
+#    Copyright (c) 2020 Project CHIP Authors
+#
+#    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.
+#
+
+#
+#    Description:
+#      This file is the GNU automake template for the CHIP system layer
+#      library.
+#
+
+include $(abs_top_nlbuild_autotools_dir)/automake/pre.am
+
+include DataModel.am
+
+SUBDIRS                             = \
+    tests                             \
+    $(NULL)
+
+EXTRA_DIST                          = \
+    $(NULL)
+
+lib_LIBRARIES                       = libDataModel.a
+
+libDataModel_a_CPPFLAGS             = \
+    -I$(top_srcdir)/src               \
+    -I$(top_srcdir)/src/include       \
+    -I$(top_srcdir)/src/lib           \
+    $(NULL)
+
+libDataModel_a_SOURCES          = $(CHIP_BUILD_DATAMODEL_SOURCE_FILES)
+
+libDataModel_adir               = $(includedir)/datamodel
+
+dist_libDataModel_a_HEADERS     = $(CHIP_BUILD_DATAMODEL_HEADER_FILES)
+
+include $(abs_top_nlbuild_autotools_dir)/automake/post.am
diff --git a/src/lib/datamodel/Value.h b/src/lib/datamodel/Value.h
new file mode 100644
index 00000000000000..35137bf1d2abcb
--- /dev/null
+++ b/src/lib/datamodel/Value.h
@@ -0,0 +1,123 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file contains definitions for working with CHIP values.
+ *
+ */
+
+#ifndef CHIP_VALUE_H_
+#define CHIP_VALUE_H_
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+
+namespace chip {
+namespace DataModel {
+
+enum ValueTypes
+{
+    kCHIPValueType_NotSpecified = -1,
+    kCHIPValueType_Int8,
+    kCHIPValueType_Int16,
+    kCHIPValueType_Int32,
+    kCHIPValueType_Int64,
+    kCHIPValueType_UInt8,
+    kCHIPValueType_UInt16,
+    kCHIPValueType_UInt32,
+    kCHIPValueType_UInt64,
+    kCHIPValueType_Bool,
+    kCHIPValueType_FloatingPointNumber32,
+    kCHIPValueType_FloatingPointNumber64,
+    kCHIPValueType_UTF8String_1ByteLength,
+    kCHIPValueType_UTF8String_2ByteLength,
+    kCHIPValueType_UTF8String_4ByteLength,
+    kCHIPValueType_UTF8String_8ByteLength,
+    kCHIPValueType_ByteString_1ByteLength,
+    kCHIPValueType_ByteString_2ByteLength,
+    kCHIPValueType_ByteString_4ByteLength,
+    kCHIPValueType_ByteString_8ByteLength,
+    kCHIPValueType_Null,
+    kCHIPValueType_EndOfContainer,
+};
+
+class Value
+{
+public:
+    ValueTypes mType;
+    union
+    {
+        uint64_t Int64;
+    };
+    Value() {}
+    Value(ValueTypes type) : mType(type), Int64() {}
+    Value(ValueTypes type, uint64_t int64Value) : mType(type), Int64(int64Value) {}
+
+    void ValueToStr(char * buf, int maxlen)
+    {
+        switch (mType)
+        {
+        case kCHIPValueType_Int8:
+        case kCHIPValueType_Int16:
+        case kCHIPValueType_Int32:
+        case kCHIPValueType_Int64:
+        case kCHIPValueType_UInt8:
+        case kCHIPValueType_UInt16:
+        case kCHIPValueType_UInt32:
+        case kCHIPValueType_UInt64:
+            snprintf(buf, maxlen, "%lld", Int64);
+            return;
+            break;
+        case kCHIPValueType_Bool:
+            snprintf(buf, maxlen, "%s", Int64 ? "true" : "false");
+            return;
+        default:
+            buf[0] = '\0';
+            return;
+        }
+        buf[0] = '\0';
+        return;
+    }
+};
+
+static inline Value ValueBool(bool b)
+{
+    return Value(kCHIPValueType_Bool, (uint64_t) b);
+}
+
+static inline bool ValueToBool(Value v)
+{
+    return (bool) v.Int64;
+}
+
+static inline Value ValueUInt8(uint8_t b)
+{
+    return Value(kCHIPValueType_UInt8, (uint64_t) b);
+}
+
+static inline uint8_t ValueToUInt8(Value v)
+{
+    return (uint8_t) v.Int64;
+}
+
+} // namespace DataModel
+} // namespace chip
+
+#endif /* CHIP_VALUE_H */
diff --git a/src/lib/datamodel/tests/Makefile.am b/src/lib/datamodel/tests/Makefile.am
new file mode 100644
index 00000000000000..a69cfec349b521
--- /dev/null
+++ b/src/lib/datamodel/tests/Makefile.am
@@ -0,0 +1,155 @@
+#
+#    Copyright (c) 2020 Project CHIP Authors
+#
+#    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.
+#
+
+#
+#    Description:
+#      This file is the GNU automake makefile for the Project CHIP
+#      App layer (i.e. cluster library) unit tests.
+#
+
+include $(abs_top_nlbuild_autotools_dir)/automake/pre.am
+
+#
+# Local headers to build against and distribute but not to install
+# since they are not part of the package.
+#
+noinst_HEADERS                                        = \
+    $(NULL)
+
+#
+# Other files we do want to distribute with the package.
+#
+EXTRA_DIST                                            = \
+    $(NULL)
+
+if CHIP_BUILD_TESTS
+lib_LIBRARIES                                         = \
+    libDataModelTests.a                                 \
+    $(NULL)
+
+libDataModelTests_a_SOURCES                       = \
+    TestClusterServer.cpp                           \
+    $(NULL)
+
+# C/C++ preprocessor option flags that will apply to all compiled
+# objects in this makefile.
+
+AM_CPPFLAGS                                           = \
+    -I$(top_srcdir)/src                                 \
+    -I$(top_srcdir)/src/lib                             \
+    $(NLASSERT_CPPFLAGS)                                \
+    $(NLUNIT_TEST_CPPFLAGS)                             \
+    $(NULL)
+
+CHIP_LDADD                                            = \
+    $(top_builddir)/src/lib/support/libSupportLayer.a   \
+    $(top_builddir)/src/lib/datamodel/libDataModel.a    \
+    $(NULL)
+
+COMMON_LDADD                                           = \
+    libDataModelTests.a                                  \
+    $(COMMON_LDFLAGS)                                    \
+    $(CHIP_LDADD)                                        \
+    $(NLUNIT_TEST_LDFLAGS) $(NLUNIT_TEST_LIBS)           \
+    $(NULL)
+
+# Test applications that should be run when the 'check' target is run.
+
+check_PROGRAMS                                        = \
+    $(NULL)
+
+check_SCRIPTS                                         = \
+    $(NULL)
+
+# The additional environment variables and their values that will be
+# made available to all programs and scripts in TESTS.
+TESTS_ENVIRONMENT                                      = \
+    $(NULL)
+
+if CHIP_DEVICE_LAYER_TARGET_ESP32
+
+check_SCRIPTS                                         += \
+    qemu_app_tests.sh                                    \
+    $(NULL)
+
+TESTS_ENVIRONMENT                                     += \
+    abs_top_srcdir='$(abs_top_srcdir)'                   \
+    abs_top_builddir='$(abs_top_builddir)'               \
+    QEMU_TEST_TARGET=libAppLayerTests.a                  \
+    $(NULL)
+
+else # CHIP_DEVICE_LAYER_TARGET_ESP32
+
+check_PROGRAMS                                       += \
+    TestAppLayer                                        \
+    $(NULL)
+
+endif # CHIP_DEVICE_LAYER_TARGET_ESP32
+
+# Test applications and scripts that should be built and run when the
+# 'check' target is run.
+
+TESTS                                                 = \
+    $(check_PROGRAMS)                                   \
+    $(check_SCRIPTS)                                    \
+    $(NULL)
+
+# Source, compiler, and linker options for test programs.
+
+TestAppLayer_SOURCES                                  = TestDriver.cpp
+TestAppLayer_LDADD                                    = $(COMMON_LDADD)
+
+#
+# Foreign make dependencies
+#
+
+NLFOREIGN_FILE_DEPENDENCIES                           = \
+   $(CHIP_LDADD)                                        \
+   $(NULL)
+
+NLFOREIGN_SUBDIR_DEPENDENCIES                         = \
+   $(NLUNIT_TEST_FOREIGN_SUBDIR_DEPENDENCY)             \
+   $(NULL)
+
+if CHIP_BUILD_COVERAGE
+CLEANFILES                                            = $(wildcard *.gcda *.gcno)
+
+if CHIP_BUILD_COVERAGE_REPORTS
+# The bundle should positively be qualified with the absolute build
+# path. Otherwise, VPATH will get auto-prefixed to it if there is
+# already such a directory in the non-colocated source tree.
+
+CHIP_COVERAGE_BUNDLE                                  = ${abs_builddir}/${PACKAGE}${NL_COVERAGE_BUNDLE_SUFFIX}
+CHIP_COVERAGE_INFO                                    = ${CHIP_COVERAGE_BUNDLE}/${PACKAGE}${NL_COVERAGE_INFO_SUFFIX}
+
+$(CHIP_COVERAGE_BUNDLE):
+	$(call create-directory)
+
+$(CHIP_COVERAGE_INFO): check-local | $(CHIP_COVERAGE_BUNDLE)
+	$(call generate-coverage-report,${top_builddir},*/usr/include/* */third_party/*)
+
+coverage-local: $(CHIP_COVERAGE_INFO)
+
+clean-local: clean-local-coverage
+
+.PHONY: clean-local-coverage
+clean-local-coverage:
+	-$(AM_V_at)rm -rf $(CHIP_COVERAGE_BUNDLE)
+endif # CHIP_BUILD_COVERAGE_REPORTS
+endif # CHIP_BUILD_COVERAGE
+endif # CHIP_BUILD_TESTS
+
+include $(abs_top_nlbuild_autotools_dir)/automake/post.am
diff --git a/src/lib/datamodel/tests/TestClusterServer.cpp b/src/lib/datamodel/tests/TestClusterServer.cpp
new file mode 100644
index 00000000000000..34fac758f241db
--- /dev/null
+++ b/src/lib/datamodel/tests/TestClusterServer.cpp
@@ -0,0 +1,155 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ * @file
+ *    This is a unit test suite for <tt>chip::App::AttributeStorage</tt>.
+ */
+
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS
+#endif
+
+#include <datamodel/ClusterOnOff.h>
+#include <datamodel/ClusterServer.h>
+#include <nlassert.h>
+#include <nlunit-test.h>
+#include <support/TestUtils.h>
+
+using namespace ::chip::DataModel;
+
+namespace {
+
+void TestClusterServerBasic(nlTestSuite * inSuite, void * inContext)
+{
+    const uint8_t ZCLVersion         = 10;
+    const uint8_t applicationVersion = 20;
+    const uint8_t stackVersion       = 1;
+    const uint8_t HWVersion          = 1;
+    Value value;
+
+    chip::DataModel::ClusterServer server(ZCLVersion, applicationVersion, stackVersion, HWVersion);
+
+    /* Validate attributes of the Base Cluster */
+    server.GetValue(1, kClusterIdBase, kAttributeIdZCLVersion, value);
+    NL_TEST_ASSERT(inSuite, ValueToUInt8(value) == ZCLVersion);
+
+    server.GetValue(1, kClusterIdBase, kAttributeIdApplicationVersion, value);
+    NL_TEST_ASSERT(inSuite, ValueToUInt8(value) == applicationVersion);
+
+    server.GetValue(1, kClusterIdBase, kAttributeIdStackVersion, value);
+    NL_TEST_ASSERT(inSuite, ValueToUInt8(value) == stackVersion);
+
+    server.GetValue(1, kClusterIdBase, kAttributeIdHWVersion, value);
+    NL_TEST_ASSERT(inSuite, ValueToUInt8(value) == HWVersion);
+}
+
+class testSwitch : public ClusterOnOff
+{
+public:
+    uint8_t mGpioNum;
+    bool mTestVector;
+    testSwitch(uint8_t gpio_no) : mGpioNum(gpio_no), mTestVector(false) {}
+
+    CHIP_ERROR Set(uint16_t attrId, const Value & value)
+    {
+        switch (attrId)
+        {
+        case kAttributeIdOnOff:
+            /* Set the test vector */
+            mTestVector = true;
+            break;
+        default:
+            /* No action */
+            break;
+        }
+        /* Update into our database */
+        return Cluster::Set(attrId, value);
+    }
+};
+
+void TestClusterServerTwoEndpoints(nlTestSuite * inSuite, void * inContext)
+{
+    const uint8_t ZCLVersion         = 10;
+    const uint8_t applicationVersion = 20;
+    const uint8_t stackVersion       = 1;
+    const uint8_t HWVersion          = 1;
+    Value value;
+
+    chip::DataModel::ClusterServer server(ZCLVersion, applicationVersion, stackVersion, HWVersion);
+    const uint8_t switch1Gpio = 10;
+    auto * switch1            = new testSwitch(switch1Gpio);
+    const uint8_t switch2Gpio = 11;
+    auto * switch2            = new testSwitch(switch2Gpio);
+
+    server.AddCluster(switch1);
+    server.AddCluster(switch2);
+
+    /* Validate attributes of the OnOff Cluster on Endpoint 1 */
+    server.GetValue(1, kClusterIdOnOff, kAttributeIdOnOff, value);
+    NL_TEST_ASSERT(inSuite, ValueToBool(value) == false);
+
+    /* Validate attributes of the OnOff Cluster on Endpoint 2 */
+    server.GetValue(2, kClusterIdOnOff, kAttributeIdOnOff, value);
+    NL_TEST_ASSERT(inSuite, ValueToBool(value) == false);
+
+    /* Test that the Set() on the base class gets redirected to the correct object */
+    /* Set 'true' to switch1 */
+    Cluster * cluster = switch1;
+    cluster->Set(kAttributeIdOnOff, ValueBool(true));
+
+    /* Test the the value in the database is updated */
+    server.GetValue(1, kClusterIdOnOff, kAttributeIdOnOff, value);
+    NL_TEST_ASSERT(inSuite, ValueToBool(value) == true);
+    /* Test that the appropriate function of the derived class was executed */
+    NL_TEST_ASSERT(inSuite, switch1->mTestVector == true);
+
+    /* Set 'true' to switch2 */
+    cluster = switch2;
+    cluster->Set(kAttributeIdOnOff, ValueBool(true));
+
+    /* Test the the value in the database is updated */
+    server.GetValue(2, kClusterIdOnOff, kAttributeIdOnOff, value);
+    NL_TEST_ASSERT(inSuite, ValueToBool(value) == true);
+    /* Test that the appropriate function of the derived class was executed */
+    NL_TEST_ASSERT(inSuite, switch2->mTestVector == true);
+}
+
+} // namespace
+
+int TestClusterServer(void)
+{
+    /**
+     *   Test Suite. It lists all the test functions.
+     */
+    static const nlTest sTests[] = { NL_TEST_DEF("TestClusterServerBasic", TestClusterServerBasic),
+                                     NL_TEST_DEF("TestClusterServerTwoEndpoints", TestClusterServerTwoEndpoints),
+                                     NL_TEST_SENTINEL() };
+
+    nlTestSuite theSuite = {
+        "TestClusterServer", &sTests[0], NULL /* setup */, NULL /* teardown */
+    };
+
+    // Run test suit againt one context.
+    nlTestRunner(&theSuite, NULL /* context */);
+    return (nlTestRunnerStats(&theSuite));
+}
+
+static void __attribute__((constructor)) Ctor(void)
+{
+    nlABORT(chip::RegisterUnitTests(&TestClusterServer) == CHIP_NO_ERROR);
+}
diff --git a/src/lib/datamodel/tests/TestDriver.cpp b/src/lib/datamodel/tests/TestDriver.cpp
new file mode 100644
index 00000000000000..e9dac883b13f74
--- /dev/null
+++ b/src/lib/datamodel/tests/TestDriver.cpp
@@ -0,0 +1,36 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *
+ *    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.
+ */
+
+/**
+ *    @file
+ *      This file implements a standalone/native program executable
+ *      test driver for the CHIP app layer library attribute storage unit
+ *      tests.
+ *
+ */
+
+#include <support/TestUtils.h>
+
+#include <nlunit-test.h>
+
+int main(void)
+{
+    // Generate machine-readable, comma-separated value (CSV) output.
+    nlTestSetOutputStyle(OUTPUT_CSV);
+
+    return chip::RunRegisteredUnitTests();
+}
diff --git a/src/lib/datamodel/tests/qemu_system_tests.sh b/src/lib/datamodel/tests/qemu_system_tests.sh
new file mode 100644
index 00000000000000..42614f393c58d0
--- /dev/null
+++ b/src/lib/datamodel/tests/qemu_system_tests.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+#
+#
+#    Copyright (c) 2020 Project CHIP Authors
+#
+#    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.
+#
+#
+#    Description:
+#      This is a utility script that runs CHIP tests using ESP32 QEMU.
+#
+
+set -e
+
+die() {
+    echo "$me: *** ERROR: " "${*}"
+    exit 1
+}
+
+source "$abs_top_builddir"/env.sh
+bash "$abs_top_builddir"/esp32_elf_builder.sh "$QEMU_TEST_TARGET"
+
+flash_image_file=$(mktemp)
+log_file=$(mktemp)
+trap "{ rm -f $flash_image_file $log_file; }" EXIT
+
+"$abs_top_srcdir"/scripts/tools/build_esp32_flash_image.sh "$abs_top_builddir"/chip-tests.bin "$flash_image_file"
+"$abs_top_srcdir"/scripts/tools/esp32_qemu_run.sh "$flash_image_file" | tee "$log_file"
+
+# If the logs contain failure message
+if grep -F "] : FAILED" "$log_file"; then
+    die 'Some tests failed.'
+fi
+
+# If the logs do not contain final success status
+if grep -F "CHIP-tests: CHIP test status: 0" "$log_file"; then
+    echo "$me: All tests passed"
+else
+    die 'Tests did not run to completion.'
+fi