
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Time to Go Big on Commodities?</h3><h4>26 September 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>What is the cost of being early?<em>"</em></p><p>Leigh Goehring & Adam Rozencwajg</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='time-to-go-big-on-commodities' href='/Content/Downloads/ARP/ARP240926.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/609e725acdffeb42ce655890_4_705x414.jpg#248;article-main-image;705;414' /></div><div class='article-page-content__container__right__simple-content'><p>To begin with, allow me to thank Leigh Goehring and Adam Rozencwajg of Goehring &amp; Rozencwajg (G&amp;R) who did much of the hard work for this paper. It so happens that I have been looking for reasons to increase our exposure to commodities so, when a Canadian friend of mine suggested I read G&amp;R&rsquo;s latest Natural Resource Market Commentary, the timing was perfect. Long-term readers of my work will be aware that I am bullish on a number of commodities already, many of which form a critical part of the green transition.</p>

<p>I have admittedly taken significant advantage of G&amp;R&rsquo;s work. <em>&ldquo;What do those four episodes have in common?&rdquo;</em> is largely a copy and paste of G&amp;R&rsquo;s Second Quarter 2024 commentary, and in <em>&ldquo;Could we possibly be too early?&rdquo;,</em> I answer the question by quoting heavily from G&amp;R&rsquo;s work. Having said that, <strong>unless stated otherwise, all opinions and conclusions are those of Absolute Return Partners and do not necessarily reflect those of G&amp;R.</strong></p>

<p>Apart from thanking Leigh and Adam, allow me to praise their work. Over the last 40 years, I have come across plenty of commodity research, both good and bad, and I rate their work near the top. They are always willing to think out of the box and are not afraid to stick their necks out &ndash; two labels you cannot put on too many analysts.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Ratio of Commodities Total Return Index-to-DJ Ind&rsquo;l Average Index </strong><br />
<em>Sources: Goehring &amp; Rozencwajg, Bloomberg</em></p>
' data-image='/Content/Images/66f58abe387f488e298c63fa_66f586f9f0870228d14754c9_Picture2.png#309;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#309;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#309;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#309;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Time to go big?</h4><p>Four times over the past 125 years, commodities have reached extreme levels of undervaluation relative to equities. It happened in the late 1920s, in the mid to late-1960s, again in the late 1990s, and we are now in the fourth episode of severe undervaluation since 1900 (Exhibit 1).</p>

<p>After each of the first three episodes, commodities went on to dramatically outperform equities; hence why it is tempting to conclude that the same is going to happen this time, but is it? As you will see in the following, I believe so, and I wrap this paper up by listing my favourites amongst the cavalcade of commodities on offer &ndash; commodities which, in my opinion, are particularly well positioned to deliver attractive returns over the next 3-5 years.</p>

<p>--image--</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#310;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#310;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#310;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#310;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What do those four episodes have in common?</h4><p>A closer inspection of the four troughs in Exhibit 1 reveals several similarities. To begin with, in the lead-up to all four inflection points, commodities plummeted by 50% or more, i.e., the underperformance has, in all four instances, been significant.</p>

<p>Secondly, the four episodes of commodity despair have all been accompanied by stock market manias:</p>

<p>(i) the broad market euphoria of the 1920s;</p>

<p>(ii) the Nifty Fifty craze of the late 1960s and early 1970s;</p>

<p>(iii) the dot-com bubble of the late 1990s; <em>and </em></p>

<p>(iv) the megacap tech mania of the last ten years.</p>

<p>Dual forces &ndash; declining commodity prices on one hand and exuberant equity markets on the other &ndash; have, in all four cases, driven the commodity-to-equity return ratio to extremes.</p>

<p>Thirdly, each instance of extreme commodity undervaluation was preceded by an extended period of benign monetary policy. In the 1920s, the Fed experimented with its first round of QE. In the 1960s, President Johnson toyed with his &ldquo;Guns and Butter&rdquo; policy programme. In the 1990s, Greenspan steered the Fed towards ever-easier monetary policy, and the 2010s were characterised by worldwide money-printing, following the Global Financial Crisis.</p>

<p>Fourthly, as commodities fell out of favour and equities soared, capital was diverted away from capex programmes in mining and energy. During the first three episodes, the supply/demand imbalance eventually pushed commodity markets from surplus to deficit, resulting in years of strong commodity returns.</p>

