
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Is AI a Pie in the Sky? - Everybody raves about it but the naked facts are less than ebullient </h3><h4>11 July 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>By far, the greatest danger of Artificial Intelligence is that people conclude too early that they understand it.<em>"</em></p><p>Eliezer Yudkowsky, Machine Intelligence Research</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='is-ai-a-pie-in-the-sky' href='/Content/Downloads/ARP/ARP240711.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/6717c31219fcbae3b52d9a94_iStock-1401292297_705x414.jpg#242;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Share of US firms that use gen. AI to produce goods and services</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66b9fc8e492b342fc4398743_6690028c293e1bea97c79476_Picture2.png#335;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: The share of US firms using AI for production &ndash; 2Q24 vs, 1Q24</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/66b9fc8e492b342fc439874d_669002d62c39580273f81bb7_Picture3.png#335;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#335;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#335;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why another paper on AI?</h4><p>This paper has been produced in response to a question raised at our webinar earlier this week. I was asked to explain how to invest in AI. That made me think of a research paper that landed in my inbox only days ago. Exhibit 1 below is from that paper. The chart forced me to think whether it is all a &lsquo;gimmick&rsquo;. Is the AI journey, which captivates everybody, only a pie in the sky? Should we all moderate our expectations for future productivity growth? In other words, is the party over before it has really begun?</p>

<p>--image--</p>

<div>
<p>Those were the sorts of questions racing through my head when I saw that only 5% of all US firms use generative AI to produce their goods and services, and the following is my attempt to answer those questions.</p>
</div>

<div>
<div>
<p>As I kept on reading, Exhibit 2 popped up, and my list of questions didn&rsquo;t get any shorter. As you can see, the share of US firms that use AI for production grew a meagre 0.2% from Q1 to Q2. What on earth is going on, I asked myself, and how can Nvidia be the king of Wall Street if so few firms use AI and the number hardly grows?</p>

<p>--image2--</p>
</div>
</div>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: Revenues generated by AI enablers</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66b9fc8e492b342fc4398747_6690034050614b67a324c1bd_Picture4.png#336;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#336;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#336;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#336;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The naked facts</h4><p>Let me remind you as to how we approach AI investments at Absolute Return Partners. We divide the AI opportunity into four separate categories:</p>

<p>- global hyperscalers;</p>

<p>- hardware &amp; software enablers;</p>

<p>- cooling system purveyors; and</p>

<p>- empowered companies.</p>

<p>At first, the hyperscalers came up with the vision and the business model. Once that was broadly accepted, the enablers moved in and built the hardware and software to make it all happen. However, it quickly became apparent that the need for cooling systems would explode with the introduction of AI servers, and a new business opportunity was created. Some regard purveyors of cooling systems as enablers, but we prefer to view them separately, as it is a profoundly different business.</p>

<p>The last group in the food chain, the empowered companies, are those that are depicted in Exhibit 1 and Exhibit 2 above. These are companies in various industries that have decided to install AI to empower their business. As pointed out by Goldman Sachs, you would expect industries in which many functions can be automated, and where wage costs account for a large percentage of total operating costs, to benefit the most from implementing generative AI. Virtually all commentators agree that banks and insurance companies top that list.</p>

<p>--image--</p>

<p>Now to Exhibit 3. As you can see, enablers continue to rapidly grow revenues. It is worth noting that consensus revenue forecast revisions for <em>hardware enablers alone</em> imply a $330 billion upgrade to 2025 annual average revenue forecasts vs. 2024, up from +$250 billion only a quarter ago (source: Goldman Sachs).</p>

<p>The hardware upgrade is primarily driven by a rise in investments in semiconductors and cloud which, by the end of 2025, are expected to increase by nearly 50% from current levels. However, according to Goldman Sachs, from 2H25, datacentre components are expected to become the driving force of AI investments.</p>

<p>My preliminary conclusion, therefore, is that there are no signs of a slowdown in AI-related investments, even if the numbers suggest only a modest uptake so far in most industries (see Exhibits 1-2 again).</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 4a: Corporate Investments in AI hardware by country</strong><br />
<em>Notes: 3Q22=100; data from various national accounts<br />
Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66b9fc8e492b342fc4398751_6690039a707ad496f7e7e3f4_Picture5.png#337;slide-image;;' data-alt-text2= '<p><strong>Exhibit 4b: Corporate investments in AI software by country</strong><br />
<em>Notes: 3Q22=100; data from various national accounts<br />
Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/66b9fc8e492b342fc439875a_669003d0e0bfd49d15de9286_Picture6.png#337;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#337;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#337;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The not so naked facts</h4><p>Assuming the AI uptake by US companies continues to be relatively modest, it is tempting to conclude that the Americans are not on the ball when compared to companies in other parts of the world. I specifically refer to companies in the Asia-Pacific region which seem to have taken an early lead in the AI race. However, as you can see in Exhibits 4a-b, nothing could be further from the truth.</p>

