diff --git a/build.sh b/build.sh
index 5bf08a767..3857f3a31 100755
--- a/build.sh
+++ b/build.sh
@@ -26,6 +26,7 @@ print_usage() {
     echo "  --clean                    cleans build artifacts"
     echo "  --aos-service <services>   specifies services (e.g., sm,mp,iam)"
     echo "  --ci                       uses build-wrapper for CI analysis (SonarQube)"
+    echo "  --parallel <N>             specifies number of parallel jobs for build (default: all available cores)"
     echo
 }
 
@@ -77,11 +78,11 @@ build_project() {
     if [ "$ARG_CI_FLAG" == "true" ]; then
         print_next_step "Run build-wrapper and build (CI mode)"
 
-        build-wrapper-linux-x86-64 --out-dir "$BUILD_WRAPPER_OUT_DIR" cmake --build ./build/ --config Debug --parallel
+        build-wrapper-linux-x86-64 --out-dir "$BUILD_WRAPPER_OUT_DIR" cmake --build ./build/ --config Debug --parallel ${ARG_PARALLEL_JOBS}
     else
         print_next_step "Run build"
 
-        cmake --build ./build/ --config Debug --parallel
+        cmake --build ./build/ --config Debug --parallel ${ARG_PARALLEL_JOBS}
     fi
 
     echo
@@ -101,6 +102,11 @@ parse_arguments() {
             shift
             ;;
 
+        --parallel)
+            ARG_PARALLEL_JOBS="$2"
+            shift 2
+            ;;
+
         *)
             error_with_usage "Unknown option: $1"
             ;;
@@ -172,6 +178,7 @@ shift
 ARG_CLEAN_FLAG=false
 ARG_AOS_SERVICES=""
 ARG_CI_FLAG=false
+ARG_PARALLEL_JOBS=$(nproc)
 
 case "$command" in
 build)
diff --git a/include/aos/cm/communication/communication.hpp b/include/aos/cm/communication/communication.hpp
index 5d0e6b188..3608a1e44 100644
--- a/include/aos/cm/communication/communication.hpp
+++ b/include/aos/cm/communication/communication.hpp
@@ -7,7 +7,7 @@
 #ifndef AOS_CM_COMMUNICATION_HPP_
 #define AOS_CM_COMMUNICATION_HPP_
 
