diff --git a/RuntimeInfo-host.cpp b/RuntimeInfo-host.cpp
index 96eff42..bd46a9f 100644
--- a/RuntimeInfo-host.cpp
+++ b/RuntimeInfo-host.cpp
@@ -23,7 +23,7 @@
 namespace android {
 namespace vintf {
 
-status_t RuntimeInfo::fetchAllInformation() {
+status_t RuntimeInfo::fetchAllInformation(RuntimeInfo::FetchFlags /* flags */) {
     LOG(WARNING) << "Should not run fetchAllInformation on host.";
     return OK;
 }
diff --git a/RuntimeInfo-target.cpp b/RuntimeInfo-target.cpp
index 9518a0c..1bdf2c3 100644
--- a/RuntimeInfo-target.cpp
+++ b/RuntimeInfo-target.cpp
@@ -45,8 +45,9 @@
 
 struct RuntimeInfoFetcher {
     RuntimeInfoFetcher(RuntimeInfo *ki) : mRuntimeInfo(ki) { }
-    status_t fetchAllInformation();
-private:
+    status_t fetchAllInformation(RuntimeInfo::FetchFlags flags);
+
+   private:
     status_t fetchVersion();
     status_t fetchKernelConfigs();
     status_t fetchCpuInfo();
@@ -159,28 +160,31 @@
     return OK;
 }
 
-status_t RuntimeInfoFetcher::fetchAllInformation() {
+status_t RuntimeInfoFetcher::fetchAllInformation(RuntimeInfo::FetchFlags flags) {
+
+    using F = RuntimeInfo::FetchFlag;
+    using RF = RuntimeInfoFetcher;
+    using FetchFunction = status_t(RF::*)();
+    const static std::vector<std::tuple<F, FetchFunction, std::string>> gFetchFunctions({
+        // flag          fetch function                 description
+        {F::CPU_VERSION, &RF::fetchVersion,             "/proc/version"},
+        {F::CONFIG_GZ,   &RF::fetchKernelConfigs,       "/proc/config.gz"},
+        {F::CPU_INFO,    &RF::fetchCpuInfo,             "/proc/cpuinfo"},
+        {F::POLICYVERS,  &RF::fetchKernelSepolicyVers,  "kernel sepolicy version"},
+        {F::AVB,         &RF::fetchAvb,                 "avb version"},
+    });
+
     status_t err;
-    if ((err = fetchVersion()) != OK) {
-        LOG(WARNING) << "Cannot fetch or parse /proc/version: " << strerror(-err);
-    }
-    if ((err = fetchKernelConfigs()) != OK) {
-        LOG(WARNING) << "Cannot fetch or parse /proc/config.gz: " << strerror(-err);
-    }
-    if ((err = fetchCpuInfo()) != OK) {
-        LOG(WARNING) << "Cannot fetch /proc/cpuinfo: " << strerror(-err);
-    }
-    if ((err = fetchKernelSepolicyVers()) != OK) {
-        LOG(WARNING) << "Cannot fetch kernel sepolicy version: " << strerror(-err);
-    }
-    if ((err = fetchAvb()) != OK) {
-        LOG(WARNING) << "Cannot fetch sepolicy avb version: " << strerror(-err);
-    }
+    for (const auto& tuple : gFetchFunctions)
+        if ((flags & std::get<0>(tuple)) && (err = (*this.*std::get<1>(tuple))()) != OK)
+            LOG(WARNING) << "Cannot fetch or parse " << std::get<2>(tuple) << ": "
+                         << strerror(-err);
+
     return OK;
 }
 
-status_t RuntimeInfo::fetchAllInformation() {
-    return RuntimeInfoFetcher(this).fetchAllInformation();
+status_t RuntimeInfo::fetchAllInformation(RuntimeInfo::FetchFlags flags) {
+    return RuntimeInfoFetcher(this).fetchAllInformation(flags);
 }
 
 } // namespace vintf
diff --git a/VintfObject.cpp b/VintfObject.cpp
index 92fa0b0..e87dd05 100644
--- a/VintfObject.cpp
+++ b/VintfObject.cpp
@@ -33,6 +33,12 @@
     std::mutex mutex;
 };
 
+struct LockedRuntimeInfoCache {
+    std::shared_ptr<RuntimeInfo> object;
+    std::mutex mutex;
+    RuntimeInfo::FetchFlags fetchedFlags = RuntimeInfo::FetchFlag::NONE;
+};
+
 template <typename T, typename F>
 static std::shared_ptr<const T> Get(
         LockedSharedPtr<T> *ptr,
@@ -82,10 +88,27 @@
 }
 
 // static
-std::shared_ptr<const RuntimeInfo> VintfObject::GetRuntimeInfo(bool skipCache) {
-    static LockedSharedPtr<RuntimeInfo> gDeviceRuntimeInfo;
-    return Get(&gDeviceRuntimeInfo, skipCache,
-            std::bind(&RuntimeInfo::fetchAllInformation, std::placeholders::_1));
+std::shared_ptr<const RuntimeInfo> VintfObject::GetRuntimeInfo(bool skipCache,
+                                                               RuntimeInfo::FetchFlags flags) {
+    static LockedRuntimeInfoCache gDeviceRuntimeInfo;
+    std::unique_lock<std::mutex> _lock(gDeviceRuntimeInfo.mutex);
+
+    if (!skipCache) {
+        flags &= (~gDeviceRuntimeInfo.fetchedFlags);
+    }
+
+    if (gDeviceRuntimeInfo.object == nullptr) {
+        gDeviceRuntimeInfo.object = std::make_shared<RuntimeInfo>();
+    }
+
+    status_t status = gDeviceRuntimeInfo.object->fetchAllInformation(flags);
+    if (status != OK) {
+        gDeviceRuntimeInfo.fetchedFlags &= (~flags);  // mark the fields as "not fetched"
+        return nullptr;
+    }
+
+    gDeviceRuntimeInfo.fetchedFlags |= flags;
+    return gDeviceRuntimeInfo.object;
 }
 
 namespace details {
diff --git a/include/vintf/RuntimeInfo.h b/include/vintf/RuntimeInfo.h
index 1505c15..390e3ed 100644
--- a/include/vintf/RuntimeInfo.h
+++ b/include/vintf/RuntimeInfo.h
@@ -74,13 +74,26 @@
     bool checkCompatibility(const CompatibilityMatrix& mat, std::string* error = nullptr,
                             DisabledChecks disabledChecks = ENABLE_ALL_CHECKS) const;
 
+    using FetchFlags = uint32_t;
+    enum FetchFlag : FetchFlags {
+        CPU_VERSION     = 1 << 0,
+        CONFIG_GZ       = 1 << 1,
+        CPU_INFO        = 1 << 2,
+        POLICYVERS      = 1 << 3,
+        AVB             = 1 << 4,
+        LAST_PLUS_ONE,
+
+        NONE = 0,
+        ALL = ((LAST_PLUS_ONE - 1) << 1) - 1,
+    };
+
    private:
     friend struct RuntimeInfoFetcher;
     friend class VintfObject;
     friend struct LibVintfTest;
     friend std::string dump(const RuntimeInfo &ki);
 
-    status_t fetchAllInformation();
+    status_t fetchAllInformation(FetchFlags flags);
 
     // mKernelVersion = x'.y'.z', minLts = x.y.z,
     // match if x == x' , y == y' , and z <= z'.
diff --git a/include/vintf/VintfObject.h b/include/vintf/VintfObject.h
index fe70784..5593da5 100644
--- a/include/vintf/VintfObject.h
+++ b/include/vintf/VintfObject.h
@@ -80,8 +80,19 @@
 
     /*
      * Return the API that access device runtime info.
+     *
+     * {skipCache == true, flags == ALL}: re-fetch everything
+     * {skipCache == false, flags == ALL}: fetch everything if not previously fetched
+     * {skipCache == true, flags == selected info}: re-fetch selected information
+     *                                if not previously fetched.
+     * {skipCache == false, flags == selected info}: fetch selected information
+     *                                if not previously fetched.
+     *
+     * @param skipCache do not fetch if previously fetched
+     * @param flags bitwise-or of RuntimeInfo::FetchFlag
      */
-    static std::shared_ptr<const RuntimeInfo> GetRuntimeInfo(bool skipCache = false);
+    static std::shared_ptr<const RuntimeInfo> GetRuntimeInfo(
+        bool skipCache = false, RuntimeInfo::FetchFlags flags = RuntimeInfo::FetchFlag::ALL);
 
     /**
      * Check compatibility, given a set of manifests / matrices in packageInfo.