
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Time to Offload Economic Beta? - Part II of II </h3><h4>20 August 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>It's a recession when your neighbour loses his job; it's a depression when you lose yours.<em>"</em></p><p>Harry S. Truman</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='time-to-offload-economic-beta-2' href='/Content/Downloads/ARP/ARP240820.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/66c4b44198ecc69eba965571_iStock-1359225856_705x414.jpg#246;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Annualised growth of real GDP in the US, 1Q13-1Q24</strong><br />
<em>Source: Statista</em></p>
' data-image='/Content/Images/66c4b74ac013c5ebf0b4fb6d_66c4b4c46ccfff805e01c818_Picture2.png#316;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#316;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#316;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#316;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The question to address in this paper</h4><p>I raised the following question in part I of this paper:</p>

<p><em>If the economy is slowing down, will other sectors and industries deliver better returns, or can we expect AI, and megacap tech stocks in particular, to continue to dominate?</em></p>

<p>Although the latest signs remain rather ambiguous, in the following, I will assume that US GDP growth will continue to slow down in a meaningful way, although a full-blown recession will probably be avoided (for now). Assuming that is correct, the question above, and thus the text to follow, is of more than theoretical interest; it becomes a user manual in portfolio construction.</p>

<p>--image--</p>

<p>As you can see in Exhibit 1 above, apart from the turmoil created by COVID-19 in early 2020, the US economy has benefitted from great strength and exceptional stability over the last decade. The stable economy has resulted in outstanding business conditions, which again has led to extraordinary returns to equity investors.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: Beta of corporate earnings to GDP</strong><br />
<em>Note: European sectors only<br />
Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66c4b74ac013c5ebf0b4fb86_66c4b514579a6921b48fe4bf_Picture3.png#317;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#317;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#317;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#317;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The winners and losers in different economic environments</h4><p>Tech stocks in general, and megacap tech stocks in particular, have outperformed everything else in recent years; however, one shouldn&rsquo;t ignore the fact that the technology sector is cyclical but only modestly so (Exhibit 2). Therefore, the question of what to expect from tech if GDP growth is below par is a relevant one.</p>

<p>--image--</p>

<p>That question becomes even more pertinent when taking into consideration that tech is selling at sky-high P/E multiples (see later), that tech investors are sitting on massive profits, and that I have noticed a certain level of complacency creeping in amongst tech investors more recently. Many of them seem convinced that the AI bull story will continue virtually forever.</p>

<p>Complacency leads to the guards coming down, and that shouldn&rsquo;t be ignored in a slowing economy. Recently, I have come across a few research papers suggesting that the rollout of generative AI may in fact take longer than expected, as companies are more reluctant than expected to make the investments required. That hesitance won&rsquo;t get any less pronounced if GDP growth continues to slow.</p>

<p>Going back to Exhibit 2 for a second, the sectors on the extreme left of the chart are obviously more cyclical than tech; however, tech will still be affected if other, and more cyclical, companies are reluctant to roll out AI.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: Top 10 companies by market cap, 1980-2020 </strong><br />
<em>Source: </em><a href="https://www.riskhedge.com/"><em>riskhedge.com</em></a></p>
' data-image='/Content/Images/66c4b74ac013c5ebf0b4fb9f_66c4b558227894b371f58ce7_Picture4.png#318;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#318;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#318;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#318;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Changing regimes over time</h4><p>The other half of my story is about regime change. As you can see in Exhibit 3 below, equity investing is very much about the big picture; about identifying the next sector(s) in vogue amongst investors. If you get that right, more than half the job is done.</p>

<p>--image--</p>

<p>Back in the 1970s, Big Oil was everybody&rsquo;s favourite, as the world underwent two oil crises (in 1973 and 1979). A similar pattern unfolded in the 1980s, this time in Japan, when Japanese stocks could walk on water. Another bubble materialised in the 1990s, when phase one of the digital revolution (the internet) was rolled out. This time, US tech stocks took the reins.</p>

<p>Not surprisingly, given investors&rsquo; current love affair with AI, tech stocks are back in vogue. If you take another look at Exhibit 3, you can see what a dramatic impact all those love affairs have had on the market cap of the companies in question. Given my assumption that US GDP growth will moderate further over the next few quarters, and given the massive investments required to roll out generative AI, the following question becomes critical:</p>

<p><em>Assuming the US economy continues to slow down, could investors&rsquo; love affair with AI end or, at the very least, be put on hold for a while; i.e., could AI stocks be about to lose their pole position in Exhibit 3, as investors begin to look for the next industry to top the marketcap league?</em></p>

<p>Before I share my thoughts on that question, allow me to make two important points. Firstly, I should point out that I have been pushed very hard on this topic by my colleagues. Their argument is something like this: given the massive implications of generative AI, why can&rsquo;t AI stocks hold on to their pole position for another 10, 20 or even another 30 years?</p>

