
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>What to Expect From Gold When the Monetary Policy Regime is Changing - and why it could offer a very convenient hedge against a selloff in US equities</h3><h4>07 June 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>I like gold because it is a stabilizer; it is an insurance policy.<em>"</em></p><p>Kevin O’Leary</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='what-to-expect-from-gold-when-the-monetary-policy-regime-is-changing' href='/Content/Downloads/ARP/ARP240607.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/58f9fc040113576d89e5e767_goldbar_705x414.jpg#240;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: COMEX gold price</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/66631b3dfdd349309766ae29_Picture1.png#344;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: Worldwide gold demand by end-market, quarterly averages</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/66631b8cb02d4a5f2890eab9_Picture2.png#344;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 3: Gold&rsquo;s share of total central bank reserves, EM vs. DM</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image3= '/Content/Images/66631bbb6e16616f13dd3182_Picture3.png#344;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#344;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why this paper?</h4><p>My interest in gold (which I hadn&rsquo;t looked at for a while) was ignited when the chart below landed in my inbox (Exhibit 1). As you can see, more recently, the gold price has risen sharply, and I started to look into the underlying reasons why that is.</p>

<p>--image--</p>

<div>
<p>There are essentially four gold end-markets, namely central banks, jewellery, financial investors and industrial use (named &ldquo;other&rdquo; in Exhibit 2 below). As you can see, over the last couple of years, the rise in demand has come exclusively from central banks; in fact, central banks have more than doubled their buying activities when compared to the previous ten years or so.</p>
</div>

<div>
<div>
<p>That led me to the next two questions &ndash; which central banks are buying and why? The first question turned out to be the easiest one to deal with. As you can see in Exhibit 3, in recent years, EM central banks have been far more active than DM central banks in the gold market.</p>

<p>--image2--</p>

<p>Hence the big question &ndash; why are EM central banks so eager to boost their gold holdings? The answer to that question is embedded in the title of this research paper and is the first reason of two why I decided to write a paper on the subject. To cut a (very) long story short, the existing monetary policy regime may be undergoing a profound change which could significantly impact financial markets in the years to come. Prominent EM countries, led by China, are trying to undermine the status of the US dollar by doing more and more international trades in renminbi.</p>

<p>--image3--</p>

<p>Adding to that, US equities are now trading at earnings multiples that make them vulnerable to external shocks. In my many years in business, I have only witnessed the current level of disregard for economic fundamentals twice. The first was in connection with the extraordinary Japanese rally in risk assets in the late 1980s, and the second one was when the US dotcom rally in the late 1990s put all plain logic aside. Do I need to remind you that they both ended in tears?</p>

<p>In this paper, I will argue how gold can be used to protect you from both of those eventualities. I am not suggesting that the US dollar will definitely lose it status as the world&rsquo;s preferred reserve currency. Nor am I saying that US equities will almost certainly collapse. Having said that, it is good practice to have a game plan ready, should one of them, or both, materialise.</p>
</div>
</div>
</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#345;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#345;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#345;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#345;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What do I mean by “changing monetary policy regime”?</h4><p>Over the last 100 years or so, the monetary policy regime has changed (at least) three times, and every time the price of gold has rallied:</p>

<p>1. In 1931, economic hardship forced the UK government to come off the gold standard. In the ten years prior, gold had been flattish at around $20 per ounce. Over the next three years, it almost doubled to $35 (see <a href="https://nma.org/wp-content/uploads/2016/09/historic_gold_prices_1833_pres.pdf">here</a>).</p>

<p>2. In 1971, under President Nixon&rsquo;s leadership, the US also abandoned the gold standard which, in 1973, led to the collapse of Bretton Woods, which had effectively ruled monetary policy since the end of World War II. Bretton Woods was an international treaty guaranteeing that the US government would always convert 35 US dollars to one ounce of gold. The price of gold, which had hardly moved during the decade of the 1960s (trading at $35 +/-), suddenly came to life and peaked at $160 in 1975.</p>

<p>3. Gold traded at about $380 as we entered the decade of the 1990s but found itself about $50 lower at $330 in 1997. Then, suddenly, the Asian financial crisis erupted. It all started in Thailand but quickly spread to other southeast Asian countries. Before things calmed down again, many countries found that their currency was suddenly worth 80-90% less against the US dollar than it was prior to the crisis. The crisis was addressed by pegging those currencies to the US dollar, hence why it is deemed a regime change. At first, there was no positive response from gold but, within a couple of years, it began to rise again and reached $600 by 2006 and $1,000 by 2009.</p>

<p>In other words, all three episodes were characterised by a relatively lacklustre gold price in the years leading up to the regime change and a much more sparkling gold price in the years afterwards. It is therefore tempting to argue that gold could continue its recent rally if there is indeed a regime change unfolding, but how can I be sure of that?</p>