<p>--image--</p>

<p>--image2--</p>

<p>Exhibit 4a depicts nationwide investments in AI hardware in the US, Canada, Japan and the UK, and Exhibit 4b provides the same information on software investments. As you can see, US companies are on a much steeper growth curve than companies in Canada, Japan and the UK. It is therefore simply not correct when some commentators argue that the slow uptake in the US is due to below-average investments by US corporates. One can argue that they were perhaps a bit slower than Japanese companies to get out of the start blocks but, at the current pace of investments, that disadvantage will soon be gone.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 5: Impact on US labour productivity from AI adoption (%) </strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66b9fc8e492b342fc4398757_6690044c5bb8149fe102f654_Picture7.png#338;slide-image;;' data-alt-text2= '<p><strong>Exhibit 6: Manufacturers&rsquo; sales of AI-related components </strong><br />
<em>Notes: US data only<br />
Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/66b9fc8e492b342fc4398754_669004808c5748f95470da88_Picture8.png#338;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#338;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#338;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>My interpretation</h4><p>I have reached the following conclusions:</p>

<p>1. The uptake has indeed been relatively slow <em>and will continue to be slow</em> (I would add that the uptake has been slow worldwide). AI offers remarkable opportunities, but many of those will not become apparent from one day to the next. Nor will company boards, who will have to sign off on investments of this magnitude, throw millions after AI without seeing some concrete results, i.e. I expect the implementation process to continue to be very gradual.</p>

<p>2. The relatively slow implementation of AI is likely to moderate the impact on productivity in the early years and, thus, likely to have a smaller effect on GDP growth than widely expected &ndash; at least in the 2020s. Goldman Sachs&rsquo; baseline forecast, which assumes AI to be fully adopted over the next ten years, suggests that US labour productivity will improve by 1.5% annually (Exhibit 5). I believe that is overly optimistic and think their +0.7% estimate, which assumes AI to be fully adopted over 20 years, is more realistic.</p>

<p>--image--</p>

<p>3. Given the steeper ramp-up in AI investments in the US, countries like Canada, Japan and the UK are at risk of falling behind the curve. I believe the European continent is exposed to this risk as well, even if I have no data to back up that claim. Anecdotal evidence from around Europe tells me that continental European companies are no better than UK companies when it comes to embracing the new technology.</p>

<p>4. One factor that should never be underestimated is peer pressure. If company X boosts its productivity meaningfully by implementing generative AI and consequently lower its prices to gain market share, other companies in the same industry could be urged to give in and follow company X&rsquo;s example. All else equal, this could possibly speed up the implementation process.</p>

<p>5. As we get further into the ongoing implementation phase, you should become more selective as to what you invest in. Earlier, I mentioned that, as of 2H25, datacentre components are expected to become the driving force of revenue growth amongst hardware enablers; however, if you look at Exhibit 6 below, you can see that different groups of components already grow at different paces. This segmentation will only increase over time, and you must build this into your portfolio construction. Otherwise, you run the risk of sitting with the losers in a fast-growing industry.</p>

<p>--image2--</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#339;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#339;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#339;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#339;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final few words</h4><p>In the first half of 2024, enablers have delivered the best performance, although hyperscalers and cooling system purveyors have nothing to be ashamed about. However, empowered companies have, so far, struggled to deliver convincing results from their AI-related investments, and that may explain why almost all other industries have dramatically underperformed tech in 1H24.</p>

<p>The other observation I have made is that software enablers have begun to perform better and have, in some instances, outperformed hardware enablers. I believe this is a natural part of the evolution. When company X decides to use AI, the first to benefit will be hardware enablers; however, the new AI software must be able to &lsquo;talk&rsquo; to the company&rsquo;s existing software, and that is where software enablers come in. This is also why software enablers will likely peak later than hardware enablers in this cycle.</p>

<p>Allow me to reiterate point #5 above. As the AI cycle matures, different types of companies will benefit. I have just mentioned software enablers vs. hardware enablers, but you also need to distinguish between different types of hardware enablers. If you stick to the early winners, you will most likely be disappointed.</p>

<p>Finally, a word of caution. Many salespeople will tell you that now is the time to invest in company X, after it has invested so much in generative AI. I can only reiterate what I said earlier. I expect empowered companies to benefit eventually, but I expect the curve to be flatter than many do. In my opinion, it is still premature to invest more generally <em>because of AI</em>. Their time will come but not yet.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>11 July 2024</strong></p></div></div></div>