<p>In principle they can, I suppose, but one important lesson I have learnt from over 40 years in this industry is that things change at regular intervals; little remains unchanged for much longer than one full business cycle, and tech stocks have already dominated for many years. I strongly suspect that investors are already on the lookout for their next &lsquo;pet&rsquo;.</p>

<p>Secondly, just because a certain industry (or country) falls from grace, you should not necessarily expect it to collapse. That might sometimes be the case but is not always going to happen. Going back to Exhibit 3 for a second, as you can see, typically when a certain sector is in vogue, 6-8 of the largest companies, when measured by marketcap, come from that sector. As investors&rsquo; love affair with Big Oil faded in the early to mid-1980s, oil stocks dropped but didn&rsquo;t collapse. The Japanese bust in 1990 was a genuine collapse, though, which took more than 30 years to recover from.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 4: S&amp;P 500 calculations &ndash; current &amp; historical</strong><br />
<em>Source: thebahnsengroup.com</em></p>
' data-image='/Content/Images/66c4b74ac013c5ebf0b4fb8c_66c4b5ac84ef12c0759787f0_Picture5.png#319;slide-image;;' data-alt-text2= '<p><strong>Exhibit 5: Tech megacap valuations &ndash; NTM P/E multiples</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/66c4b74ac013c5ebf0b4fb89_66c4b5d819b2099fa6ebdc87_Picture6.png#319;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#319;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#319;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>More on tech stocks</h4><p>Tech stocks in general, and AI megacap stocks in particular (the so-called hyperscalers) have been on a high for many years. As you saw in Exhibit 3, tech stocks were already investors&rsquo; favoured sector in 2020 and now, 4-5 years later, nothing has changed apart from tech stocks being even more dominant.</p>

<p>--image--</p>

<p>Years of strong performance has led to some quite extraordinary valuation metrics (Exhibit 4). As you can see, on average, tech stocks trade on 28.4x NTM earnings, 56% above its 15-year average. Also, tech is by far the most expensive sector in S&amp;P 500, currently trading at a 36% premium to the average sector P/E. Compare that to energy which was the sector to invest in in the 2000s. The 15-year average relative P/E for the energy sector is, as you can see, 1.14x. Today, it is 0.59x &ndash; a sign of what might happen when investors go cold on a sector.</p>

<p>Even if most of us think megacap tech stocks are the most expensive of all tech stocks (I certainly did), the picture is in fact slightly different. Take a look at Exhibit 5. As you can see, megacap tech stocks traded at approx. 18x NTM earnings a decade ago. Now, ten years later, they trade at 27x NTM earnings. Then compare it to the 28.4 NTM P/E multiple in Exhibit 4 above. Effectively, this means that other tech stocks are now more expensively priced than the hyperscalers, a fact which I find quite telling.</p>

<p>--image2--</p>

<p>When we invest in AI stocks at ARP, we divide the opportunity set into four distinctly different boxes:</p>

<p>i. global hyperscalers;</p>

<p>ii. hardware &amp; software enablers;</p>

<p>iii. purveyors of cooling systems; <em>and</em></p>

<p>iv. empowered companies.</p>

<p>Global hyperscalers make up five of the six companies depicted in Exhibit 5 above. Only Nvidia is not a hyperscaler; it is an enabler. The fact that global hyperscalers now trade at lower forward earnings multiples than tech stocks in general is a sign that investors have begun to move on. It is not necessarily a sign that the AI party is about to be over but phase one, the phase dominated by hyperscalers, probably is.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 6: Wealth creation by industry, United States, 1926-2019</strong><br />
<em>Source: Robeco</em></p>
' data-image='/Content/Images/66c4b74ac013c5ebf0b4fb9c_66c4b62a96fa087b36d17342_Picture7.png#320;slide-image;;' data-alt-text2= '<p><strong>Exhibit 7: Relative industry profitability and its stickiness over time</strong><br />
<em>Source: Robeco</em></p>
' data-image2= '/Content/Images/66c4b74ac013c5ebf0b4fb83_66c4b6611349657dffca2501_Picture8.png#320;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#320;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#320;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The three facts to focus on when looking for your next pet</h4><p>If you want to reduce the economic beta in your portfolio, and investors&rsquo; love affair with AI is about to come to a (temporary?) halt, what portfolio changes should you make?</p>

<p>I have spent months looking for an answer to that question. Let&rsquo;s assume it is not just about lowering the economic beta but also about identifying the next sector to dominate the marketcap league table in Exhibit 3.</p>