<p>Last but not least, the first three episodes coincided with a shift in the global monetary system. In 1931, economic hardship forced the UK government to come off the gold standard. In 1971, under President Nixon&rsquo;s leadership, the US also abandoned the gold standard which led to the collapse of Bretton Woods. And, in 1999, the fallout from the Asian currency crisis led to a wave of EM currencies being pegged to the US dollar at artificially low levels.</p>

<p>Could something similar happen again? I have recently written a paper on gold, where I argued that it is performing so well at present because the Chinese are pushing for the renminbi to replace the US dollar when EM nations trade with each other (you can find the paper <a href="https://www.arpinvestments.com/insights/what-to-expect-from-gold-when-the-monetary-policy-regime-is-changing">here</a>). Such a change would definitely go down in history as a significant shift in the global monetary system.</p>

<p>I have noted that Donald Trump has turned the Chinese desire to &lsquo;promote&rsquo; the renminbi into an election issue. In a recent rally, he said that the US will punish those countries not willing to trade in US dollars. Apart from the fact that it is a sign that he is aware of the Chinese ambitions, it is also a sign that the US is in danger of losing its position as the world&rsquo;s ultimate economic superpower &ndash; a position the US has held since the years after World War I, when it grabbed it from the UK.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2a: Annualised growth in US household asset wealth, 1952-1965</strong><br />
<em>Source: Strategic Economic Decisions, Inc.</em></p>
' data-image='/Content/Images/66f58abe387f488e298c63f3_66f5878d486799fe44f4c823_Picture3.png#311;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2b: Annualised growth in US household asset wealth, 1966-1980</strong><br />
<em>Source: Strategic Economic Decisions, Inc.</em></p>
' data-image2= '/Content/Images/66f58abe387f488e298c640e_66f587b2fec8655b66abb162_Picture4.png#311;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#311;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#311;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The link to our megatrend philosophy</h4><p>I first wrote about the concept of wealth regimes in early 2008, where I argued that wealth-to-GDP is long-term stable, and that it will always mean-revert, should the ratio diverge significantly from its long-term mean-value. It happens that wealth regimes and equity-to-commodity performance cycles are linked. There is almost always a wealth regime change around the inflection point in the equity-to-commodity performance cycle.</p>

<p>Take for example the inflection point in the 1960s identified by G&amp;R, and compare it to the two wealth regimes depicted in Exhibits 2a-b below, identified by Woody Brock of Strategic Economic Decisions, Inc. As you can see, equities delivered a robust return of +8.3% annually in the years leading up to the low point in the 1960s only to deliver a miserable -4.9% per annum in the years following the inflection point. As you can also see, the annual increase in household asset wealth dropped from +5.7% in the prior regime to only +0.6% in the latter.</p>

<p>--image--</p>

<p>--image2--</p>

<p>I draw two conclusions from that observation:</p>

<p>1. Equity returns have a significant impact on overall household wealth, particularly in the US where investments in public equities account for a much higher proportion of overall household wealth than it does elsewhere.</p>

<p>2. Given the close link between equity returns and wealth, and given the fact that I expect commodities to do much better than equities in the years to come, overall household wealth will probably be negatively impacted by this dynamic.</p>

<p>The latter of those two conclusions syncs with &ldquo;Mean Reversion of Wealth-to-GDP&rdquo; which is (we believe) the aggregate result of the seven megatrends we have identified. In the US, wealth-to-GDP has averaged about 3.8x over the last 75 years (before 1950, the data available is less precise). It is 5.7x at present, meaning that the ratio <em>must </em>mean-revert in the years to come. If we are close to another inflection point, and commodities begin to deliver much higher returns than equities, that could also mark the starting point for the long-awaited process of mean reversion of wealth-to-GDP.</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#312;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#312;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#312;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#312;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>A few words about fossil fuels</h4><p>Before going into a discussion about which commodities I favour, I should point out that, as part of our commitment to Responsible Investing, we do not take any views on fossil fuels, nor do we invest in oil, gas or coal. Having said that, I can certainly make a generic comment or two.</p>

