
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>The Next Phase of AI Investing</h3><h4>22 October 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>AI will not replace jobs, but it will change the nature of work<em>"</em></p><p>Kai-Fu Lee</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='the-next-phase-of-ai-investing' href='/Content/Downloads/ARP/ARP241022.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#249;article-main-image;705;414' /></div><div class='article-page-content__container__right__simple-content'><div>
<p>In the past, when writing about AI, I have distinguished between hyperscalers, enablers and empowered companies. Hyperscalers are those megacap companies that made it all happen. Enablers are tech companies with an enabling technology - either software or hardware &ndash; and empowered companies are firms that choose to implement AI and thus seek to benefit productivity-wise.</p>

<p>The hyperscalers were, until recently, the clear winners, but enablers&rsquo; footprints are getting bigger and bigger, hence why it is now time to differentiate between early and late enablers. In a new research paper, the research team at Goldman Sachs not only make that distinction, but they also change the labelling system. They now divide AI companies into four categories or <em>phases </em>as they call them.</p>
</div>

<div>
<div>
<p>The earliest enabler of them all, Nvidia, is the only constituent in <em>phase 1</em>. Behind Nvidia comes a group of <em>phase 2</em> enablers. This is a group of companies which facilitate the set-up by providing various infrastructure goods/services and include data centre REITs, certain utility companies, semiconductor manufacturers, cloud providers and various hardware and software companies.</p>

<p>Then come <em>phase 3</em> companies. These are mostly software and IT services companies with the potential to monetise AI by generating incremental revenue. These are companies with a core business away from AI pursuing an opportunity in AI. Phase 3 companies will typically benefit later in the cycle than phase 2 companies.</p>

<p>Then, at the end of it all, come <em>phase 4 </em>companies, previously named AI empowered companies, and that includes companies which will benefit earnings-wise from the adoption of AI and the productivity gains that will follow. The following is an attempt to clarify where in that chain investors should focus right now.</p>
</div>
</div>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Performance of phase 2, phase 3 and phase 4 companies </strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/6717c63f7ed0c2f9f3c1555f_6717c5132d7770944c85a529_Picture1.png#306;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: Performance of phase 2 companies vs. forward EPS estimates &nbsp;</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/6717c63f7ed0c2f9f3c15557_6717c546f36d4094be711dc9_Picture2.png#306;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#306;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#306;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The current picture</h4><p>Nvidia is in a league of its own when compared to other early enablers. In 2024, EPS at Nvidia are expected to grow well over 100% year-on-year, whereas phase 2 companies, on average, are expected to grow EPS by less than 10%. However, from Exhibit 1 you can see that relatively lacklustre EPS growth amongst phase 2 companies in 2024 hasn&rsquo;t prevented them from outperforming phase 3 and phase 4 companies over the last 18 months.</p>

<p>--image--</p>

<p>To me, that is a yellow flag. And the yellow flag gets even bigger if you take Exhibit 2 into account as well. As you can see, phase 2 companies have performed significantly better than corporate earnings would suggest, i.e., it probably won&rsquo;t take too many disappointing earnings reports before stocks in phase 2 begin to struggle.</p>

<p>--image2--</p>

<p>I fully accept the argument that while the multiple-expansion story may be largely behind us, phase 2 companies can continue to deliver solid returns <em>provided </em>earnings live up to, or exceed, expectations. However, that is a big &ldquo;if&rdquo; in an environment where the hyperscalers have started to slow down their capex spending.</p>

<p>It is also worth noting that neither phase 1 (i.e. Nvidia), phase 3 or phase 4 companies have experienced the same inconsistency between stock prices and corporate earnings as is evident amongst phase 2 companies. The only conclusion I can draw from that is that the risk/reward profile is unfavourable in phase 2 companies when compared to other companies with exposure to AI.</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#307;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#307;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#307;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#307;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The arguments for and against</h4><p>When looking for reasons to justify current valuations, one realises that there are in fact two sides to the story. On one hand, even if year-on-year growth rates have started to slow, hyperscalers continue to invest massive amounts of money in AI. Take for example the recent announcement from Microsoft that it has committed to buying all the electricity output from a resurrected Unit 1 nuclear reactor at Three Mile Island for the next 20 years.</p>

<p>The bulls argue that if hyperscalers are prepared to go that far to ensure the power supply for their data centres, it is only a question of time before phase 2 companies begin to benefit.</p>

<p>The bears, on the other hand, argue that the <em>percentage growth </em>of hyperscalers&rsquo; capex programmes and the <em>magnitude </em>of Nvidia&rsquo;s revenue surprises have been shrinking more recently. Moreover, the AI take-up amongst companies in general has been surprisingly slow, which is probably why hyperscalers have begun to cut back on their AI investments (the bears argue).</p>

<p>I haven&rsquo;t come across any convincing evidence in favour of either of those arguments, hence why I believe it will come down to the forthcoming earnings season and possibly the one after that. The facts will come out &ndash; good or bad &ndash; hence why this coming season is so important to the AI story.</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#308;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#308;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#308;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#308;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Where to invest</h4><p>Let&rsquo;s assume that this coming earnings season will confirm that there is still plenty of appetite to invest amongst hyperscalers, but that the AI take-up amongst other (non-tech) companies continues to be slow. That assumption is based on a recent IT spending survey which shows that just 3% of corporate IT budgets will be spent on generative AI next year. Under those conditions, do you invest in AI at all at this point and, if so, where?</p>

<p>The easy one first. Widespread adoption of AI is still years away, and that will limit the upside opportunity in phase 4 companies. As already mentioned, only 3% of corporate IT budgets will be spent on generative AI in 2025, and only 6% of all US firms are currently using generative AI when producing. That said, the penetration varies significantly from industry to industry.</p>

<p>In terms of the biggest upside opportunity near term, one should probably zoom in on phase 3 companies. They have not performed particularly well more recently, as the near-term outlook is rather fussy &ndash; in fact too fussy to fully rotate into this category at this point in time. However, platform companies that focus on database management and development tools should represent an attractive near-term opportunity, as they are set to be the primary beneficiaries of the next wave of generative AI investments.</p>

<p>One final observation: Earlier, I made the point that phase 2 companies can continue to perform well but only if earnings &lsquo;cooperate&rsquo;. One could make the same point about phase 3 companies, hence why this coming earnings season is the best indicator you have in terms of where to invest (if at all).</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>22 October 2024</strong></p></div></div></div>