
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Time to Offload Economic Beta? - Part I of II </h3><h4>13 August 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>If you aren’t willing to own a stock for 10 years, don’t even think about owning it for 10 minutes<em>"</em></p><p>Warren Buffett</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='time-to-offload-economic-beta' href='/Content/Downloads/ARP/ARP240813.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/66bb419a713db9bf4ebbb5d8_iStock-518070288_705x414.jpg#245;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: CBOE volatility index (VIX), YTD</strong><br />
<em>Source: Yahoo Finance</em></p>
' data-image='/Content/Images/66bb49a67a4b2d37545240f9_66bb464b2bf5e1b9fcab5dec_Picture1.png#323;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: S&amp;P 500 annual peak-to-trough declines</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/66bb49a67a4b2d37545240f5_66bb4696aa9f5658d27bac10_Picture2.png#323;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#323;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#323;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What is this paper all about?</h4><p>In early August, equities suddenly fell out of bed, and equity market volatility spiked (Exhibit 1). Although things have since calmed down a fair bit, there is still tension in the air.</p>

<p>--image--</p>

<p>As you will see later, many investors have taken the turmoil as an opportunity to restructure their portfolios (as evidenced by the relative performance of various sectors), but let&rsquo;s start by putting the correction into a historical context.</p>

<p>As you can see in Exhibit 2, peak-to-trough, the selloff in early August resulted in an 8% decline in the value of S&amp;P 500. 8% doesn&rsquo;t even make it a proper correction, for which 10% shall be required. It was &lsquo;only&rsquo; a bit of noise.</p>

<p>Now, that can mean one of two things. Either the whole thing was no more than a storm in a teacup, or there is more bad news to come. For the latter to happen, a GDP recession or, at the very least, a profit recession shall probably be required, and that is essentially what this paper is about.</p>

<p>--image2--</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: US unemployment rate</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66bb49a67a4b2d37545240f2_66bb46d4b43ed6aed0fb0493_Picture3.png#324;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#324;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#324;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#324;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Toying with recession?</h4><p>Historically, a 50 bps or bigger rise in the 3-month moving average rate of unemployment from its 12-month low has been a reliable recession indicator. As you can see from Exhibit 3 below, the 3-month average rate was 3.6% 12 months ago and is now 4.1%. In other words, we are now exactly 50bps above the 12-month low; i.e., if history provides any guidance, a recession is coming.</p>

<p>--image--</p>

<p>That is the key argument provided by the bearish camp. One could in fact add another couple of reasons why the US economy is on shaky ground at present. For a starter, excess savings from the COVID-19 pandemic have now been spent, i.e., consumers no longer have that little extra in their pockets.</p>

<p>Also, new home sales continue to weaken and, most importantly, the inverted US yield curve is sending a very powerful signal. In the past, more often than not, an inverted yield curve has led to recession.</p>

<p>The strongest counterargument is the COVID-19 mayhem which effectively messed up all conventional economic logic. When COVID-19 arrived on our doorstep, the world changed profoundly and so did most of what I learned in school about economic policy and consumer behaviour. Central bank policy has changed. So has corporate investment patterns as well as consumers&rsquo; behavioural patterns.</p>

<p>At this stage, it is premature to say precisely what the impact will be longer term, but certainly things have changed dramatically since the pandemic broke out, and &lsquo;normal&rsquo; conditions have not yet returned. Take for example UK working patterns &ndash; particularly those in greater London. The London workforce has never returned in scale; some work full-time from home whereas other split the week between working from home and travelling into London (I am one of them) but few come into the office every day.</p>

<p>The impact is noticeable. Sandwich shops, hairdressers and other small businesses which made a living out of servicing this daily traffic are struggling to survive, and the amount of idle shop space is rising by the day. At the same time, because working habits have changed, more and more companies are downscaling, leaving plenty of idle office space as well.</p>

<p>I am told this is less of an issue in the US than it is in the UK. Having said that, I am on video calls with US domiciled individuals every week and have noticed that a large percentage of these people do the call from home, i.e. the impact <em>must </em>be noticeable in the US as well.</p>

<p>Whether employees choose to work from home or from the office, my guess is that the next recession, whenever it happens, will strengthen the hand of the employer. If the company in question suddenly needs to cut 10% of its staff, those employees who were reluctant to &lsquo;play ball&rsquo;, will be first in line to be made redundant, I suspect. Therefore, I am of the opinion that only after the next recession will we know what the new normal will look like.</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#325;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#325;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#325;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#325;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Events in early August</h4><p>Now to the big question: What did markets try to tell us in early August? Is the economy really slowing down, or was it &lsquo;just&rsquo; a dramatic overreaction to some not-so-good payroll numbers?</p>