<p>Some investors assume fossil fuel prices can only go one way, given the intent to phase out oil, gas and coal but that is, in my opinion, too simplistic an analysis (unless you take a 100-year view). You have to look at demand <em>relative </em>to supply to get a complete picture. In other words, if supply is falling even more than demand, fossil fuel prices can still rise, even if most countries are busy phasing them out.</p>

<p>It goes without saying that this logic is not specific to fossil fuels but can be deployed across the board. However, given the unique circumstances surrounding fossil fuels at present, it is particularly relevant to keep this in mind when assessing this class of commodities.</p>

<p>I should stress that this is <em>not </em>an implied recommendation of fossil fuels. Supply continues to hold up quite well, leaving it reasonably well balanced with demand at present, i.e., you can read nothing into the comments just made.</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#313;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#313;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#313;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#313;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>My favourite commodities</h4><p>Many commodities have caught my attention more recently &ndash; some because they look attractively priced, others because various dynamics have established truly unique circumstances. In no particular order, my favourite commodities at present include:</p>

<p>- water;</p>

<p>- gold;</p>

<p>- uranium;</p>

<p>- various green materials; and</p>

<p>- sustainable farming.</p>

<p><strong>Our water investment thesis</strong></p>

<p>Water is not even considered to be a commodity by many investors but it certainly is. In fact, it is the most important commodity of them all. As Benjamin Franklin once said, <em>&ldquo;when the well is dry, we know the worth of water&rdquo;</em>, and that sums up our investment thesis quite well. Water is not only the most important commodity to mankind. &nbsp;Without it, most of us won&rsquo;t survive for more than 72 hours, and the well is drying up.</p>

<p>The global annual temperature has increased 0.06&deg;C per decade since 1850 (the early days of the industrial revolution) and by 0.2&deg;C since 1982, leading to a total rise in the global average temperature since 1850 of about 1.3&deg;C (source: NOAA). These numbers are factual, and it is irrelevant whether the ongoing climate change is manmade or not. Regardless of the underlying cause(s), the temperature increase is having a massive impact on water &ndash; on the total amount of it, on the quality of it and on our ability to access it.</p>

<p>Over 70% of planet Earth is covered in water; however, little of it can be used for drinking. Only 2.5% of all water is freshwater, and only 1% of all freshwater is easily accessible. &nbsp;Over the past 40 years, the world&rsquo;s population has doubled, whilst water consumption has quadrupled. Worldwide, 800Mn people (about 10%) have no access to clean drinking water, and about 4Bn people experience severe water scarcity for at least one month every year.</p>

<p>Agriculture accounts for about 72% of all freshwater withdrawals worldwide, and the number is rising. &nbsp;A growing population, as well as rising living standards, will cause agriculture&rsquo;s consumption of freshwater to increase dramatically. By 2040, if we continue to do what we are doing today, there will not be enough water in the world to quench the thirst of everybody and, at the same time, keep the current energy and power solutions going.</p>

<p><em>How can there be water shortages when sea levels are rising?</em></p>

<p>Plain logic would suggest that rising sea levels should address the water shortage problem, but things are not as simple as that. &nbsp;Rising sea levels are mostly caused by melting glaciers and other ice, and almost all of the melted ice ends up in the sea, effectively turning freshwater into saltwater.</p>

<p>A good example is the city of Philadelphia. &nbsp;Currently, the Delaware River&rsquo;s salt front lies 40 miles from Philadelphia&rsquo;s most important drinking water intake. &nbsp;If sea levels were to rise by 3 feet, the salt front would move upstream to within 12 miles of Philadelphia&rsquo;s city centre, and it is worth noting that sea levels in that part of the world are rising 25% faster than the global average, because the mid-Atlantic coast between New York and Virginia is sinking at the same time as sea levels are rising.</p>

<p>Therefore, even a modest rise in sea levels can cause problems along that coastline. &nbsp;The latest estimates suggest that sea levels along the New Jersey coastline will have risen 1.1 foot by 2030, up to 3.5 feet by 2070, and up to 6.3 feet by the end of the century.</p>

<p>Furthermore, if much ice melts now, the rivers will be fed less melted ice going forward, meaning that, in the future, many of the water systems responsible for providing our water supplies today will dry out. &nbsp;Also, rising sea levels are indicative of other problems, as the rise is at least partially a function of the thermal expansion caused by the excess intake of CO2 by the oceans.</p>