<p>The short answer is that I can never be 100% certain but listen to this. The Chinese increasingly trade commodities with other EM countries in renminbi, and it is pretty obvious that they are trying to establish a new currency block. Deals with Brazil and South Africa to trade in renminbi have already been entered into, and a deal with Saudi Arabia to trade oil in renminbi is currently being negotiated. The objective of those arrangements is to promote the Chinese currency as a credible alternative to the US dollar, I believe.</p>

<p>You may argue that such an arrangement cannot not work for as long as the renminbi is not freely tradeable and transferable, but there is a catch to that argument. The Chinese have, according to my source, either promised or are about to promise that all renminbi held by China&rsquo;s trading partners can be converted to gold in Shanghai &ndash; one of three exchanges worldwide that make a market in gold.</p>

<p>Such an arrangement is effectively Bretton Woods Mk. II. It would allow EM nations to trade with each other in renminbi, explicitly underwritten by China and its commitment to convert any credit balances in renminbi to gold. Precisely which EM nations that are part of such an arrangement is not clear. That said, it is probably no coincidence that EM countries as a block have been massive buyers of gold more recently.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 4: Ratio of gold price-to-monetary base</strong><br />
<em>Source: </em><a href="https://www.macrotrends.net/2485/gold-to-monetary-base-ratio"><em>macrotrends.net</em></a></p>
' data-image='/Content/Images/66631c34e8132e744cb1ceed_Picture4.png#346;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#346;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#346;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#346;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How high could the gold price go?</h4><p>As I have already pointed out, if the monetary policy regime is undergoing a profound change, the gold price will most likely go higher but how much higher? One of the best indicators of where in the cycle we currently are, is the so-called gold price-to-monetary base ratio.</p>

<p>In the US (the only country worldwide tracking this ratio), it measures the value of gold relative to the size of Fed&rsquo;s balance sheet, which is virtually identical to the US monetary base. Ideally, this ratio should be measured globally, but no such statistics exist.</p>

<p>As you can see in Exhibit 4, in two of the biggest gold bull markets we enjoyed in the 20th century (1934 and 1980), the ratio peaked at about 5x; however, as you can also see, we are far, far away from that level now. It is also worth noting that, over the last 100+ years, it has almost always turned out to be a great buying opportunity in gold when the ratio has been as low as it is now.</p>

<p>--image--</p>

<p>As you can see, the gold price-to-monetary base ratio is close to its all-time low, suggesting gold should trade <em>much </em>higher. My source has suggested that, given the current size of the monetary base, a price of $10-15,000 per ounce would be a fair reflection, but that guesstimate assumes an unchanged monetary base, and that is not a fair assumption, I believe.</p>

<p>The problem is that we don&rsquo;t know how much central banks intend to shrink the monetary base. Although I expect it to be reduced a fair bit over the next few years, I do not expect it to come all the way back to pre-2008 levels, as the economic implications would be too severe. In other words, gold could peak anywhere between current levels (a tad below $2,400 per ounce) and $15,000 depending on:</p>

<p>(i) how much the monetary base will be reduced; and</p>

<p>(ii) how much substance there is to the changing monetary policy regime proposition.</p>

<p>However, it is impossible to be more precise at this stage.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 5: Comparison of an average hypothetical USD portfolio</strong><br />
<em>Note: The hypothetical portfolio is measured with and without 5% in gold from 2004 to 2023<br />
Source: World Gold Council</em></p>
' data-image='/Content/Images/66631c9e376107eb5bdd7534_Picture5.png#347;slide-image;;' data-alt-text2= '<p><strong>Exhibit 6: Correlation between US equities (S&amp;P 500) and gold/US Treasuries</strong><br />
<em>Source: World Gold Council</em></p>
' data-image2= '/Content/Images/66631cc643d6a6f108376b99_Picture6.png#347;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 7: Performance of gold during various crises</strong><br />
<em>Source: World Gold Council</em></p>
' data-image3= '/Content/Images/66631cf0ad22d687b6508f53_Picture7.png#347;slide-image3;;' data-image4= '/Content/Images/66631f553f7c5dda14e77583_Picture8.png#347;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why holding gold makes sense, regime change or not</h4><p>Ignoring the above, there are <em>always </em>solid fundamental reasons to invest in gold. This view is based on its ability to maintain its purchasing power in most environments. Since 1971, the price of gold has risen 8% annually when measured in US dollars. Even in benign times, gold has proven to be a good place to park some of your money, as risk-adjusted portfolio returns almost always improve as a result &ndash; take for example the period covering 2004-23 (Exhibit 5) which includes both an extraordinarily difficult spell (2007-08) and much more upbeat conditions (since 2009).</p>