<p>As I searched my toolbox for answers, I quickly realised that certain essentials must be met. Size and liquidity is one. (For your information, I have simplified this exercise by amalgamating size and liquidity. Strictly speaking, they are two different metrics; however, in almost all cases, liquidity is a function of size.)</p>

<p>Take for example the battery industry which I find very attractive from an investment point-of-view. The green transition simply won&rsquo;t happen without more powerful grid batteries, i.e., the investment case is compelling. That said, from a marketcap point-of-view, the battery industry is tiny, i.e., it will not reach the top of the league table in Exhibit 3 for many, many years. That doesn&rsquo;t make it a bad investment &ndash; not at all, but we are looking for an industry to replace tech in the largest institutional portfolios worldwide, and the battery industry doesn&rsquo;t tick that box.</p>

<p>The next box that needs to be ticked is past wealth creation. Investors are peculiar animals. If an industry has not been able to create a reasonable amount of wealth before, many investors will quickly jump to the conclusion that it won&rsquo;t happen this time either. That is clearly not correct, but it suddenly becomes more of an uphill battle to make the journey to the top of the tree. In Exhibit 6, you can see which industries that have created the most wealth over the last 100 or so years.</p>

<p>--image--</p>

<p>Exhibit 6 also explains why industries like tech and energy have repeatedly made it to the top of the tree in Exhibit 3. As you can see, both tech and energy have generated plenty of wealth in the last 100 years, i.e., investors are easily convinced that it could happen again. Therefore, unless the industry/sector in question is relatively close to the top of the pyramid in Exhibit 6, it will struggle to replace tech stocks in Exhibit 3.</p>

<p>For me, the last box to be ticked is the earnings box. Can the industry/sector in question deliver solid earnings even in difficult times? That requirement is probably the harshest of the three and eliminates many possible candidates (Exhibit 7).</p>

<p>--image2--</p>

<p>In summary, we have now identified three metrics to zoom in on:</p>

<p>1. size and liquidity;</p>

<p>2. history; <em>and</em></p>

<p>3. stickiness of earnings.</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#321;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#321;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#321;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#321;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>My favourite industry to take over from AI</h4><p>In my book, one industry stands out as it ticks all three boxes. It is a large, well-capitalised and very liquid industry. Plenty of wealth has been created from that industry in the past, and earnings in the industry are extraordinarily stable. The industry in question is <em>healthcare </em>(look for <em>pharmaceutical products</em> near the top in Exhibit 6 above). I consider the healthcare industry a serious candidate to replace AI at the top of the tree for four reasons:</p>

<p>I. Changing demographics favour rapidly rising healthcare spending. In the UK, the NHS spends almost seven times more every year on a man in his mid-80s than it does on a man in his mid-30s.</p>

<p>II. Rising living standards in most EM countries will result in <em>much </em>higher healthcare spending across the world. Most OECD countries spend 8-12% of GDP on healthcare. The corresponding number in EM countries is half that, 4-6%.</p>

<p>III. More than one billion people (out of eight billion people on Earth) are now clinically obese, including 150 million children, a number which is expected to grow rapidly with rising living standards in almost all EM countries. New anti-obesity drugs offer one of the most successful remedies so far, and it is one of the fastest growing markets <em>anywhere</em>.</p>

<p>IV. Just like anti-obesity drugs have created a phenomenal opportunity, a strong pipeline of oncology products will do the same over the next few years. Cancer research is a massive business, and enormous amounts are ploughed into it every year. Even better, several breakthroughs are imminent.</p>

<p>For those four reasons, the future looks bright for the healthcare industry. One word of caution: healthcare stocks rarely perform well in US election years. Many US politicians bend over backwards to promise the electorate lower healthcare costs, and the industry performs relatively poorly as a result. This time is no different. Some candidates have made promises they can never deliver on, but Wall Street still reacts as if it is a genuine risk. Therefore, <em>buy but only buy on weakness</em>.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 8: Sector composition of S&amp;P 500 by market capitalisation, 1972-2024</strong><br />
<em>Note: Data as of 30 June 2024<br />
Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66c4b74ac013c5ebf0b4fb99_66c4b6d5dff73819480dea13_Picture9.png#322;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#322;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#322;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#322;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Conclusion</h4><p>Although anti-obesity drug companies have already delivered extraordinary results, both earnings-wise and in terms of stock price performance, the healthcare industry is not at all in &lsquo;froth&rsquo; territory (Exhibit 8). As you can see, healthcare&rsquo;s share of total marketcap in S&amp;P 500 is not meaningfully different from what it was 20 or 30 years ago.</p>

<p>--image--</p>

<p>On the basis of that, I believe the opportunity set is still vast. Having said that, and given the extraordinary performance of anti-obesity drug companies more recently, the bigger opportunity may be found in the forest of healthcare companies about to roll out various oncology products.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>20 August 2024</strong></p></div></div></div>