<p>When we first established the water basket, we took the view that the best way to invest in this theme would be through various water technology &amp; treatment companies &ndash; companies offering a technology that can convert non-drinkable water to drinkable water &ndash; and we continue to follow that philosophy with four of the five names in our Water basket ticking that box.</p>

<p><strong>Our gold investment thesis</strong></p>

<p>Over the last 100 years or so, the monetary policy regime has fundamentally changed 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.</p>

<p>2. In 1971, under President Nixon&rsquo;s leadership, the US also abandoned the gold standard which 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. When the Asian financial crisis suddenly erupted, 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. We believe the same could happen again. The Chinese increasingly settle in renminbi when trading commodities with other EM countries, and it is pretty obvious that they are trying to establish a new currency block. The objective is to promote the Chinese currency as a credible alternative to the US dollar, we believe.</p>

<p>It is tempting to argue that such an arrangement won&rsquo;t work for as long as the renminbi is not freely tradeable and transferable, but there is a catch to that argument. The Chinese have 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 have been massive buyers of gold more recently.</p>

<p><strong>Our uranium investment thesis</strong></p>

<p>A nuclear power station runs at full speed 24/7 unless it is down for maintenance. It is quite simply too expensive to reduce the output for shorter periods of time &ndash; for example at nighttime or over weekends. And, for that reason, demand for uranium is highly predictable, making the investment case mostly about supply swings.</p>

<p>Not that demand is irrelevant or that it is not growing; it is indeed, but it is highly predictable and subject to long lead times. In the OECD, it typically takes at least eight years from the decision is made to build a new reactor until the output can be added to the grid. Supply, on the other hand, is far less predictable. Quite regularly, uranium mining companies run into problems that force nuclear power stations to take from inventories instead.</p>

<p>The combination of a run-down uranium mining industry, record-low supplier-controlled inventories and a very rich pipeline of new reactors under construction attracted us to uranium in the first place. Worldwide, there are about 440 nuclear reactors up and running today. A further 60 are currently under construction, and another 110 will go into construction over the next few years. Most of those are in Asia. In China alone, there are plans for over 200 nuclear reactors &ndash; more than have been built in the rest of the world over the past 35 years.</p>

<p>Last time demand dramatically exceeded supply, the uranium price peaked at $148 (in May 2007). With more than 200 new reactors scheduled to come onstream in China alone and almost twice that many worldwide over the next ten years, it is hard not to be bullish on the uranium price.</p>

<p><strong>Our green materials investment thesis</strong></p>

<p>The green materials universe, as we define it, consists of a broad mix of green metals and other materials that stand to benefit from the green transition. Certain industrial metals, e.g. copper and aluminium, are included, as they are critical to the green agenda. So are &lsquo;dedicated&rsquo; green metals like lithium. We also include other green materials like rare earths as, without them, the green transition would never happen.</p>

<p>In the following few paragraphs, I focus exclusively on lithium, the reason being that a unique buying opportunity is unfolding in that commodity. This does not imply that other green materials are not attractively priced; however, at current prices, the upside opportunity in those commodities is less spectacular than it is in lithium.</p>

<p>As a result of global oversupplies, lithium carbonate prices have been through a horrendous bear market since late 2022, which has resulted in price falls on the commodity of about 90%. Lithium miners haven&rsquo;t done much better with the average miner being down 80% over the same period. I should stress that demand for lithium has <em>not </em>collapsed &ndash; not at all. Demand from most countries has risen robustly; however, global lithium markets were suddenly being dramatically oversupplied.</p>

<p>In 2020-22, lithium was widely expected to become the new oil and Chile to become the new Saudi Arabia. That viewpoint has faded over the last 18-24 months, but I strongly suspect the worst is now over and a new bull market is awaiting. For many years to come, lithium will be a critical commodity in the green transition, and overly ambitious capex programmes in the lithium mining industry are now being adjusted downwards which should, within the next 24-36 months, result in a much better balance between demand and supply.</p>

<p>I have been assured by battery industry insiders that there is no viable alternative to lithium on the horizon. Lithium is the key fuel and will remain the key fuel for at least another 10-15 years. I have written extensively about the next generation of batteries &ndash; the so-called solid-state batteries which will, most likely, out-compete lithium-ion batteries over the next 5-10 years. In that context, it is worth noting that solid-state batteries use even more lithium than lithium-ion batteries do.</p>