-#include "aos/common/cloudprotocol/state.hpp"
+#include "aos/common/cloudprotocol/cloudmessage.hpp"
 #include "aos/common/types.hpp"
 
 namespace aos::cm::communication {
@@ -17,25 +17,36 @@ namespace aos::cm::communication {
  */
 
 /**
- * Communication interface.
+ * Message handler interface to handle received message.
  */
-class CommunicationItf {
+class MessageHandlerItf {
 public:
     /**
-     * Sends instances new state.
+     * Handles received message.
      *
-     * @param newState new state to send.
+     * @param message received message.
      * @return Error.
      */
-    virtual Error SendInstanceNewState(const cloudprotocol::NewState& newState) = 0;
+    virtual Error HandleMessage(const cloudprotocol::MessageVariant& message) = 0;
+
+    /**
+     * Destructor.
+     */
+    virtual ~MessageHandlerItf() = default;
+};
 
+/**
+ * Communication interface.
+ */
+class CommunicationItf {
+public:
     /**
-     * Sends instances update state.
+     * Sends cloud message.
      *
-     * @param updateState update state to send.
+     * @param body cloud message body to send.
      * @return Error.
      */
-    virtual Error SendInstanceStateRequest(const cloudprotocol::StateRequest& stateRequest) = 0;
+    virtual Error SendMessage(const cloudprotocol::MessageVariant& body) = 0;
 
     /**
      * Destructor.
diff --git a/include/aos/cm/launcher/nodemanager.hpp b/include/aos/cm/launcher/nodemanager.hpp
index c3211bb0e..4f34961df 100644
--- a/include/aos/cm/launcher/nodemanager.hpp
+++ b/include/aos/cm/launcher/nodemanager.hpp
@@ -28,7 +28,7 @@ struct InstanceStatus : public aos::InstanceStatus {
     /**
      * Service state checksum.
      */
-    StaticString<cSHA3_224Size> mStateChecksum;
+    StaticString<2 * cSHA3_224Size> mStateChecksum;
 
     /**
      * Compares instance status.
diff --git a/include/aos/common/cloudprotocol/alerts.hpp b/include/aos/common/cloudprotocol/alerts.hpp
index 04d40127b..e3062b82f 100644
--- a/include/aos/common/cloudprotocol/alerts.hpp
+++ b/include/aos/common/cloudprotocol/alerts.hpp
@@ -38,6 +38,11 @@ constexpr auto cAlertParameterLen = AOS_CONFIG_CLOUDPROTOCOL_ALERT_PARAMETER_LEN
  */
 constexpr auto cAlertResourceErrorsSize = AOS_CONFIG_CLOUDPROTOCOL_ALERT_RESOURCE_ERRORS_SIZE;
 
+/**
+ * Alert items count.
+ */
+constexpr auto cAlertItemsCount = AOS_CONFIG_CLOUDPROTOCOL_ALERT_ITEMS_COUNT;
+
 /**
  * Alert tag.
  */
@@ -645,6 +650,31 @@ struct ServiceInstanceAlert : AlertItem {
 using AlertVariant = Variant<SystemAlert, CoreAlert, DownloadAlert, SystemQuotaAlert, InstanceQuotaAlert,
     DeviceAllocateAlert, ResourceValidateAlert, ServiceInstanceAlert>;
 
+using AlertVariantStaticArray = StaticArray<AlertVariant, cAlertItemsCount>;
+
+/**
+ * Alerts message structure.
+ */
+struct Alerts {
+    AlertVariantStaticArray mItems;
+
+    /**
+     * Compares alerts.
+     *
+     * @param alerts alerts to compare with.
+     * @return bool.
+     */
+    bool operator==(const Alerts& alerts) const { return mItems == alerts.mItems; }
+
+    /**
+     * Compares alerts.
+     *
+     * @param alerts alerts to compare with.
+     * @return bool.
+     */
+    bool operator!=(const Alerts& alerts) const { return !operator==(alerts); }
+};
+
 } // namespace aos::cloudprotocol
 
 #endif
diff --git a/include/aos/common/cloudprotocol/certificates.hpp b/include/aos/common/cloudprotocol/certificates.hpp
new file mode 100644
index 000000000..0f0891161
--- /dev/null
+++ b/include/aos/common/cloudprotocol/certificates.hpp
@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2025 EPAM Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef AOS_CLOUDPROTOCOL_CERTIFICATES_HPP_
+#define AOS_CLOUDPROTOCOL_CERTIFICATES_HPP_
+
+#include "aos/common/cloudprotocol/cloudprotocol.hpp"
+#include "aos/common/crypto/crypto.hpp"
+#include "aos/common/tools/map.hpp"
+#include "aos/common/tools/optional.hpp"
+#include "aos/common/types.hpp"
+
+namespace aos::cloudprotocol {
+
+/**
+ * Supported version of UnitSecret message.
+ */
+static constexpr auto cUnitSecretVersion = "2.0.0";
+
+/**
+ * Certificate installation description size.
+ */
+static constexpr auto cCertInstallationDescriptionSize
+    = AOS_CONFIG_CLOUDPROTOCOL_CERTIFICATE_INSTALLATION_DESCRIPTION_SIZE;
+
+/**
+ * Certificate secret size.
+ */
+static constexpr auto cCertSecretSize = AOS_CONFIG_CLOUDPROTOCOL_CERTIFICATE_SECRET_SIZE;
+
+/**
+ * Cert type type.
+ */
+class CertTypeType {
+public:
+    enum class Enum {
+        eOffline,
+        eOnline,
+        eUM,
+        eSM,
+        eCM,
+        eIAM,
+        eNumCertificates,
+    };
+
+    static const Array<const char* const> GetStrings()
+    {
+        static const char* const sStrings[] = {
+            "offline",
+            "online",
+            "um",
+            "sm",
+            "cm",
+            "iam",
+            "unknown",
+        };
+
+        return Array<const char* const>(sStrings, ArraySize(sStrings));
+    };
+};
+
+using CertTypeEnum = CertTypeType::Enum;
+using CertType     = EnumStringer<CertTypeType>;
+
+/**
+ * Maximum number of certificates per node.
+ */
+static constexpr auto cCertificatesPerNodeCount = static_cast<size_t>(CertTypeEnum::eNumCertificates);
+
+/**
+ * Maximum number of certificates per unit.
+ */
+static constexpr auto cCertsPerUnitCount = cMaxNumNodes * cCertificatesPerNodeCount;
+
+/**
+ * IssuedCertData issued unit certificate data.
+ */
+struct IssuedCertData {
+    CertType                            mType;
+    StaticString<cNodeIDLen>            mNodeID;
+    StaticString<crypto::cCertChainLen> mCertificateChain;
+
+    /**
+     * Compares issued certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const IssuedCertData& other) const
+    {
+        return mType == other.mType && mNodeID == other.mNodeID && mCertificateChain == other.mCertificateChain;
+    }
+
+    /**
+     * Compares issued certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const IssuedCertData& other) const { return !operator==(other); }
+};
+
+/**
+ * InstallCertData install certificate data.
+ */
+struct InstallCertData {
+    CertType                                       mType;
+    StaticString<cNodeIDLen>                       mNodeID;
+    StaticString<crypto::cSerialNumStrLen>         mSerial;
+    ItemStatus                                     mStatus {ItemStatusEnum::eInstalled};
+    StaticString<cCertInstallationDescriptionSize> mDescription;
+
+    /**
+     * Compares install certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const InstallCertData& other) const
+    {
+        return mType == other.mType && mNodeID == other.mNodeID && mSerial == other.mSerial && mStatus == other.mStatus
+            && mDescription == other.mDescription;
+    }
+
+    /**
+     * Compares install certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const InstallCertData& other) const { return !operator==(other); }
+};
+
+/**
+ * RenewCertData renew certificate data.
+ */
+struct RenewCertData {
+    CertType                               mType;
+    StaticString<cNodeIDLen>               mNodeID;
+    StaticString<crypto::cSerialNumStrLen> mSerial;
+    Optional<Time>                         mValidTill;
+
+    /**
+     * Compares renew certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+
+    bool operator==(const RenewCertData& other) const
+    {
+        return mType == other.mType && mNodeID == other.mNodeID && mSerial == other.mSerial
+            && mValidTill == other.mValidTill;
+    }
+
+    /**
+     * Compares renew certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const RenewCertData& other) const { return !operator==(other); }
+};
+
+/**
+ * UnitSecrets keeps secrets for nodes.
+ */
+struct UnitSecrets {
+    StaticString<cVersionLen>                                                        mVersion;
+    StaticMap<StaticString<cNodeIDLen>, StaticString<cCertSecretSize>, cMaxNumNodes> mNodes;
+
+    /**
+     * Compares unit secrets.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const UnitSecrets& other) const { return mVersion == other.mVersion && mNodes == other.mNodes; }
+
+    /**
+     * Compares unit secrets.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const UnitSecrets& other) const { return !operator==(other); }
+};
+
+/**
+ * IssueCertData issue certificate data.
+ */
+struct IssueCertData {
+    CertType                         mType;
+    StaticString<cNodeIDLen>         mNodeID;
+    StaticString<crypto::cCSRPEMLen> mCsr;
+
+    /**
+     * Compares issue certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const IssueCertData& other) const
+    {
+        return mType == other.mType && mNodeID == other.mNodeID && mCsr == other.mCsr;
+    }
+
+    /**
+     * Compares issue certificate data.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const IssueCertData& other) const { return !operator==(other); }
+};
+
+/**
+ * RenewCertsNotification renew certificate notification from cloud with pwd.
+ */
+struct RenewCertsNotification {
+    StaticArray<RenewCertData, cCertsPerUnitCount> mCertificates;
+    UnitSecrets                                    mUnitSecrets;
+
+    /**
+     * Compares renew certificate notification.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const RenewCertsNotification& other) const
+    {
+        return mCertificates == other.mCertificates && mUnitSecrets == other.mUnitSecrets;
+    }
+
+    /**
+     * Compares renew certificate notification.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const RenewCertsNotification& other) const { return !operator==(other); }
+};
+
+/**
+ * IssuedUnitCerts issued unit certificates info.
+ */
+struct IssuedUnitCerts {
+    StaticArray<IssuedCertData, cCertsPerUnitCount> mCertificates;
+
+    /**
+     * Compares issued unit certificates.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const IssuedUnitCerts& other) const { return mCertificates == other.mCertificates; }
+
+    /**
+     * Compares issued unit certificates.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const IssuedUnitCerts& other) const { return !operator==(other); }
+};
+
+/**
+ * IssueUnitCerts issue unit certificates request.
+ */
+struct IssueUnitCerts {
+    StaticArray<IssueCertData, cCertsPerUnitCount> mRequests;
+
+    /**
+     * Compares issue unit certificates.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const IssueUnitCerts& other) const { return mRequests == other.mRequests; }
+
+    /**
+     * Compares issue unit certificates.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const IssueUnitCerts& other) const { return !operator==(other); }
+};
+
+/**
+ * InstallUnitCertsConfirmation install unit certificates confirmation.
+ */
+struct InstallUnitCertsConfirmation {
+    StaticArray<InstallCertData, cCertsPerUnitCount> mCertificates;
+
+    /**
+     * Compares install unit certificates confirmation.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const InstallUnitCertsConfirmation& other) const { return mCertificates == other.mCertificates; }
+
+    /**
+     * Compares install unit certificates confirmation.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const InstallUnitCertsConfirmation& other) const { return !operator==(other); }
+};
+
+} // namespace aos::cloudprotocol
+
+#endif
diff --git a/include/aos/common/cloudprotocol/cloudmessage.hpp b/include/aos/common/cloudprotocol/cloudmessage.hpp
new file mode 100644
index 000000000..9cb14674b
--- /dev/null
+++ b/include/aos/common/cloudprotocol/cloudmessage.hpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2025 EPAM Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef AOS_CLOUDPROTOCOL_CLOUDMESSAGE_HPP_
+#define AOS_CLOUDPROTOCOL_CLOUDMESSAGE_HPP_
+
+#include "aos/common/cloudprotocol/alerts.hpp"
+#include "aos/common/cloudprotocol/certificates.hpp"
+#include "aos/common/cloudprotocol/cloudprotocol.hpp"
+#include "aos/common/cloudprotocol/desiredstatus.hpp"
+#include "aos/common/cloudprotocol/envvars.hpp"
+#include "aos/common/cloudprotocol/log.hpp"
+#include "aos/common/cloudprotocol/monitoring.hpp"
+#include "aos/common/cloudprotocol/provisioning.hpp"
+#include "aos/common/cloudprotocol/state.hpp"
+#include "aos/common/cloudprotocol/unitstatus.hpp"
+#include "aos/common/tools/variant.hpp"
+
+namespace aos::cloudprotocol {
+
+/**
+ * Cloud protocol version.
+ */
+static constexpr auto cProtocolVersion = 7;
+
+/**
+ * Cloud message variant type.
+ */
+using MessageVariant = Variant<Alerts, Monitoring, UnitStatus, DeltaUnitStatus, DesiredStatus, NewState, StateRequest,
+    StateAcceptance, UpdateState, RequestLog, PushLog, OverrideEnvVarsRequest, OverrideEnvVarsStatuses,
+    RenewCertsNotification, IssuedUnitCerts, IssueUnitCerts, InstallUnitCertsConfirmation, StartProvisioningRequest,
+    StartProvisioningResponse, FinishProvisioningRequest, FinishProvisioningResponse, DeprovisioningRequest,
+    DeprovisioningResponse>;
+
+/**
+ * Cloud message header.
+ */
+struct MessageHeader {
+    /**
+     * Default constructor.
+     */
+    MessageHeader() = default;
+
+    /**
+     * Constructor.
+     *
+     * @param version protocol version.
+     * @param systemID system identifier.
+     */
+    MessageHeader(size_t version, const String& systemID)
+        : mVersion(version)
+        , mSystemID(systemID)
+    {
+    }
+
+    size_t                     mVersion {};
+    StaticString<cSystemIDLen> mSystemID;
+
+    /**
+     * Compares message headers.
+     *
+     * @param header message header to compare with.
+     * @return bool.
+     */
+    bool operator==(const MessageHeader& header) const
+    {
+        return mVersion == header.mVersion && mSystemID == header.mSystemID;
+    }
+
+    /**
+     * Compares message headers.
+     *
+     * @param header message header to compare with.
+     * @return bool.
+     */
+    bool operator!=(const MessageHeader& header) const { return !operator==(header); }
+};
+
+/**
+ * Cloud message.
+ */
+struct CloudMessage {
+    /**
+     * Default constructor.
+     */
+    CloudMessage() = default;
+
+    /**
+     * Constructor.
+     *
+     * @param header message header.
+     * @param data message data.
+     */
+    CloudMessage(const MessageHeader& header, const MessageVariant& data)
+        : mHeader(header)
+        , mData(data)
+    {
+    }
+
+    MessageHeader  mHeader;
+    MessageVariant mData;
+
+    /**
+     * Compares cloud messages.
+     *
+     * @param message cloud message to compare with.
+     * @return bool.
+     */
+    bool operator==(const CloudMessage& message) const { return mHeader == message.mHeader && mData == message.mData; }
+
+    /**
+     * Compares cloud messages.
+     *
+     * @param message cloud message to compare with.
+     * @return bool.
+     */
+    bool operator!=(const CloudMessage& message) const { return !operator==(message); }
+};
+
+} // namespace aos::cloudprotocol
+
+#endif
diff --git a/include/aos/common/cloudprotocol/cloudprotocol.hpp b/include/aos/common/cloudprotocol/cloudprotocol.hpp
index 5833a61be..31d378c9c 100644
--- a/include/aos/common/cloudprotocol/cloudprotocol.hpp
+++ b/include/aos/common/cloudprotocol/cloudprotocol.hpp
@@ -81,19 +81,55 @@ struct InstanceFilter {
 class MessageTypeType {
 public:
     enum class Enum {
-        eStateAcceptance,
-        eUpdateState,
+        eAlerts,
+        eDeprovisioningRequest,
+        eDeprovisioningResponse,
+        eDesiredStatus,
+        eFinishProvisioningRequest,
+        eFinishProvisioningResponse,
+        eInstallUnitCertificatesConfirmation,
+        eIssuedUnitCertificates,
+        eIssueUnitCertificates,
+        eMonitoringData,
         eNewState,
+        eOverrideEnvVars,
+        eOverrideEnvVarsStatus,
+        ePushLog,
+        eRenewCertificatesNotification,
+        eRequestLog,
+        eStartProvisioningRequest,
+        eStartProvisioningResponse,
+        eStateAcceptance,
         eStateRequest,
+        eUnitStatus,
+        eUpdateState,
     };
 
     static const Array<const char* const> GetStrings()
     {
         static const char* const sStrings[] = {
-            "stateAcceptance",
-            "updateState",
+            "alerts",
+            "deprovisioningRequest",
+            "deprovisioningResponse",
+            "desiredStatus",
+            "finishProvisioningRequest",
+            "finishProvisioningResponse",
+            "installUnitCertificatesConfirmation",
+            "issuedUnitCertificates",
+            "issueUnitCertificates",
+            "monitoringData",
             "newState",
+            "overrideEnvVars",
+            "overrideEnvVarsStatus",
+            "pushLog",
+            "renewCertificatesNotification",
+            "requestLog",
+            "startProvisioningRequest",
+            "startProvisioningResponse",
+            "stateAcceptance",
             "stateRequest",
+            "unitStatus",
+            "updateState",
         };
 
         return Array<const char* const>(sStrings, ArraySize(sStrings));
diff --git a/include/aos/common/cloudprotocol/desiredstatus.hpp b/include/aos/common/cloudprotocol/desiredstatus.hpp
new file mode 100644
index 000000000..a19bda034
--- /dev/null
+++ b/include/aos/common/cloudprotocol/desiredstatus.hpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2025 EPAM Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef AOS_CLOUDPROTOCOL_DESIREDSTATUS_HPP_
+#define AOS_CLOUDPROTOCOL_DESIREDSTATUS_HPP_
+
+#include "aos/common/cloudprotocol/cloudprotocol.hpp"
+#include "aos/common/types.hpp"
+
+namespace aos::cloudprotocol {
+
+/**
+ * Node config.
+ */
+struct NodeConfig {
+    StaticString<cNodeTypeLen>                                  mNodeType;
+    StaticString<cNodeIDLen>                                    mNodeID;
+    Optional<AlertRules>                                        mAlertRules;
+    Optional<ResourceRatios>                                    mResourceRatios;
+    StaticArray<DeviceInfo, cMaxNumNodeDevices>                 mDevices;
+    StaticArray<ResourceInfo, cMaxNumNodeResources>             mResources;
+    StaticArray<StaticString<cLabelNameLen>, cMaxNumNodeLabels> mLabels;
+    size_t                                                      mPriority {0};
+
+    /**
+     * Compares node configs.
+     *
+     * @param nodeConfig node config to compare.
+     * @return bool.
+     */
+    bool operator==(const NodeConfig& nodeConfig) const
+    {
+        return mNodeType == nodeConfig.mNodeType && mNodeID == nodeConfig.mNodeID
+            && mAlertRules == nodeConfig.mAlertRules && mResourceRatios == nodeConfig.mResourceRatios
+            && mDevices == nodeConfig.mDevices && mResources == nodeConfig.mResources && mLabels == nodeConfig.mLabels
+            && mPriority == nodeConfig.mPriority;
+    }
+
+    /**
+     * Compares node configs.
+     *
+     * @param nodeConfig node config to compare.
+     * @return bool.
+     */
+    bool operator!=(const NodeConfig& nodeConfig) const { return !operator==(nodeConfig); }
+};
+
+/**
+ * Unit config.
+ */
+struct UnitConfig {
+    StaticString<cVersionLen>             mVersion;
+    StaticString<cVersionLen>             mFormatVersion;
+    StaticArray<NodeConfig, cMaxNumNodes> mNodes;
+
+    /**
+     * Compares unit config.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const UnitConfig& other) const
+    {
+        return mVersion == other.mVersion && mFormatVersion == other.mFormatVersion && mNodes == other.mNodes;
+    }
+
+    /**
+     * Compares unit config.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const UnitConfig& other) const { return !operator==(other); }
+};
+
+/**
+ * Desired status.
+ */
+struct DesiredStatus {
+    Optional<UnitConfig> mUnitConfig;
+
+    /**
+     * Compares desired status.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const DesiredStatus& other) const { return mUnitConfig == other.mUnitConfig; }
+
+    /**
+     * Compares desired status.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const DesiredStatus& other) const { return !operator==(other); }
+};
+
+} // namespace aos::cloudprotocol
+
+#endif
diff --git a/include/aos/common/cloudprotocol/envvars.hpp b/include/aos/common/cloudprotocol/envvars.hpp
index 9f7be79f8..b65306d52 100644
--- a/include/aos/common/cloudprotocol/envvars.hpp
+++ b/include/aos/common/cloudprotocol/envvars.hpp
@@ -163,6 +163,52 @@ struct EnvVarsInstanceStatus {
 
 using EnvVarsInstanceStatusArray = StaticArray<EnvVarsInstanceStatus, cMaxNumInstances>;
 
+/**
+ * Environment variable override request.
+ */
+struct OverrideEnvVarsRequest {
+    EnvVarsInstanceInfoArray mItems;
+
+    /**
+     * Compares environment variable override request.
+     *
+     * @param request environment variable override request to compare with.
+     * @return bool.
+     */
+    bool operator==(const OverrideEnvVarsRequest& request) const { return mItems == request.mItems; }
+
+    /**
+     * Compares environment variable override request.
+     *
+     * @param request environment variable override request to compare with.
+     * @return bool.
+     */
+    bool operator!=(const OverrideEnvVarsRequest& request) const { return !operator==(request); }
+};
+
+/**
+ * Environment variable override statuses.
+ */
+struct OverrideEnvVarsStatuses {
+    EnvVarsInstanceStatusArray mStatuses;
+
+    /**
+     * Compares environment variable override statuses.
+     *
+     * @param statuses environment variable override statuses to compare with.
+     * @return bool.
+     */
+    bool operator==(const OverrideEnvVarsStatuses& statuses) const { return mStatuses == statuses.mStatuses; }
+
+    /**
+     * Compares environment variable override statuses.
+     *
+     * @param statuses environment variable override statuses to compare with.
+     * @return bool.
+     */
+    bool operator!=(const OverrideEnvVarsStatuses& statuses) const { return !operator==(statuses); }
+};
+
 } // namespace aos::cloudprotocol
 
 #endif
diff --git a/include/aos/common/cloudprotocol/log.hpp b/include/aos/common/cloudprotocol/log.hpp
index 953af37de..1ee575e7f 100644
--- a/include/aos/common/cloudprotocol/log.hpp
+++ b/include/aos/common/cloudprotocol/log.hpp
@@ -24,11 +24,6 @@ constexpr auto cLogIDLen = AOS_CONFIG_CLOUDPROTOCOL_LOG_ID_LEN;
  */
 constexpr auto cLogContentLen = AOS_CONFIG_CLOUDPROTOCOL_LOG_CONTENT_LEN;
 
-/**
- * Bearer token len.
- */
-constexpr auto cBearerTokenLen = AOS_CONFIG_CLOUDPROTOCOL_BEARER_TOKEN_LEN;
-
 /**
  * Log type type.
  */
@@ -55,11 +50,33 @@ class LogTypeType {
 using LogTypeEnum = LogTypeType::Enum;
 using LogType     = EnumStringer<LogTypeType>;
 
+/**
+ * Log upload type type.
+ */
+class LogUploadTypeType {
+public:
+    enum class Enum {
+        eHTTPS,
+    };
+
+    static const Array<const char* const> GetStrings()
+    {
+        static const char* const sStrings[] = {
+            "https",
+        };
+
+        return Array<const char* const>(sStrings, ArraySize(sStrings));
+    };
+};
+
+using LogUploadTypeEnum = LogUploadTypeType::Enum;
+using LogUploadType     = EnumStringer<LogUploadTypeType>;
+
 /**
  * Log upload options.
  */
 struct LogUploadOptions {
-    LogType                       mType;
+    LogUploadType                 mType;
     StaticString<cURLLen>         mURL;
     StaticString<cBearerTokenLen> mBearerToken;
     Optional<Time>                mBearerTokenTTL;
@@ -92,7 +109,6 @@ struct LogFilter {
     Optional<Time>                                      mFrom;
     Optional<Time>                                      mTill;
     StaticArray<StaticString<cNodeIDLen>, cMaxNumNodes> mNodeIDs;
-    Optional<LogUploadOptions>                          mUploadOptions;
     InstanceFilter                                      mInstanceFilter;
 
     /**
@@ -104,7 +120,7 @@ struct LogFilter {
     bool operator==(const LogFilter& filter) const
     {
         return mFrom == filter.mFrom && mTill == filter.mTill && mNodeIDs == filter.mNodeIDs
-            && mUploadOptions == filter.mUploadOptions && mInstanceFilter == filter.mInstanceFilter;
+            && mInstanceFilter == filter.mInstanceFilter;
     }
 
     /**
@@ -116,38 +132,14 @@ struct LogFilter {
     bool operator!=(const LogFilter& filter) const { return !operator==(filter); }
 };
 
-/**
- * Log message type type.
- */
-class LogMessageTypeType {
-public:
-    enum class Enum {
-        eRequestLog,
-        ePushLog,
-    };
-
-    static const Array<const char* const> GetStrings()
-    {
-        static const char* const sLogMessageTypeStrings[] = {
-            "requestLog",
-            "pushLog",
-        };
-
-        return Array<const char* const>(sLogMessageTypeStrings, ArraySize(sLogMessageTypeStrings));
-    };
-};
-
-using LogMessageTypeEnum = LogMessageTypeType::Enum;
-using LogMessageType     = EnumStringer<LogMessageTypeType>;
-
 /**
  * Log status.
  */
 struct RequestLog {
-    LogMessageType          mMessageType;
-    StaticString<cLogIDLen> mLogID;
-    LogType                 mLogType;
-    LogFilter               mFilter;
+    StaticString<cLogIDLen>    mLogID;
+    LogType                    mLogType;
+    LogFilter                  mFilter;
+    Optional<LogUploadOptions> mUploadOptions;
 
     /**
      * Compares log request.
@@ -157,8 +149,8 @@ struct RequestLog {
      */
     bool operator==(const RequestLog& request) const
     {
-        return mMessageType == request.mMessageType && mLogID == request.mLogID && mLogType == request.mLogType
-            && mFilter == request.mFilter;
+        return mLogID == request.mLogID && mLogType == request.mLogType && mFilter == request.mFilter
+            && mUploadOptions == request.mUploadOptions;
     }
 
     /**
@@ -202,7 +194,6 @@ using LogStatus     = EnumStringer<LogStatusType>;
  * Push log.
  */
 struct PushLog {
-    LogMessageType               mMessageType;
     StaticString<cNodeIDLen>     mNodeID;
     StaticString<cLogIDLen>      mLogID;
     uint64_t                     mPartsCount;
@@ -219,9 +210,8 @@ struct PushLog {
      */
     bool operator==(const PushLog& log) const
     {
-        return mMessageType == log.mMessageType && mNodeID == log.mNodeID && mLogID == log.mLogID
-            && mPartsCount == log.mPartsCount && mPart == log.mPart && mContent == log.mContent
-            && mStatus == log.mStatus && mErrorInfo == log.mErrorInfo;
+        return mNodeID == log.mNodeID && mLogID == log.mLogID && mPartsCount == log.mPartsCount && mPart == log.mPart
+            && mContent == log.mContent && mStatus == log.mStatus && mErrorInfo == log.mErrorInfo;
     }
 
     /**
diff --git a/include/aos/common/cloudprotocol/monitoring.hpp b/include/aos/common/cloudprotocol/monitoring.hpp
new file mode 100644
index 000000000..02a12e5c8
--- /dev/null
+++ b/include/aos/common/cloudprotocol/monitoring.hpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2025 EPAM Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef AOS_CLOUDPROTOCOL_MONITORING_HPP_
+#define AOS_CLOUDPROTOCOL_MONITORING_HPP_
+
+#include "aos/common/crypto/crypto.hpp"
+#include "aos/common/tools/optional.hpp"
+#include "aos/common/types.hpp"
+
+namespace aos::cloudprotocol {
+
+/**
+ * Monitoring items count.
+ */
+static constexpr auto cMonitoringItemsCount = AOS_CONFIG_CLOUDPROTOCOL_MONITORING_ITEMS_COUNT;
+
+/**
+ * Partition usage.
+ */
+struct PartitionUsage {
+    StaticString<cPartitionNameLen> mName;
+    size_t                          mUsedSize {};
+
+    /**
+     * Compares partition usages.
+     * @param usage object to compare with.
+     * @return bool.
+     */
+    bool operator==(const PartitionUsage& usage) const { return mName == usage.mName && mUsedSize == usage.mUsedSize; }
+
+    /**
+     * Compares partition usages.
+     * @param usage object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const PartitionUsage& usage) const { return !operator==(usage); }
+};
+
+using PartitionUsageStaticArray = StaticArray<PartitionUsage, cMaxNumPartitions>;
+
+/**
+ * Monitoring data.
+ */
+struct MonitoringData {
+    Time                      mTime;
+    size_t                    mCPU {};
+    size_t                    mRAM {};
+    size_t                    mDownload {};
+    size_t                    mUpload {};
+    PartitionUsageStaticArray mPartitions;
+
+    /**
+     * Compares monitoring data.
+     *
+     * @param data monitoring data to compare with.
+     * @return bool.
+     */
+    bool operator==(const MonitoringData& data) const
+    {
+        return mCPU == data.mCPU && mRAM == data.mRAM && mPartitions == data.mPartitions && mDownload == data.mDownload
+            && mUpload == data.mUpload;
+    }
+
+    /**
+     * Compares monitoring data.
+     *
+     * @param data monitoring data to compare with.
+     * @return bool.
+     */
+    bool operator!=(const MonitoringData& data) const { return !operator==(data); }
+};
+
+/**
+ * Node monitoring data.
+ */
+struct NodeMonitoringData {
+    StaticString<cNodeIDLen>                           mNodeID;
+    StaticArray<MonitoringData, cMonitoringItemsCount> mItems;
+
+    /**
+     * Compares node monitoring data.
+     *
+     * @param data node monitoring data to compare with.
+     * @return bool.
+     */
+    bool operator==(const NodeMonitoringData& data) const { return mNodeID == data.mNodeID && mItems == data.mItems; }
+
+    /**
+     * Compares node monitoring data.
+     *
+     * @param data node monitoring data to compare with.
+     * @return bool.
+     */
+    bool operator!=(const NodeMonitoringData& data) const { return !operator==(data); }
+};
+
+/**
+ * Instance monitoring data.
+ */
+struct InstanceMonitoringData {
+    InstanceIdent                                      mInstanceIdent;
+    StaticString<cNodeIDLen>                           mNodeID;
+    StaticArray<MonitoringData, cMonitoringItemsCount> mItems;
+
+    /**
+     * Compares instance monitoring data.
+     *
+     * @param data instance monitoring data to compare with.
+     * @return bool.
+     */
+    bool operator==(const InstanceMonitoringData& data) const
+    {
+        return mInstanceIdent == data.mInstanceIdent && mNodeID == data.mNodeID && mItems == data.mItems;
+    }
+
+    /**
+     * Compares instance monitoring data.
+     *
+     * @param data instance monitoring data to compare with.
+     * @return bool.
+     */
+    bool operator!=(const InstanceMonitoringData& data) const { return !operator==(data); }
+};
+
+/**
+ * Monitoring message type.
+ */
+struct Monitoring {
+    StaticArray<NodeMonitoringData, cMaxNumNodes>         mNodes;
+    StaticArray<InstanceMonitoringData, cMaxNumInstances> mServiceInstances;
+
+    /**
+     * Compares monitoring message.
+     *
+     * @param monitoring monitoring message to compare with.
+     * @return bool.
+     */
+    bool operator==(const Monitoring& monitoring) const
+    {
+        return mNodes == monitoring.mNodes && mServiceInstances == monitoring.mServiceInstances;
+    }
+
+    /**
+     * Compares monitoring message.
+     *
+     * @param monitoring monitoring message to compare with.
+     * @return bool.
+     */
+    bool operator!=(const Monitoring& monitoring) const { return !operator==(monitoring); }
+};
+
+} // namespace aos::cloudprotocol
+
+#endif
diff --git a/include/aos/common/cloudprotocol/provisioning.hpp b/include/aos/common/cloudprotocol/provisioning.hpp
new file mode 100644
index 000000000..1cd644b59
--- /dev/null
+++ b/include/aos/common/cloudprotocol/provisioning.hpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2025 EPAM Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef AOS_CLOUDPROTOCOL_PROVISIONING_HPP_
+#define AOS_CLOUDPROTOCOL_PROVISIONING_HPP_
+
+#include "aos/common/cloudprotocol/certificates.hpp"
+#include "aos/common/types.hpp"
+
+namespace aos::cloudprotocol {
+
+/**
+ * StartProvisioningRequest message.
+ */
+struct StartProvisioningRequest {
+    StaticString<cNodeIDLen>      mNodeID;
+    StaticString<cCertSecretSize> mPassword;
+
+    /**
+     * Compares start provisioning request.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const StartProvisioningRequest& other) const
+    {
+        return mNodeID == other.mNodeID && mPassword == other.mPassword;
+    }
+
+    /**
+     * Compares start provisioning request.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const StartProvisioningRequest& other) const { return !operator==(other); }
+};
+
+/**
+ * StartProvisioningResponse message.
+ */
+struct StartProvisioningResponse {
+    StaticString<cNodeIDLen>                       mNodeID;
+    Error                                          mError;
+    StaticArray<IssueCertData, cCertsPerUnitCount> mCSRs;
+
+    /**
+     * Compares start provisioning response.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const StartProvisioningResponse& other) const
+    {
+        return mNodeID == other.mNodeID && mError == other.mError && mCSRs == other.mCSRs;
+    }
+
+    /**
+     * Compares start provisioning response.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const StartProvisioningResponse& other) const { return !operator==(other); }
+};
+
+/**
+ * FinishProvisioningRequest message.
+ */
+struct FinishProvisioningRequest {
+    StaticString<cNodeIDLen>                        mNodeID;
+    StaticArray<IssuedCertData, cCertsPerUnitCount> mCertificates;
+    StaticString<cCertSecretSize>                   mPassword;
+
+    /**
+     * Compares finish provisioning request.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const FinishProvisioningRequest& other) const
+    {
+        return mNodeID == other.mNodeID && mCertificates == other.mCertificates && mPassword == other.mPassword;
+    }
+
+    /**
+     * Compares finish provisioning request.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const FinishProvisioningRequest& other) const { return !operator==(other); }
+};
+
+/**
+ * FinishProvisioningResponse message.
+ */
+struct FinishProvisioningResponse {
+    StaticString<cNodeIDLen> mNodeID;
+    Error                    mError;
+
+    /**
+     * Compares finish provisioning response.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const FinishProvisioningResponse& other) const
+    {
+        return mNodeID == other.mNodeID && mError == other.mError;
+    }
+
+    /**
+     * Compares finish provisioning response.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const FinishProvisioningResponse& other) const { return !operator==(other); }
+};
+
+/**
+ * DeprovisioningRequest message.
+ */
+struct DeprovisioningRequest {
+    StaticString<cNodeIDLen>      mNodeID;
+    StaticString<cCertSecretSize> mPassword;
+
+    /**
+     * Compares deprovisioning request.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const DeprovisioningRequest& other) const
+    {
+        return mNodeID == other.mNodeID && mPassword == other.mPassword;
+    }
+
+    /**
+     * Compares deprovisioning request.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const DeprovisioningRequest& other) const { return !operator==(other); }
+};
+
+/**
+ * DeprovisioningRequest message.
+ */
+struct DeprovisioningResponse {
+    StaticString<cNodeIDLen> mNodeID;
+    Error                    mError;
+
+    /**
+     * Compares deprovisioning response.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator==(const DeprovisioningResponse& other) const
+    {
+        return mNodeID == other.mNodeID && mError == other.mError;
+    }
+
+    /**
+     * Compares deprovisioning response.
+     *
+     * @param other object to compare with.
+     * @return bool.
+     */
+    bool operator!=(const DeprovisioningResponse& other) const { return !operator==(other); }
+};
+
+} // namespace aos::cloudprotocol
+
+#endif
diff --git a/include/aos/common/cloudprotocol/servicediscovery.hpp b/include/aos/common/cloudprotocol/servicediscovery.hpp
new file mode 100644
index 000000000..7e3b26a28
--- /dev/null
+++ b/include/aos/common/cloudprotocol/servicediscovery.hpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2025 EPAM Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef AOS_CLOUDPROTOCOL_SERVICEDISCOVERY_HPP_
+#define AOS_CLOUDPROTOCOL_SERVICEDISCOVERY_HPP_
+
+#include "aos/common/types.hpp"
+
+namespace aos::cloudprotocol {
+
+/**
+ * Service discovery supported protocols count.
+ */
+constexpr auto cServiceDiscoveryProtocolsCount = AOS_CONFIG_CLOUDPROTOCOL_SERVICE_DISCOVERY_PROTOCOLS_COUNT;
+
+/**
+ * Service discovery URLs count.
+ */
+constexpr auto cServiceDiscoveryURLsCount = AOS_CONFIG_CLOUDPROTOCOL_SERVICE_DISCOVERY_URLS_COUNT;
+
+/**
+ * Service discovery request.
+ */
+struct ServiceDiscoveryRequest {
+    size_t                                                                       mVersion {};
+    StaticString<cSystemIDLen>                                                   mSystemID;
+    StaticArray<StaticString<cProtocolNameLen>, cServiceDiscoveryProtocolsCount> mSupportedProtocols;
+
+    /**
+     * Compares service discovery request.
+     *
+     * @param request service discovery request to compare with.
+     * @return bool.
+     */
+    bool operator==(const ServiceDiscoveryRequest& request) const
+    {
+        return mVersion == request.mVersion && mSystemID == request.mSystemID
+            && mSupportedProtocols == request.mSupportedProtocols;
+    }
+
+    /**
+     * Compares service discovery request.
+     *
+     * @param request service discovery request to compare with.
+     * @return bool.
+     */
+    bool operator!=(const ServiceDiscoveryRequest& request) const { return !operator==(request); }
+};
+
+/**
+ * Service discovery response error code.
+ */
+class ServiceDiscoveryResponseErrorType {
+public:
+    enum class Enum { eNoError, eRedirect, eRepeatLater, eError };
+
+    static const Array<const char* const> GetStrings()
+    {
+        static const char* const sStrings[] = {"NoError", "Redirect", "RepeatLater", "Error"};
+        return Array<const char* const>(sStrings, ArraySize(sStrings));
+    };
+};
+
+using ServiceDiscoveryResponseErrorEnum = ServiceDiscoveryResponseErrorType::Enum;
+using ServiceDiscoveryResponseError     = EnumStringer<ServiceDiscoveryResponseErrorType>;
+
+/**
+ * Service discovery response.
+ */
+struct ServiceDiscoveryResponse {
+    size_t                                                         mVersion {};
+    StaticString<cSystemIDLen>                                     mSystemID;
+    Duration                                                       mNextRequestDelay;
+    StaticArray<StaticString<cURLLen>, cServiceDiscoveryURLsCount> mConnectionInfo;
+    StaticString<cBearerTokenLen>                                  mAuthToken;
+    ServiceDiscoveryResponseError                                  mErrorCode;
+
+    /**
+     * Compares service discovery response.
+     *
+     * @param response service discovery response to compare with.
+     * @return bool.
+     */
+    bool operator==(const ServiceDiscoveryResponse& response) const
+    {
+        return mVersion == response.mVersion && mSystemID == response.mSystemID
+            && mNextRequestDelay == response.mNextRequestDelay && mConnectionInfo == response.mConnectionInfo
+            && mAuthToken == response.mAuthToken && mErrorCode == response.mErrorCode;
+    }
+
+    /**
+     * Compares service discovery response.
+     *
+     * @param response service discovery response to compare with.
+     * @return bool.
+     */
+    bool operator!=(const ServiceDiscoveryResponse& response) const { return !operator==(response); }
+};
+
+} // namespace aos::cloudprotocol
+
+#endif
diff --git a/include/aos/common/cloudprotocol/state.hpp b/include/aos/common/cloudprotocol/state.hpp
index 4569ba680..1aa1ace36 100644
--- a/include/aos/common/cloudprotocol/state.hpp
+++ b/include/aos/common/cloudprotocol/state.hpp
@@ -63,6 +63,25 @@ struct BaseState {
 
     InstanceIdent mInstanceIdent;
     MessageType   mMessageType;
+
+    /**
+     * Compares base state.
+     *
+     * @param state base state to compare with.
+     * @return bool.
+     */
+    bool operator==(const BaseState& state) const
+    {
+        return mInstanceIdent == state.mInstanceIdent && mMessageType == state.mMessageType;
+    }
+
+    /**
+     * Compares base state.
+     *
+     * @param state base state to compare with.
+     * @return bool.
+     */
+    bool operator!=(const BaseState& state) const { return !operator==(state); }
 };
 
 /**
@@ -82,6 +101,26 @@ struct StateAcceptance : public BaseState {
     StaticString<crypto::cSHA2DigestSize> mChecksum;
     StateResult                           mResult;
     StaticString<cStateReason>            mReason;
+
+    /**
+     * Compares state acceptance.
+     *
+     * @param acceptance state acceptance to compare with.
+     * @return bool.
+     */
+    bool operator==(const StateAcceptance& acceptance) const
+    {
+        return BaseState::operator==(acceptance) && mChecksum == acceptance.mChecksum && mResult == acceptance.mResult
+            && mReason == acceptance.mReason;
+    }
+
+    /**
+     * Compares state acceptance.
+     *
+     * @param acceptance state acceptance to compare with.
+     * @return bool.
+     */
+    bool operator!=(const StateAcceptance& acceptance) const { return !operator==(acceptance); }
 };
 
 /**
@@ -100,6 +139,25 @@ struct UpdateState : public BaseState {
 
     StaticString<crypto::cSHA2DigestSize> mChecksum;
     StaticString<cStateLen>               mState;
+
+    /**
+     * Compares update state.
+     *
+     * @param state update state to compare with.
+     * @return bool.
+     */
+    bool operator==(const UpdateState& state) const
+    {
+        return BaseState::operator==(state) && mChecksum == state.mChecksum && mState == state.mState;
+    }
+
+    /**
+     * Compares update state.
+     *
+     * @param state update state to compare with.
+     * @return bool.
+     */
+    bool operator!=(const UpdateState& state) const { return !operator==(state); }
 };
 
 /**
@@ -118,6 +176,17 @@ struct NewState : public BaseState {
 
     StaticString<crypto::cSHA2DigestSize> mChecksum;
     StaticString<cStateLen>               mState;
+
+    /**
+     * Compares new state.
+     *
+     * @param state new state to compare with.
+     * @return bool.
+     */
+    bool operator==(const NewState& state) const
+    {
+        return BaseState::operator==(state) && mChecksum == state.mChecksum && mState == state.mState;
+    }
 };
 
 /**
@@ -135,6 +204,25 @@ struct StateRequest : public BaseState {
     }
 
     bool mDefault {};
+
+    /**
+     * Compares state request.
+     *
+     * @param request state request to compare with.
+     * @return bool.
+     */
+    bool operator==(const StateRequest& request) const
+    {
+        return BaseState::operator==(request) && mDefault == request.mDefault;
+    }
+
+    /**
+     * Compares state request.
+     *
+     * @param request state request to compare with.
+     * @return bool.
+     */
+    bool operator!=(const StateRequest& request) const { return !operator==(request); }
 };
 
 } // namespace aos::cloudprotocol
diff --git a/include/aos/common/cloudprotocol/unitstatus.hpp b/include/aos/common/cloudprotocol/unitstatus.hpp
new file mode 100644
index 000000000..cb444cf9b
--- /dev/null
+++ b/include/aos/common/cloudprotocol/unitstatus.hpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2025 EPAM Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef AOS_CLOUDPROTOCOL_UNITSTATUS_HPP_
+#define AOS_CLOUDPROTOCOL_UNITSTATUS_HPP_
+
+#include "aos/common/cloudprotocol/cloudprotocol.hpp"
+#include "aos/common/crypto/crypto.hpp"
+#include "aos/common/tools/optional.hpp"
+#include "aos/common/types.hpp"
+
+namespace aos::cloudprotocol {
+
+/**
+ * Annotations length.
+ */
+static constexpr auto cAnnotationsLen = AOS_CONFIG_CLOUDPROTOCOL_ANNOTATION_LEN;
+
+/**
+ * Component ID len.
+ */
+static constexpr auto cComponentIDLen = AOS_CONFIG_CLOUDPROTOCOL_COMPONENT_ID_LEN;
+
+/**
+ * Component type len.
+ */
+static constexpr auto cComponentTypeLen = AOS_CONFIG_CLOUDPROTOCOL_COMPONENT_TYPE_LEN;
+
+/**
+ * Unit config status count.
+ */
+static constexpr auto cUnitConfigStatusCount = AOS_CONFIG_CLOUDPROTOCOL_UNIT_CONFIG_STATUS_COUNT;
+
+/**
+ * Unit config status.
+ */
+struct UnitConfigStatus {
+    StaticString<cVersionLen> mVersion;
+    ItemStatus                mStatus;
+    Error                     mError;
+
+    /**
+     * Compares unit config status.
+     *
+     * @param status unit config status to compare with.
+     * @return bool.
+     */
+    bool operator==(const UnitConfigStatus& status) const
+    {
+        return mVersion == status.mVersion && mStatus == status.mStatus && mError == status.mError;
+    }
+
+    /**
+     * Compares unit config status.
+     *
+     * @param status unit config status to compare with.
+     * @return bool.
+     */
+    bool operator!=(const UnitConfigStatus& status) const { return !operator==(status); }
+};
+
+using UnitConfigStatusStaticArray = StaticArray<UnitConfigStatus, cUnitConfigStatusCount>;
+
+/**
+ * Component status.
+ */
+struct ComponentStatus {
+    StaticString<cComponentIDLen>           mComponentID;
+    StaticString<cComponentTypeLen>         mComponentType;
+    StaticString<cVersionLen>               mVersion;
+    Optional<StaticString<cNodeIDLen>>      mNodeID;
+    ItemStatus                              mStatus;
+    Optional<StaticString<cAnnotationsLen>> mAnnotations;
+    Error                                   mError;
+
+    /**
+     * Compares component status.
+     *
+     * @param status component status to compare with.
+     * @return bool.
+     */
+    bool operator==(const ComponentStatus& status) const
+    {
+        return mComponentID == status.mComponentID && mComponentType == status.mComponentType
+            && mVersion == status.mVersion && mNodeID == status.mNodeID && mStatus == status.mStatus
+            && mAnnotations == status.mAnnotations && mError == status.mError;
+    }
+
+    /**
+     * Compares component status.
+     *
+     * @param status component status to compare with.
+     * @return bool.
+     */
+    bool operator!=(const ComponentStatus& status) const { return !operator==(status); }
+};
+
+using ComponentStatusStaticArray = StaticArray<ComponentStatus, 2 * cMaxNumNodes>;
+
+/**
+ * Unit status
+ */
+struct UnitStatus {
+    UnitConfigStatusStaticArray         mUnitConfigStatus;
+    StaticArray<NodeInfo, cMaxNumNodes> mNodeInfo;
+    ServiceStatusStaticArray            mServiceStatus;
+    InstanceStatusStaticArray           mInstanceStatus;
+    LayerStatusStaticArray              mLayerStatus;
+    ComponentStatusStaticArray          mComponentStatus;
+    StaticString<cSubjectIDLen>         mUnitSubjects;
+
+    /**
+     * Compares unit status.
+     *
+     * @param status unit status to compare with.
+     * @return bool.
+     */
+    bool operator==(const UnitStatus& status) const
+    {
+        return mUnitConfigStatus == status.mUnitConfigStatus && mNodeInfo == status.mNodeInfo
+            && mServiceStatus == status.mServiceStatus && mInstanceStatus == status.mInstanceStatus
+            && mLayerStatus == status.mLayerStatus && mComponentStatus == status.mComponentStatus
+            && mUnitSubjects == status.mUnitSubjects;
+    }
+
+    /**
+     * Compares unit status.
+     *
+     * @param status unit status to compare with.
+     * @return bool.
+     */
+    bool operator!=(const UnitStatus& status) const { return !operator==(status); }
+};
+
+/**
+ * Delta unit status.
+ */
+struct DeltaUnitStatus {
+    Optional<UnitConfigStatusStaticArray>         mUnitConfigStatus;
+    Optional<StaticArray<NodeInfo, cMaxNumNodes>> mNodeInfo;
+    Optional<ServiceStatusStaticArray>            mServiceStatus;
+    Optional<InstanceStatusStaticArray>           mInstanceStatus;
+    Optional<LayerStatusStaticArray>              mLayerStatus;
+    Optional<ComponentStatusStaticArray>          mComponentStatus;
+    Optional<StaticString<cSubjectIDLen>>         mUnitSubjects;
+
+    /**
+     * Compares unit status.
+     *
+     * @param status unit status to compare with.
+     * @return bool.
+     */
+    bool operator==(const DeltaUnitStatus& status) const
+    {
+        return mUnitConfigStatus == status.mUnitConfigStatus && mNodeInfo == status.mNodeInfo
+            && mServiceStatus == status.mServiceStatus && mInstanceStatus == status.mInstanceStatus
+            && mLayerStatus == status.mLayerStatus && mComponentStatus == status.mComponentStatus
+            && mUnitSubjects == status.mUnitSubjects;
+    }
+
+    /**
+     * Compares unit status.
+     *
+     * @param status unit status to compare with.
+     * @return bool.
+     */
+    bool operator!=(const DeltaUnitStatus& status) const { return !operator==(status); }
+};
+
+} // namespace aos::cloudprotocol
+
+#endif
diff --git a/include/aos/common/config.hpp b/include/aos/common/config.hpp
index 20429b90e..6107c43b9 100644
--- a/include/aos/common/config.hpp
+++ b/include/aos/common/config.hpp
@@ -704,6 +704,13 @@
 #define AOS_CONFIG_CRYPTO_SIGNATURE_SIZE 512
 #endif
 
+/**
+ * Maximum len of a certificate chain string representation.
+ */
+#ifndef AOS_CONFIG_CRYPTO_CERTIFICATE_CHAIN_LEN
+#define AOS_CONFIG_CRYPTO_CERTIFICATE_CHAIN_LEN 4 * 1024
+#endif
+
 /**
  * Max expected number of certificates in a chain stored in PEM file.
  */
@@ -991,6 +998,13 @@
 #define AOS_CONFIG_CLOUDPROTOCOL_ALERT_RESOURCE_ERRORS_SIZE 4
 #endif
 
+/**
+ * Alert items count.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_ALERT_ITEMS_COUNT
+#define AOS_CONFIG_CLOUDPROTOCOL_ALERT_ITEMS_COUNT 16
+#endif
+
 /**
  * Environment variable name value.
  */
@@ -1026,6 +1040,70 @@
 #define AOS_CONFIG_CLOUDPROTOCOL_STATE_LEN 64 * 1024
 #endif
 
+/**
+ * Annotation len.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_ANNOTATION_LEN
+#define AOS_CONFIG_CLOUDPROTOCOL_ANNOTATION_LEN 16 * 1024
+#endif
+
+/**
+ * Component ID len.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_COMPONENT_ID_LEN
+#define AOS_CONFIG_CLOUDPROTOCOL_COMPONENT_ID_LEN 64
+#endif
+
+/**
+ * Component type len.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_COMPONENT_TYPE_LEN
+#define AOS_CONFIG_CLOUDPROTOCOL_COMPONENT_TYPE_LEN 64
+#endif
+
+/**
+ * Unit config status count.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_UNIT_CONFIG_STATUS_COUNT
+#define AOS_CONFIG_CLOUDPROTOCOL_UNIT_CONFIG_STATUS_COUNT 2
+#endif
+
+/**
+ * Monitoring items count.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_MONITORING_ITEMS_COUNT
+#define AOS_CONFIG_CLOUDPROTOCOL_MONITORING_ITEMS_COUNT 16
+#endif
+
+/**
+ * Certificate secret size.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_CERTIFICATE_SECRET_SIZE
+#define AOS_CONFIG_CLOUDPROTOCOL_CERTIFICATE_SECRET_SIZE 64
+#endif
+
+/**
+ * Certificate installation description size.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_CERTIFICATE_INSTALLATION_DESCRIPTION_SIZE
+#define AOS_CONFIG_CLOUDPROTOCOL_CERTIFICATE_INSTALLATION_DESCRIPTION_SIZE 1024
+#endif
+
+/**
+ * Service discovery supported protocols count.
+ */
+
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_SERVICE_DISCOVERY_PROTOCOLS_COUNT
+#define AOS_CONFIG_CLOUDPROTOCOL_SERVICE_DISCOVERY_PROTOCOLS_COUNT 1
+#endif
+
+/**
+ * Service discovery URLs count.
+ */
+#ifndef AOS_CONFIG_CLOUDPROTOCOL_SERVICE_DISCOVERY_URLS_COUNT
+#define AOS_CONFIG_CLOUDPROTOCOL_SERVICE_DISCOVERY_URLS_COUNT 8
+#endif
+
 /**
  * Maximum supported number of timers.
  */
diff --git a/include/aos/common/crypto/crypto.hpp b/include/aos/common/crypto/crypto.hpp
index 98a9ed9c6..605481c0b 100644
--- a/include/aos/common/crypto/crypto.hpp
+++ b/include/aos/common/crypto/crypto.hpp
@@ -124,11 +124,21 @@ constexpr auto cECDSAParamsOIDSize = AOS_CONFIG_CRYPTO_ECDSA_PARAMS_OID_SIZE;
  */
 constexpr auto cECDSAPointDERSize = AOS_CONFIG_CRYPTO_ECDSA_POINT_DER_SIZE;
 
+/**
+ * Maximum len of a certificate chain string representation.
+ */
+constexpr auto cCertChainLen = AOS_CONFIG_CRYPTO_CERTIFICATE_CHAIN_LEN;
+
 /**
  * Max expected number of certificates in a chain stored in PEM file.
  */
 constexpr auto cCertChainSize = AOS_CONFIG_CRYPTO_CERTS_CHAIN_SIZE;
 
+/**
+ * Number of certificate chains to be stored in crypto::CertLoader.
+ */
+constexpr auto cCertChainsCount = AOS_CONFIG_CRYPTO_CERTIFICATE_CHAINS_COUNT;
+
 /**
  * Maximum size of SHA2 digest.
  */
diff --git a/include/aos/common/crypto/utils.hpp b/include/aos/common/crypto/utils.hpp
index f7375915b..5196651ee 100644
--- a/include/aos/common/crypto/utils.hpp
+++ b/include/aos/common/crypto/utils.hpp
@@ -76,7 +76,7 @@ class CertLoader : public CertLoaderItf {
     using PEMCertChainBlob = StaticString<crypto::cCertPEMLen * crypto::cCertChainSize>;
 
     static constexpr auto cCertAllocatorSize
-        = AOS_CONFIG_CRYPTO_CERTIFICATE_CHAINS_COUNT * crypto::cCertChainSize * sizeof(crypto::x509::Certificate)
+        = crypto::cCertChainsCount * crypto::cCertChainSize * sizeof(crypto::x509::Certificate)
         + sizeof(PEMCertChainBlob);
     static constexpr auto cKeyAllocatorSize
         = AOS_CONFIG_CRYPTO_KEYS_COUNT * pkcs11::cPrivateKeyMaxSize + sizeof(crypto::cPrivKeyPEMLen);
diff --git a/include/aos/common/monitoring/resourcemonitor.hpp b/include/aos/common/monitoring/resourcemonitor.hpp
index f178292e9..fe62dbad1 100644
--- a/include/aos/common/monitoring/resourcemonitor.hpp
+++ b/include/aos/common/monitoring/resourcemonitor.hpp
@@ -128,7 +128,7 @@ class ResourceMonitor : public ResourceMonitorItf,
     Error SetupAlerts(
         const ResourceIdentifier identifierTemplate, const AlertRules& rules, Array<AlertProcessor>& alertProcessors);
 
-    Error SetupSystemAlerts(const NodeConfig& nodeConfig);
+    Error SetupSystemAlerts(const cloudprotocol::NodeConfig& nodeConfig);
     Error SetupInstanceAlerts(const String& instanceID, const InstanceMonitorParams& instanceParams);
     void  NormalizeMonitoringData();
     void  ProcessMonitoring();
diff --git a/include/aos/common/tools/enum.hpp b/include/aos/common/tools/enum.hpp
index c3e2e9664..5f661f68b 100644
--- a/include/aos/common/tools/enum.hpp
+++ b/include/aos/common/tools/enum.hpp
@@ -25,7 +25,7 @@ class EnumStringer : public Stringer {
      *
      * @param value curent enum value.
      */
-    EnumStringer()
+    constexpr EnumStringer()
         : mValue(static_cast<EnumType>(0)) {};
 
     // cppcheck-suppress noExplicitConstructor
@@ -35,7 +35,7 @@ class EnumStringer : public Stringer {
      *
      * @param value curent enum value.
      */
-    EnumStringer(EnumType value)
+    constexpr EnumStringer(EnumType value)
         : mValue(value) {};
 
     /**
diff --git a/include/aos/common/types.hpp b/include/aos/common/types.hpp
index 76f9cec48..94ab71d72 100644
--- a/include/aos/common/types.hpp
+++ b/include/aos/common/types.hpp
@@ -388,6 +388,11 @@ static constexpr auto cMaxNumExposedPorts = AOS_CONFIG_MAX_NUM_EXPOSED_PORTS;
  */
 static constexpr auto cExposedPortLen = cPortLen + cProtocolNameLen;
 
+/**
+ * Bearer token len.
+ */
+constexpr auto cBearerTokenLen = AOS_CONFIG_CLOUDPROTOCOL_BEARER_TOKEN_LEN;
+
 /**
  * Instance identification.
  */
@@ -564,10 +569,12 @@ using InstanceRunState     = EnumStringer<InstanceRunStateType>;
  * Instance status.
  */
 struct InstanceStatus {
-    InstanceIdent             mInstanceIdent;
-    StaticString<cVersionLen> mServiceVersion;
-    InstanceRunState          mRunState;
-    Error                     mError;
+    InstanceIdent                   mInstanceIdent;
+    StaticString<cVersionLen>       mServiceVersion;
+    StaticString<2 * cSHA3_224Size> mStateChecksum;
+    InstanceRunState                mStatus;
+    StaticString<cNodeIDLen>        mNodeID;
+    Error                           mError;
 
     /**
      * Compares instance status.
@@ -578,7 +585,8 @@ struct InstanceStatus {
     bool operator==(const InstanceStatus& instance) const
     {
         return mInstanceIdent == instance.mInstanceIdent && mServiceVersion == instance.mServiceVersion
-            && mRunState == instance.mRunState && mError == instance.mError;
+            && mStateChecksum == instance.mStateChecksum && mStatus == instance.mStatus && mNodeID == instance.mNodeID
+            && mError == instance.mError;
     }
 
     /**
@@ -610,6 +618,7 @@ class ItemStatusType {
         eRemoving,
         eRemoved,
         eError,
+        eFailed,
     };
 
     static const Array<const char* const> GetStrings()
@@ -624,6 +633,7 @@ class ItemStatusType {
             "removing",
             "removed",
             "error",
+            "failed",
         };
 
         return Array<const char* const>(sStrings, ArraySize(sStrings));
@@ -1151,39 +1161,6 @@ struct ResourceRatios {
     bool operator!=(const ResourceRatios& ratios) const { return !operator==(ratios); }
 };
 
-/**
- * Node config.
- */
-struct NodeConfig {
-    StaticString<cNodeTypeLen>                                  mNodeType;
-    StaticArray<DeviceInfo, cMaxNumNodeDevices>                 mDevices;
-    StaticArray<ResourceInfo, cMaxNumNodeResources>             mResources;
-    StaticArray<StaticString<cLabelNameLen>, cMaxNumNodeLabels> mLabels;
-    uint32_t                                                    mPriority {0};
-    Optional<AlertRules>                                        mAlertRules;
-    Optional<ResourceRatios>                                    mResourceRatios;
-
-    /**
-     * Compares node configs.
-     *
-     * @param nodeConfig node config to compare.
-     * @return bool.
-     */
-    bool operator==(const NodeConfig& nodeConfig) const
-    {
-        return mNodeType == nodeConfig.mNodeType && mDevices == nodeConfig.mDevices
-            && mResources == nodeConfig.mResources && mLabels == nodeConfig.mLabels && mPriority == nodeConfig.mPriority
-            && mAlertRules == nodeConfig.mAlertRules && mResourceRatios == nodeConfig.mResourceRatios;
-    }
-
-    /**
-     * Compares node configs.
-     *
-     * @param nodeConfig node config to compare.
-     * @return bool.
-     */
-    bool operator!=(const NodeConfig& nodeConfig) const { return !operator==(nodeConfig); }
-};
 /**
  * Partition info.
  */
diff --git a/include/aos/sm/launcher/instance.hpp b/include/aos/sm/launcher/instance.hpp
index 1cf853942..572f1aee6 100644
--- a/include/aos/sm/launcher/instance.hpp
+++ b/include/aos/sm/launcher/instance.hpp
@@ -257,6 +257,14 @@ class Instance {
         return fs::DirExist(fs::JoinPath(cRuntimeDir, instanceID));
     };
 
+    /**
+     * Converts instance object to instance status.
+     *
+     * @param instanceStatus[out] instance status.
+     * @return Error.
+     */
+    Error ToInstanceStatus(InstanceStatus& instanceStatus) const;
+
     /**
      * Compares instances.
      *
diff --git a/include/aos/sm/resourcemanager.hpp b/include/aos/sm/resourcemanager.hpp
index af79dabe6..92db2fdb2 100644
--- a/include/aos/sm/resourcemanager.hpp
+++ b/include/aos/sm/resourcemanager.hpp
@@ -8,6 +8,7 @@
 #ifndef AOS_RESOURCEMANAGER_HPP_
 #define AOS_RESOURCEMANAGER_HPP_
 
+#include "aos/common/cloudprotocol/desiredstatus.hpp"
 #include "aos/common/tools/error.hpp"
 #include "aos/common/tools/map.hpp"
 #include "aos/common/tools/memory.hpp"
@@ -28,7 +29,7 @@ static constexpr auto cNodeConfigJSONLen = AOS_CONFIG_RESOURCEMANAGER_NODE_CONFI
  * Node Config.
  */
 struct NodeConfig {
-    aos::NodeConfig           mNodeConfig;
+    cloudprotocol::NodeConfig mNodeConfig;
     StaticString<cVersionLen> mVersion;
 
     /**
@@ -149,7 +150,7 @@ class ResourceManagerItf {
      * @param nodeConfig[out] param to store node config.
      * @return Error.
      */
-    virtual Error GetNodeConfig(aos::NodeConfig& nodeConfig) const = 0;
+    virtual Error GetNodeConfig(cloudprotocol::NodeConfig& nodeConfig) const = 0;
 
     /**
      * Gets device info by name.
@@ -278,7 +279,7 @@ class ResourceManager : public ResourceManagerItf, private NonCopyable {
      * @param nodeConfig[out] param to store node config.
      * @return Error.
      */
-    Error GetNodeConfig(aos::NodeConfig& nodeConfig) const override;
+    Error GetNodeConfig(cloudprotocol::NodeConfig& nodeConfig) const override;
 
     /**
      * Gets device info by name.
diff --git a/src/common/monitoring/resourcemonitor.cpp b/src/common/monitoring/resourcemonitor.cpp
index d033cefd3..a68bbe89d 100644
--- a/src/common/monitoring/resourcemonitor.cpp
+++ b/src/common/monitoring/resourcemonitor.cpp
@@ -275,7 +275,7 @@ double ResourceMonitor::CPUToDMIPs(double cpuPersentage) const
     return cpuPersentage * static_cast<double>(mMaxDMIPS) / 100.0;
 }
 
-Error ResourceMonitor::SetupSystemAlerts(const NodeConfig& nodeConfig)
+Error ResourceMonitor::SetupSystemAlerts(const cloudprotocol::NodeConfig& nodeConfig)
 {
     LOG_DBG() << "Setup system alerts";
 
diff --git a/src/sm/launcher/instance.cpp b/src/sm/launcher/instance.cpp
index 6e441e125..bf66167ae 100644
--- a/src/sm/launcher/instance.cpp
+++ b/src/sm/launcher/instance.cpp
@@ -188,6 +188,23 @@ void Instance::SetOverrideEnvVars(const Array<StaticString<cEnvVarLen>>& envVars
     mOverrideEnvVars = envVars;
 };
 
+Error Instance::ToInstanceStatus(InstanceStatus& instanceStatus) const
+{
+    instanceStatus.mInstanceIdent = mInstanceInfo.mInstanceIdent;
+    instanceStatus.mStatus        = mRunState;
+    instanceStatus.mError         = mRunError;
+
+    if (auto err = instanceStatus.mServiceVersion.Assign(mService.mVersion); !err.IsNone()) {
+        return AOS_ERROR_WRAP(err);
+    }
+
+    if (auto err = instanceStatus.mNodeID.Assign(mNodeInfo.mNodeID); !err.IsNone()) {
+        return AOS_ERROR_WRAP(err);
+    }
+
+    return ErrorEnum::eNone;
+}
+
 /***********************************************************************************************************************
  * Private
  **********************************************************************************************************************/
diff --git a/src/sm/launcher/launcher.cpp b/src/sm/launcher/launcher.cpp
index 2ae4082b5..facc1ecb0 100644
--- a/src/sm/launcher/launcher.cpp
+++ b/src/sm/launcher/launcher.cpp
@@ -207,9 +207,11 @@ Error Launcher::GetCurrentRunStatus(Array<InstanceStatus>& instances) const
                       << ", err=" << instance.RunError();
         }
 
-        if (auto err = instances.PushBack({instance.Info().mInstanceIdent, instance.GetServiceVersion(),
-                instance.RunState(), instance.RunError()});
-            !err.IsNone()) {
+        if (auto err = instances.EmplaceBack(); !err.IsNone()) {
+            return AOS_ERROR_WRAP(err);
+        }
+
+        if (auto err = instance.ToInstanceStatus(instances.Back()); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
         }
     }
@@ -270,10 +272,11 @@ Error Launcher::UpdateRunStatus(const Array<runner::RunStatus>& instances)
                               << ", err=" << currentInstance->RunError();
                 }
 
-                if (auto err
-                    = status->PushBack({currentInstance->Info().mInstanceIdent, currentInstance->GetServiceVersion(),
-                        currentInstance->RunState(), currentInstance->RunError()});
-                    !err.IsNone()) {
+                if (auto err = status->EmplaceBack(); !err.IsNone()) {
+                    return AOS_ERROR_WRAP(err);
+                }
+
+                if (auto err = currentInstance->ToInstanceStatus(status->Back()); !err.IsNone()) {
                     return AOS_ERROR_WRAP(err);
                 }
             }
@@ -521,9 +524,11 @@ Error Launcher::SendRunStatus()
                       << ", err=" << instance.RunError();
         }
 
-        if (auto err = status->PushBack({instance.Info().mInstanceIdent, instance.GetServiceVersion(),
-                instance.RunState(), instance.RunError()});
-            !err.IsNone()) {
+        if (auto err = status->EmplaceBack(); !err.IsNone()) {
+            return AOS_ERROR_WRAP(err);
+        }
+
+        if (auto err = instance.ToInstanceStatus(status->Back()); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
         }
     }
@@ -559,10 +564,14 @@ Error Launcher::SendOutdatedInstancesStatus(const Array<InstanceData>& instances
         LOG_ERR() << "Instance status: instanceID=" << instance.mInstanceID << ", serviceVersion=" << serviceVersion
                   << ", runState=" << runState << ", err=" << runErr;
 
-        if (auto err = status->PushBack({instance.mInstanceInfo.mInstanceIdent, serviceVersion, runState, runErr});
-            !err.IsNone()) {
+        if (auto err = status->EmplaceBack(); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
         }
+
+        status->Back().mInstanceIdent  = instance.mInstanceInfo.mInstanceIdent;
+        status->Back().mServiceVersion = serviceVersion;
+        status->Back().mStatus         = runState;
+        status->Back().mError          = runErr;
     }
 
     LOG_DBG() << "Send update status";
@@ -1227,9 +1236,11 @@ Error Launcher::SendEnvChangedInstancesStatus(const Array<InstanceData>& instanc
                       << ", err=" << instance->RunError();
         }
 
-        if (auto err = status->PushBack({instance->Info().mInstanceIdent, instance->GetServiceVersion(),
-                instance->RunState(), instance->RunError()});
-            !err.IsNone()) {
+        if (auto err = status->EmplaceBack(); !err.IsNone()) {
+            return AOS_ERROR_WRAP(err);
+        }
+
+        if (auto err = instance->ToInstanceStatus(status->Back()); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
         }
     }
diff --git a/src/sm/resourcemanager/resourcemanager.cpp b/src/sm/resourcemanager/resourcemanager.cpp
index ea07556a6..eee6f5ccc 100644
--- a/src/sm/resourcemanager/resourcemanager.cpp
+++ b/src/sm/resourcemanager/resourcemanager.cpp
@@ -50,7 +50,7 @@ RetWithError<StaticString<cVersionLen>> ResourceManager::GetNodeConfigVersion()
     return {mConfig->mVersion, mConfigError};
 }
 
-Error ResourceManager::GetNodeConfig(aos::NodeConfig& nodeConfig) const
+Error ResourceManager::GetNodeConfig(cloudprotocol::NodeConfig& nodeConfig) const
 {
     LockGuard lock {mMutex};
 
diff --git a/tests/common/src/monitoring_test.cpp b/tests/common/src/monitoring_test.cpp
index dcb32de8c..b72eb6371 100644
--- a/tests/common/src/monitoring_test.cpp
+++ b/tests/common/src/monitoring_test.cpp
@@ -122,7 +122,7 @@ class MockResourceManager : public sm::resourcemanager::ResourceManagerItf {
 
     RetWithError<StaticString<cVersionLen>> GetNodeConfigVersion() const override { return mConfig.mVersion; }
 
-    Error GetNodeConfig(aos::NodeConfig& nodeConfig) const override
+    Error GetNodeConfig(cloudprotocol::NodeConfig& nodeConfig) const override
     {
         nodeConfig = mConfig.mNodeConfig;
 
diff --git a/tests/common/src/types_test.cpp b/tests/common/src/types_test.cpp
index 098f016a0..b163e4e0d 100644
--- a/tests/common/src/types_test.cpp
+++ b/tests/common/src/types_test.cpp
@@ -24,9 +24,12 @@ TEST(CommonTest, Types)
         != (InstanceInfo {{"service1", "subject1", 2}, 3, 4, "state", "storage", {}}));
 
     // InstanceStatus comparision
-    EXPECT_TRUE((InstanceStatus {{"service1", "subject1", 2}, "3.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone})
-        == (InstanceStatus {{"service1", "subject1", 2}, "3.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone}));
+    EXPECT_TRUE(
+        (InstanceStatus {{"service1", "subject1", 2}, "3.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone})
+        == (InstanceStatus {
+            {"service1", "subject1", 2}, "3.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone}));
     EXPECT_FALSE(
-        (InstanceStatus {{"service1", "subject1", 2}, "3.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone})
-        != (InstanceStatus {{"service1", "subject1", 2}, "3.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone}));
+        (InstanceStatus {{"service1", "subject1", 2}, "3.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone})
+        != (InstanceStatus {
+            {"service1", "subject1", 2}, "3.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone}));
 }
diff --git a/tests/include/mocks/communicationmock.hpp b/tests/include/mocks/communicationmock.hpp
index 888f1c67a..0f54d1bf9 100644
--- a/tests/include/mocks/communicationmock.hpp
+++ b/tests/include/mocks/communicationmock.hpp
@@ -18,8 +18,7 @@ namespace aos::cm::communication {
  */
 class CommunicationMock : public CommunicationItf {
 public:
-    MOCK_METHOD(Error, SendInstanceNewState, (const cloudprotocol::NewState& newState), (override));
-    MOCK_METHOD(Error, SendInstanceStateRequest, (const cloudprotocol::StateRequest& stateRequest), (override));
+    MOCK_METHOD(Error, SendMessage, (const cloudprotocol::MessageVariant& body), (override));
 };
 
 } // namespace aos::cm::communication
diff --git a/tests/include/mocks/resourcemanagermock.hpp b/tests/include/mocks/resourcemanagermock.hpp
index 52ecc9641..9028a2eba 100644
--- a/tests/include/mocks/resourcemanagermock.hpp
+++ b/tests/include/mocks/resourcemanagermock.hpp
@@ -47,7 +47,7 @@ class NodeConfigReceiverMock : public NodeConfigReceiverItf {
 class ResourceManagerMock : public ResourceManagerItf {
 public:
     MOCK_METHOD(RetWithError<StaticString<cVersionLen>>, GetNodeConfigVersion, (), (const override));
-    MOCK_METHOD(Error, GetNodeConfig, (aos::NodeConfig&), (const override));
+    MOCK_METHOD(Error, GetNodeConfig, (cloudprotocol::NodeConfig&), (const override));
     MOCK_METHOD(Error, GetDeviceInfo, (const String&, DeviceInfo&), (const override));
     MOCK_METHOD(Error, GetResourceInfo, (const String&, ResourceInfo&), (const override));
     MOCK_METHOD(Error, AllocateDevice, (const String&, const String&), (override));
diff --git a/tests/sm/launcher/launcher_test.cpp b/tests/sm/launcher/launcher_test.cpp
index 4919fd0a1..cfe456249 100644
--- a/tests/sm/launcher/launcher_test.cpp
+++ b/tests/sm/launcher/launcher_test.cpp
@@ -199,9 +199,9 @@ TEST_F(LauncherTest, RunInstances)
             },
             {},
             std::vector<InstanceStatus> {
-                {{"service0", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service1", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service2", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
+                {{"service0", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service1", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service2", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
             },
             {},
         },
@@ -219,9 +219,9 @@ TEST_F(LauncherTest, RunInstances)
             },
             {},
             std::vector<InstanceStatus> {
-                {{"service0", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service1", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service2", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
+                {{"service0", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service1", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service2", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
             },
             {},
         },
@@ -239,9 +239,9 @@ TEST_F(LauncherTest, RunInstances)
             },
             {},
             std::vector<InstanceStatus> {
-                {{"service0", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service2", "subject0", 1}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service3", "subject0", 2}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
+                {{"service0", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service2", "subject0", 1}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service3", "subject0", 2}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
             },
             {},
         },
@@ -259,9 +259,9 @@ TEST_F(LauncherTest, RunInstances)
             },
             {},
             std::vector<InstanceStatus> {
-                {{"service0", "subject0", 0}, "2.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service2", "subject0", 1}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
-                {{"service3", "subject0", 2}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
+                {{"service0", "subject0", 0}, "2.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service2", "subject0", 1}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
+                {{"service3", "subject0", 2}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
             },
             {},
         },
@@ -279,9 +279,9 @@ TEST_F(LauncherTest, RunInstances)
             },
             {},
             std::vector<InstanceStatus> {
-                {{"service0", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eFailed, ErrorEnum::eNotFound},
-                {{"service1", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eFailed, ErrorEnum::eNotFound},
-                {{"service2", "subject0", 0}, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone},
+                {{"service0", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eFailed, "", ErrorEnum::eNotFound},
+                {{"service1", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eFailed, "", ErrorEnum::eNotFound},
+                {{"service2", "subject0", 0}, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone},
             },
             {
                 {InstanceIdent {"service0", "subject0", 0}, ErrorEnum::eNotFound},
@@ -345,7 +345,7 @@ TEST_F(LauncherTest, RunMaxInstances)
         InstanceIdent ident     = {serviceID.c_str(), "subject0", i / cMaxNumServices};
 
         testItem.mInstances.push_back({ident, 0, 0, "", "", {}});
-        testItem.mStatus.push_back({ident, "1.0.0", InstanceRunStateEnum::eActive, ErrorEnum::eNone});
+        testItem.mStatus.push_back({ident, "1.0.0", "", InstanceRunStateEnum::eActive, "", ErrorEnum::eNone});
     }
 
     for (size_t i = 0; i < static_cast<size_t>(std::min(cMaxNumServices, cMaxNumInstances)); i++) {
diff --git a/tests/sm/resourcemanager/resourcemanager_test.cpp b/tests/sm/resourcemanager/resourcemanager_test.cpp
index be7769de7..2bc3843ca 100644
--- a/tests/sm/resourcemanager/resourcemanager_test.cpp
+++ b/tests/sm/resourcemanager/resourcemanager_test.cpp
@@ -114,7 +114,7 @@ TEST_F(ResourceManagerTest, InitSucceeds)
 {
     InitResourceManager();
 
-    aos::NodeConfig nodeConfig;
+    cloudprotocol::NodeConfig nodeConfig;
 
     ASSERT_TRUE(mResourceManager.GetNodeConfig(nodeConfig).IsNone());
     EXPECT_EQ(nodeConfig, mConfig.mNodeConfig);
@@ -145,7 +145,7 @@ TEST_F(ResourceManagerTest, InitSucceedsWhenNodeConfigParseFails)
 
     InitResourceManager(expectedError);
 
-    aos::NodeConfig nodeConfig;
+    cloudprotocol::NodeConfig nodeConfig;
 
     ASSERT_TRUE(mResourceManager.GetNodeConfig(nodeConfig).Is(expectedError));
 }