<p>It all started when the monthly payroll report was published on the 2nd of August. Panic spread rapidly, in part because many investors believed the Fed had been caught behind the curve. US bond yields tanked and JPY/USD, which has been exceptionally weak in recent months, rallied strongly &ndash; all signs of investors rapidly changing their views on the US economy.</p>

<p>Having said that, I do <em>not </em>believe a US recession is coming in the next few quarters. The economy is indeed slowing down, as it sometimes does, but investors have been spoiled in recent years by an unprecedented number of quarters of robust economic growth. I believe the severe investor reaction in early August was caused by a mix of factors, not least:</p>

<p>(i) a sudden realisation that financial conditions had been disregarded for too long (more on this later);</p>

<p>(ii) weaker than expected quarterly earnings from certain tech companies (e.g. Intel), an industry that was meant to &lsquo;guarantee&rsquo; continued robust economic growth;</p>

<p>(iii) a perception that the Fed was now behind the curve; and</p>

<p>(iv) a worry that the long-standing yen carry trade could not survive the stronger yen.</p>

<p>The long sequence of robust economic growth created a widespread belief that solid economic growth and strong corporate profit growth of recent years is a God-given right but it isn&rsquo;t. Moreover, I think this perception led to plenty of complacency, and that it resulted in such a strong reaction when the boat was rocked.</p>

<p>In part II of my analysis which will follow in the next week or so, I will address the question: if the economy is indeed 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?</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 4: 12m forward P/E vs. Global Financial Conditions Index (RHS, inverted) MSCI AC World Index &nbsp;</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66bb49a67a4b2d3754524102_66bb47616a9e25f806bb7764_Picture4.png#326;slide-image;;' data-alt-text2= '<p><strong>Exhibit 5: Last month&rsquo;s performance of S&amp;P 500 sectors</strong><br />
<em>Note: 6 July to 5 August 2024<br />
Source: </em><a href="https://www.sectorspdrs.com/"><em>sectorspdrs.com</em></a></p>
' data-image2= '/Content/Images/66bb49a67a4b2d37545240ff_66bb47907323b0ec75943b28_Picture5.png#326;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 6: Calendarized S&amp;P 500 performance since 1928</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image3= '/Content/Images/66bb49a67a4b2d3754524105_66bb47d9455a34770e3927ee_Picture6.png#326;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#326;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Has anything actually changed?</h4><p>For a long time, equity valuations traded in line with financial conditions. When conditions eased, investors were prepared to pay more for equities and vice versa when financial conditions tightened (Exhibit 4). Then suddenly, early this year, investors began to bid up equity valuations regardless. As you can see, financial conditions no longer mattered. This disregard of economic fundamentals is, in my book, the root cause of the mayhem in early August.</p>

<p>--image--</p>

<p>Despite equities being weak overall in early August, US equities actually delivered very mixed returns. Whereas some sectors tanked, others delivered respectable returns. Take a look at Exhibit 5 and pay particular attention to the performance of cyclical vs. defensive industries.</p>

<p>--image2--</p>

<p>As you can see, from early July to early August, a clear pattern emerged. Defensive industries dramatically outperformed cyclical industries with real estate and utilities delivering the highest returns, whereas technology and consumer discretionary struggled the most.</p>

<p>The extended period of disregard of economic fundamentals as depicted in Exhibit 4 resulted in extraordinary returns in 1H24 (Exhibit 6) but, as we have learned over the last few weeks, it also resulted in a market which was very accident-prone. As you can see, 1H24 returns were consistently in the top quartile of returns over the last c.100 years, regularly in the top decile and, for shorter periods of time, even in the top percentile.</p>

<p>--image3--</p>