<p>It is also worth pointing out that the first commercial fusion reactor is no more than 10-12 years away now. For the uninitiated, a fusion reactor is a nuclear reactor, but the fusion process is fundamentally different from the fission process, used in all commercial nuclear reactors today. Fusion energy is the ultimate solution to our fast-growing energy needs. In a fusion reactor, the marginal cost of generating an extra kW of electricity is virtually zero, it is much safer than fission energy, it produces far less waste, and lithium makes up the fuel in a fusion reactor.</p>

<p>For all those reasons, the future looks bright for lithium. If, as expected, reduced capex programmes in the mining sector bring supply in line with demand by late 2026 or early 2027, lithium mining stocks should start to perform better at least 12 months before, i.e., within the next 12-15 months or so. Given how poorly they have performed over the last couple of years, there is probably little downside risk associated with investing prematurely.</p>

<p>I would recommend for investors to only invest in lithium mining stocks to begin with, as they typically outperform the commodity price in the early stages of a recovery. Then, as improving fundamentals become more visible, I would switch to the commodity (mostly lithium carbonate). Such a trading strategy is likely to maximise returns.</p>

<p><strong>Our sustainable farming investment thesis</strong></p>

<p>Sustainable farming is the least researched of the five opportunities I refer to in this paper. Admittedly, we have not yet begun to invest in sustainable farming, but there is a whole host of reasons why we should. The best reason of them all &ndash; the agricultural industry&rsquo;s excessive use of freshwater &ndash; is only one of many. More than 70% of all freshwater withdrawn worldwide every year is used by farmers, and that is clearly unsustainable when you think of the growing scarcity problem.</p>

<p>If you take continued population growth and rising living standards into account, it is no wonder that the UN expects demand for freshwater to continue to grow rapidly in the years to come. Freshwater withdrawals amounted to 4.3 trillion m3 worldwide last year, up six-fold since 1900, and is expected to rise by another 25% between now and 2050 (source: <a href="https://irrigreen.com/pages/water-consumption-statistics#:~:text=Our%20global%20freshwater%20consumption%20reaches,meters%20of%20this%20precious%20resource">irrigreen.com</a>).</p>

<p>One important factor which distinguishes sustainable farming from the other opportunities mentioned in this paper is that sustainable faming is not only about commodities but also about the technologies used by farmers to make farming sustainable.</p>

<p><em>An example</em>: Israeli farmers have, to a significant degree, replaced conventional sprinkler-based irrigation systems with underground dripping tubes. The method uses a network of tubes, valves and drippers that apply nearly 100% of the water directly into the roots, thereby dramatically reducing the water used to grow crops without compromising output (source: <a href="https://climateadaptationplatform.com/israels-water-technology-and-innovation-lead-to-resilience-and-surplus/#:~:text=The%20method%20uses%20a%20network,crops%20without%20compromising%20agriculture%20output">climateadaptationplatform.com</a>).</p>

<p>Today, 75% of all Israeli farmers use this technology, and it is an example as to how farming can be made sustainable through the use of better technology, and why there is more to sustainable farming than investing in the right commodities.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: Performance of natural resource equities vs. broader equity indices &nbsp;</strong><br />
<em>Sources: Goehring &amp; Rozencwajg, CRSP, Bloomberg</em></p>
' data-image='/Content/Images/66f58abe387f488e298c63f6_66f58a529227f9e1937ac4bb_Picture5.png#314;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#314;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#314;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#314;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Could we possibly be too early?</h4><p>Going back to Exhibit 1 for a moment, as you can see, the present inflection point looks more like the one in the mid to late-1960s than it looks like the two other inflection points, both of which were much sharper (the late 1920s and the late 1990s respectively). This raises the inevitable question: could we possibly be too early with our recommendation?</p>

<p>Going back to the work conducted by G&amp;R, the same question is raised in the company&rsquo;s 2Q24 investor report, and their conclusion is somewhat surprising: <em>&ldquo;When commodities and natural resource equities are deeply undervalued such as they were in the mid-1950s, the cost of buying into these markets is surprisingly low &ndash; if it exists at all.&rdquo;</em></p>