<p>It is not that gold always correlates negatively with other asset classes. Since 1980, the correlation between gold returns and those of other asset classes have been mostly positive but only modestly so. In the case of S&amp;P 500, it has even been (marginally) negative.</p>

<p>--image--</p>

<p>In crisis times, gold tends to do even better than in benign times due to its countercyclical nature, i.e., when risk assets struggle, gold does well. That view is supported by Exhibit 6. As you can see, whereas gold returns and equity returns are modestly positively correlated in most environments, in extreme selloffs, the correlation turns negative.</p>

<p>--image2--</p>

<p>Exhibit 7 provides more details on that observation. Although it is not always the same, as you can see, when some sort of crisis strikes, the correlation between gold and equities almost always turns negative.</p>

<p>--image3--</p>

<p>There are two types of crises that affect the gold price more than anything else &ndash; periods of high inflation and geopolitical incidents. In Exhibit 8, you can see that gold, over the last 55 years, has performed much better during periods of relatively high inflation and not nearly as well during periods of relatively low inflation.</p>

<p>--image4--</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 9: Gold bullion vs. gold miners</strong><br />
<em>Source: Russell Clark</em></p>
' data-image='/Content/Images/66631fb63f9966dbd2466f45_Picture12.png#348;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#348;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#348;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#348;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How to put it all together</h4><p>First and foremost, I should stress that my recommendation to invest in gold now is <em>not </em>dependent on the Chinese succeeding with their plans. Adding gold will <em>always </em>reduce the equity beta in the portfolio and, in this case, my recommendation to add gold at this point is driven by risk management considerations. The change of monetary policy regime, should it happen, is merely an added bonus. &nbsp;</p>

<p>Having said that, should the Chinese succeed with this plan, financial markets all over the world will be affected, none more so than FX markets. The US dollar stands to be a loser over time, as it runs the risk of becoming &lsquo;just another currency&rsquo;. It is hard to quantify this risk but, given the magnitude of external deficits in the US, the Americans will most likely struggle to keep the dollar at present levels, and that could prove costly inflation-wise.</p>

<p>There can be no doubt that the US will do its utmost to protect its current position, but I should remind you that a similar situation developed in the years around World War I. Back then, the UK was the incumbent, and the US was the up and coming &lsquo;bully&rsquo;. As we all know, the US won that battle, just like I am convinced the US will have to give in to China eventually. In the world of economics, nothing lasts forever, and a country of just over 300 million people <em>cannot </em>hold a country of 1.4 billion people back forever.</p>

<p>The other big issue on my mind is the disconnect between gold bullion and gold mining companies. Under the circumstances outlined above, wouldn&rsquo;t it make more sense to invest in gold miners? Isn&rsquo;t there more value to be found there? Although I can find plenty of logic in favour of that argument, I am hesitant to go there, and so is the market, it appears (Exhibit 9).</p>

<p>--image--</p>

<p>Russell Clark, who is a big bull on gold bullion (see for example <a href="https://www.russell-clark.com/p/precious-metals-why-is-only-gold">here</a>), provides the following explanation for the poor performance of gold miners: <em>&ldquo;The answer has to do with the very nature of gold. Its value comes from being difficult to mine. Not only are upfront capital costs substantial; the operating costs tend to eat most of the profits.&rdquo;</em></p>

<p>In the context of this paper on monetary policy regimes, I should add that so long as virtually all bullion buying emanates from EM countries and most gold equity buying from DM-based investors, there is no reason whatsoever why the gap can&rsquo;t widen even further. Therefore, I will stick to bullion.</p>

<p>That leaves only one question. How much should you invest in gold? It depends, amongst other things, on your portfolio equity beta and which other tools you have at your disposal. If gold were the only portfolio hedge you could access, at this stage, I would <em>strongly </em>argue for at least 10%, possibly as much as 20%, of your NAV to be allocated to gold. However, when mixed with other capital conservation strategies (e.g. cash and/or high-quality bonds), less will do. That said, for the impact to be meaningful, I would aim for at least 5%.</p>

<p>In terms of how I would link an investment in gold to our collection of megatrends, my thinking is as follows: two of &lsquo;our&rsquo; seven megatrends underwrite an investment in gold &ndash; <em>Last Stages of the Debt Supercycle</em> and <em>Globalisation 2.0</em>. The world is increasingly struggling to service the rising mountain of debt and, in the not-so-distant future, I believe the card house will collapse with severe implications for risk assets, hence why you should hedge.</p>

<p>Adding to that, the monetary policy regime may also be undergoing one or two rather dramatic changes, resulting from the EM desire to reduce the dependence on the US dollar, hence the link to <em>Globalisation 2.0</em>. That said, the main reason for investing in gold at this stage is capital protection, hence why I would assign 75% to the Debt Supercycle megatrend and only 25% to Globalisation 2.0.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>07 June 2024</strong></p></div></div></div>