<p>Going back to my earlier point about investor complacency, as I have learned over the last 40 years, when things are too easy, the guards <em>always</em> come down, leaving investors very exposed. And, because they are so complacent, they are ill-prepared for the bad news when it arrives, hence why incidents like this almost always end in tears.&nbsp;</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 7: Relative price returns of various MSCI indices (USD) </strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66bb49a67a4b2d3754524105_66bb47d9455a34770e3927ee_Picture6.png#327;slide-image;;' data-alt-text2= '<p><strong>Exhibit 8: Last month&rsquo;s performance of S&amp;P 500 sectors</strong><br />
<em>Note: 10 July to 9 August<br />
Source: </em><a href="https://www.sectorspdrs.com/"><em>sectorspdrs.com</em></a></p>
' data-image2= '/Content/Images/66bb49a67a4b2d37545240fc_66bb4852d58523ff56a86ecc_Picture7.png#327;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 9a: 12m forward P/E multiples in various MSCI regions<br />
Data covering last 20 years </strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image3= '/Content/Images/66bb49a67a4b2d37545240ef_66bb48c86a1e1951b6d0fef7_Picture8.png#327;slide-image3;;' data-image4= '/Content/Images/66bb49a67a4b2d3754524110_66bb48f33317f1d50b7d738a_Picture9.png#327;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How much economic beta have investors offloaded?</h4><p>Although it is impossible to say precisely how much economic beta (in $ terms) has been offloaded, as you can see in Exhibit 7 below, plenty of investment portfolios have been restructured recently in the direction of more defensive stocks. Out have gone high-economic beta stocks (cyclical companies) and in have come low-economic beta stocks (defensive names).</p>

<p>--image--</p>

<p>As you can see, for the first six months of this year, cyclicals outperformed defensives worldwide; however, that suddenly changed. Events in early August caused investors to become more defensive. What we don&rsquo;t know at this stage is to what extent this has affected investor behaviour more fundamentally.</p>

<p>The early signs are that investor behaviour has not been greatly affected. Take another look at Exhibit 5 and then compare it to Exhibit 8 below. Only a few days distinguish the two charts from each other and, as you can see, they paint a dramatically different picture.</p>

<p>--image2--</p>

<p>Therefore, it is difficult to categorically state that investor behaviour has changed. My hunch &ndash; but it is only a hunch &ndash; is that it <em>will </em>gradually change in the months and quarters to come, as it becomes more and more evident that the economy is slowing, but I don&rsquo;t think it has happened yet. Therefore, if you have not yet made any adjustments to your portfolio, it is probably not too late to do so. The risk is that you will underperform in the short term by going more defensive.</p>

<p>My hunch is predicated on:</p>

<p>1. the severity of the selloff in early August;</p>

<p>2. the excessive valuation of US tech stocks; and</p>

<p>3. the length of time economic fundamentals were widely disregarded which is all about investor complacency.</p>

<p>This implies that there is more downside risk to equity prices. Even ex. tech, US equities continue to be expensively priced, both vis-&agrave;-vis other equity markets (Exhibit 9a) and historically speaking (Exhibits 9a-b). I should also point out that Exhibits 9a and 9b were both created before the strong comeback of the last few days, i.e. US equities are even more expensive now than Exhibit 9a-b suggest.</p>

<p>As I have pointed out before, <em>do not</em> use analyses like this to predict the direction of equities over the short to medium term. It rarely works! That said, <em>at some point</em> over the next ten years or so, high US equity valuations at present will cause the bubble to burst &ndash; another reason to gradually go more defensive even if the timing of this scenario is uncertain.</p>

<p>--image3--</p>

<p>--image4--</p>

<p>&nbsp;</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#328;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#328;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#328;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#328;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Conclusion</h4><p>Based on the above analysis, I conclude the following:</p>

<p>1. We are not yet out of the woods in terms of equity market turmoil. Volatility is likely to remain elevated for a while longer, and there is probably also another down-leg to the ongoing &lsquo;correction&rsquo; (which, strictly speaking, is not yet a correction).</p>

<p>2. The ongoing turmoil is more likely to be the result of a brewing profit recession than a pending GDP recession, i.e. we are not likely to be about to enter a bear market (defined as -20% or more).</p>

<p>3. That said, if it is neither a profit recession nor a proper GDP recession, the worst is probably over, and you have little to worry about, but my money is not on that outcome.</p>

<p>4. These observations assume an investment horizon of 1-2 years. More conservative investors should take a long look at Exhibits 9a-b and structure their portfolios accordingly. The problem I am up against is that the underlying theory provides no guidance on timing. The show could be over tomorrow morning, or the bull market could go on for another 5-10 years. Impossible to say.</p>

<p>In part II of this analysis, which I plan to complete over the next week or so, I will provide more guidance on which sectors/industries that are likely to prevail if the economy is indeed about to slow down.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>13 August 2024</strong></p></div></div></div>