<p>Allow me to share some more thoughts provided by G&amp;R (and I quote):</p>

<p>&ldquo;In December 1954, the commodity-to-Dow ratio breached the 1:1 threshold, a moment that might have signalled a bottom. Yet, rather than rallying as one might expect, the ratio meandered lower, descending over the next eleven years to a low of 0.4 by February 1966. Even then, the awaited rally did not materialise with any vigour, instead lingering in a range until finally breaking higher in 1970. By 1981, however, the ratio had soared to a remarkable 4:1&mdash;one of the loftiest readings on record.</p>

<p><em>&ldquo;While the commodity-to-Dow ratio continued its descent during the subsequent decade, commodity prices themselves did not stand still. Between December 1954 and January 1970, commodities advanced by 25%&mdash;a modest gain, to be sure, yet upward progress nonetheless. Natural resource equities, meanwhile, benefitted from investor neglect, and their depressed valuations offered investors tremendous opportunity. From December 1954 to January 1970 the basket of natural resource stocks delivered a total return of 320% during this period, outpacing both the Dow and the S&amp;P 500, which rose by 135% and 294%, respectively. On an annualized basis, the resource stock basket returned 10.0%, comfortably ahead of the Dow&rsquo;s 5.8% and the S&amp;P 500&rsquo;s 9.5%.</em></p>

<p><em>&ldquo;Being early, as it turns out, was no disadvantage. Yes, the ride was bumpy&mdash;the maximum drawdown for our commodity stock basket was a daunting 36% in late 1957, compared with 22% for the Dow and S&amp;P 500 in 1962. Yet, for those with the fortitude to weather the volatility, the rewards were substantial.</em></p>

<p>--image--</p>

<p><em>&ldquo;From 1970 to 1980, as commodities surged, natural resource equities truly came into their own, quintupling in value with a 16% annual return. By contrast, the Dow and S&amp;P 500, with gains of 93% and 122%, respectively, advanced at an annual clip of 6.4% and 7.8%&mdash;both trailing resource equities by significant amounts. </em>(Exhibit 3.)</p>

<p><em>&ldquo;Viewed from the broader perspective of 1954 to 1980, the investor who stepped in when the commodity-to-Dow ratio first broke one in 1954 would have achieved a staggering 2,000% return, or 12.5% annually. The Dow, for all its &ldquo;blue chip&rdquo; lustre, advanced by a comparatively modest 385%, or 6.3% annually, while the S&amp;P 500 rallied 828%, or 9.0% annually. In relative terms, the natural resource investor outperformed the Dow by 6.2% and the S&amp;P by 3.5% annually.</em></p>

<p><em>&ldquo;Ironically, we believe the biggest risk is in being late. Waiting until 1970 would have meant missing half of the rally. Had an investor chosen the Dow from 1954 until 1970 and then presciently switched to commodity stocks, his total cumulative return would have been half of what it would have been if he had simply bought commodity stocks early. Had he instead chosen the S&amp;P 500 before changing course adeptly in 1970, his return would still have trailed. Factoring in the realised capital gains impact of rotating from the S&amp;P to resource stocks, of course, makes our case much stronger.&rdquo;</em></p>

<p>In other words, if one can stomach a fair amount of volatility, and investors have indeed been confronted with plenty of it over the years, history suggests that the cost of being early in commodities is negligible, and that investors will be handsomely rewarded once the tide turns.</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#315;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#315;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#315;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#315;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final few words</h4><p>I should stress that a basket consisting of the commodities discussed in this paper is not a typical commodity basket, and your tracking error vis-&agrave;-vis for example the Bloomberg Commodities Index (BCOM) will be massive. Energy alone accounts for 30% in BCOM and grains for 23%. We have nothing in either but grains are work-in progress. This may or may not be acceptable to you, but you need to know.</p>

<p>The other point I must emphasize is that gold has already had a good run this year. It entered 2024 at $2,065/oz and now, at the time of writing, stands at $2,665/oz; i.e. a gain of $600 (+29%) has already been made YTD. Does this warrant some caution? It certainly does, and I can almost guarantee that there will be bumps on the road as we move forward. Having said that, I expect to see at least $3,000/oz before this is over, so I am hanging on.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>26 September 2024</strong></p></div></div></div>