Slutet är nära,
med Peter Thiel

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-154317"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="154317" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="U2x1dGV0IMOkciBuw6RyYSw8YnI+bWVkIFBldGVyIFRoaWVs" data-acurl="aHR0cHM6Ly9rdmFydGFsLnNlL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzAzL2t2YXJ0YWwtcHJlbnVtZXJlcmEtMDMtaGlyZXMubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTMtNTItc2x1dGV0LWFyLW5hcmEtc2x1dGV0LWFyLW5hcmEtX21lZC1wZXRlci10aGllbC5tcDM=">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: "><div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslutet-ar-nara-med-peter-thiel%2F&amp;t=Slutet+%C3%A4r+n%C3%A4ra%2C%3Cbr%3Emed+Peter+Thiel"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Slutet+%C3%A4r+n%C3%A4ra%2C%3Cbr%3Emed+Peter+Thiel+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslutet-ar-nara-med-peter-thiel%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslutet-ar-nara-med-peter-thiel%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Slutet är nära,<br>med Peter Thiel&body=https://kvartal.se/artiklar/slutet-ar-nara-med-peter-thiel/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/154317/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/lapo-lappin/">Lapo&nbsp;Lappin</a> | 26 oktober 2024<div class="author-desc">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslutet-ar-nara-med-peter-thiel%2F&amp;t=Slutet+%C3%A4r+n%C3%A4ra%2C%3Cbr%3Emed+Peter+Thiel"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Slutet+%C3%A4r+n%C3%A4ra%2C%3Cbr%3Emed+Peter+Thiel+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslutet-ar-nara-med-peter-thiel%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fslutet-ar-nara-med-peter-thiel%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Slutet är nära,<br>med Peter Thiel&body=https://kvartal.se/artiklar/slutet-ar-nara-med-peter-thiel/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/154317/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/slutet-ar-nara-med-peter-thiel/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 16 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/154317"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-154317">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "154317"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Dagens miljardärer bryr sig inte om pengar. Åtminstone om man ska tro dem själva. Allt flera techmiljardärer försäkrar oss om att det som de verkligen brinner för är mänsklighetens framtid. De har filantropiska men också intellektuella anspråk och anser sig kunna tyda tidens tecken och urskilja den smala vägen framåt.</p>
<h2>Techfilosofernas tid är nu</h2>
</div>
<div class="rest-of-article ">
<p>Ett exempel på en sådan filosof-entreprenör var grundaren av kryptovalutaföretaget FTX, <strong>Sam Bankman-Fried</strong> (som jag tidigare har <a href="https://kvartal.se/artiklar/givarfilosofin-bakom-kryptokraschen/">skrivit</a> om i Kvartal). Innan han blev dömd till 25 års fängelse för bedrägeri och andra brott var Bankman-Fried en frontfigur för den etiska filosofirörelsen Effektiv altruism. Flera Silicon Valley-figurer har gått i samma fotspår till EA–rörelsen, som leds av ”miljardärernas filosof” <strong>William MacAskill</strong> (som jag har <a href="https://kvartal.se/artiklar/fragan-som-far-miljardarernas-filosof-att-tystna/">intervjuat</a> för Kvartal).</p>
<p>Den mest uppmärksammade filosofiska miljardären är dock utan tvekan<strong> Elon Musk</strong> (som jag – hör och häpna – också <a href="https://kvartal.se/artiklar/elon-musks-plan-for-manniskan/">porträtterat</a> i Kvartal). När Musk som tonåring läste <strong>Douglas Adams</strong> <em>Liftarens guide till galaxen</em> fann han en färdplan som kunde vägleda honom resten av livet. Han landade i att meningen med livet är att hitta meningen med livet – och för att göra detta måste vi ”expandera medvetandets skala och räckvidd”, det vill säga smälta samman mänskliga hjärnor med AI och sprida den mänskliga civilisationen till andra planeter.</p>
<p>Men den mest intressanta figuren i detta färgstarka landskap – den mest provocerande och svårfångade – är den tyskfödde och i Sydafrika och Namibia uppväxte amerikanske techmiljardären <strong>Peter Thiel</strong>, 57 år.</p>
<p>Få personer har lika stort inflytande på den ekonomiska och politiska samtiden.</p>
<h2>I kulisserna bakom Trump och JD Vance</h2>
<p>Thiels förmögenhet och rykte som en skicklig finansman grundar sig i stor utsträckning på att han stod för den första externa investeringen i Facebook. Dessutom är han medgrundare till dataföretaget Palantir Technologies. Men Thiels kometkarriär i Silicon Valley började när han grundade den digitala betalningtjänsten Paypal. Där arbetade han med bland andra Elon Musk.</p>
<p>På många sätt är Musk och Thiel lika varandra, inte minst politiskt. Thiel beskriver sig som libertarian och precis som Musk är han influerad av den nyliberala husguden, författaren <strong>Ayn Rand</strong>. Bägge är i 50-årsåldern och tillbringade formbara barndomsår som vita i södra Afrika. Bägge stöttar Donald Trumps sida av politiken. Thiel skänkte pengar till Donald Trumps kampanj 2016 och har varit mentor för Trumps vicepresidentkandidat <strong>JD Vance</strong>, som under en tid arbetade för Thiels företag Mithril Capital.<sup>1</sup> Thiel skänkte dessutom 15 miljoner dollar till Vances valkampanj för senaten.<sup>2</sup></p>
<p>Musk och Thiel slåss även på samma sida i det amerikanska kulturkriget. Elon Musk har enligt egen utsaga vigt sitt liv åt att utrota det han kallar för <em>the woke mind virus</em>, det vill säga vänsterideologin som dominerar på amerikanska universitetscampus. Även Thiel har engagerat sig i campuspolitik. Redan 1995 författade han tillsammans med sin medstudent på Stanford, <strong>David Sacks</strong>, boken <em>The diversity myth</em>, som går till attack mot vad de uppfattar som en politiskt korrekt ideologi på amerikanska elituniversitet.</p>
<p>Men på flera andra sätt skiljer sig Musks och Thiels perspektiv åt. Musk har aldrig riktigt vuxit ifrån sin pubertala Randianska libertarianism. Hans filosofi formades enligt honom själv när han var tretton år gammal, och han har sedan dess aldrig upplevt behovet av att revidera den. Thiel har däremot en kandidatutbildning i filosofi från Stanford, där han på senare tid även undervisat.</p>
<p>Medan Musk präglas av en närmast banal optimism, en blåögd tro på människans och teknologins potential, är Thiels utblick desto dystrare. Han ser en värld av mörka makter och dunkla drifter.</p>
<h2>Inspirerad av Jünger, Carl Schmitt, Heidegger – och Tolkien</h2>
<p>Thiel brukar ibland beskrivas som “libertarianskt konservativ.” Begreppet låter nästan som en självmotsägelse; libertarianismen strävar efter en total frigörelse från staten och att släppa marknadskrafterna fria, vilket innebär upplösning. Klassisk konservatism motsätter sig däremot radikal samhällsomvandling. Libertariansk konservatism är dock en träffande beskrivning av Thiels idiosynkratiska blandning av Ayn Rand och en rad tyska tänkare från den så kallade ”konservativa revolutionen” på 20- och 30-talen. Hit hör figurer som <strong>Ernst Jünger</strong> och <strong>Martin Heidegger</strong>, liksom Thiels favoriter <strong>Carl Schmitt</strong> och <strong>Leo Strauss</strong>. Gemensamt för dessa män är deras misstro mot den liberala demokratin; Schmitt blev medlem av nazistpartiet redan 1933. Thiel liknar dessa tänkare vid dvärgarna i <strong>J.R.R. Tolkiens </strong><em>Sagan om ringen</em>, vars utgrävningar tar dem för djupt in i urberget så att de till slut väcker monstret Balrog.<sup>3</sup> Detta är för övrigt en pojkrumsbok som har haft stor påverkan på Thiel. Han har namngett sex bolag efter Tolkiens värld.</p>
<p>Men det motsägelsefulla i libertariansk konservatism speglar också något grundläggande motsägelsefullt i människan Thiel. Detta är en inbiten frihetsvän som grundat ett företag som sysslar med statlig övervakning av civila medborgare. Homosexuell, gift sedan 2017 med investeraren <strong>Matt Danzeisen</strong> <strong>– </strong>men som samtidigt stödjer en vicepresidentkandidat som sagt att han skulle ha röstat mot samkönade äktenskap. En entreprenör som har byggt sin förmögenhet på sociala mediers framgång, men endast tillåter sina barn (tre och fem år) en och en halv timmes skärmtid i veckan.<sup>4</sup></p>
<p>Man kan säga att hela Thiels tänkande kretsar kring två avgörande händelser. Den ena är ett livsomvälvande personligt möte, det andra en världsomvälvande kris.</p>
<h2>Blev rik på avundsjukans teori</h2>
<p>Under hans tid på Stanford lärde Thiel känna den franske antropologen och litteraturkritikern <strong>René Girard</strong>. Fransmannen hade rykte om sig att vara en tänkare som simmade mot strömmen, något som föll Thiels konträra böjningar väl in.<sup>5</sup> Girard kom att bli en slags mentor och intellektuell förebild.</p>
<p>René Girards tänkande är vindlande och komplext. Den franske professorns intellektuella gärning spänner från <strong>Proust</strong> och <strong>Shakespeare</strong> ända till hinduistisk religion och psykoanalys. Trots detta är kärnan i Girards tänkande förvånansvärt överblickbar. Girard tror sig nämligen ha hittat en enda princip ur vilken alla kulturella former kan härledas. Hela Girards tänkande kretsar kring två idéer: det <em>mimetiska begäret</em> och <em>syndabocksmekanismen. </em></p>
<p>Det som särskiljer människan från djuren, enligt Girard, är människans förmåga att härma, att efterapa. Såklart kan i viss mån även djur imitera – men Girard menar att vi gör det på ett särskilt sätt. Människan är det ”mimetiska djuret”, från grekiskans <em>mimesis</em> (efterlikning).</p>
<blockquote><p>Thiel insåg att Facebook livnär sig på människans allra djupaste psykologiska mekanismer.</p></blockquote>
<p>Vidare menar Girard att människan inte vet vad hon egentligen vill. Visst, vi har vissa fysiska begär: mat, dryck, sömn, sex… Men bortom detta är människan osäker på vad hon egentligen längtar efter. Därför gör hon det hon gör bäst: hon <em>imiterar</em> andras begär. Hon tittar på vad människor omkring henne strävar efter och siktar på samma föremål. Det mänskliga begäret är således ett <em>mimetiskt begär</em>.</p>
<p>Vi brukar tänka att relationen som uppstår när någon begär ett objekt består av två komponenter: personen och det åtrådda objektet. Girard menar att begäret är triangulärt. Utöver personen som begär och objektet finns alltid en tredje komponent: en mänsklig motpart (eller rival) som också strävar efter samma objekt.</p>
<p>Det finns även experimentellt stöd för Girards teori. Exempelvis får ett barn leka med en leksak i ett rum fylld med många helt identiska leksaker. Sedan får ytterligare ett barn träda in i rummet. Vilken av leksakerna kommer det nya barnet vilja leka med?</p>
<p>Det är bland annat Girards teori om det mänskliga begäret som motiverade Thiels tidiga investering i Facebook. Sociala mediers framgång bygger på det ohämmade mimetiska begäret, avundsjukan som släpps loss i en evig tävling av jämförelse och statusjakt. Thiel insåg att Facebook livnär sig på människans allra djupaste psykologiska mekanismer.</p>
<h2>Syndabockar skapar samhällelig stabilitet</h2>
<p>Den andra huvudidén i Girards allomfattande teori är det som han kallar för <em>syndabocksmekanismen</em>. Genom att studera antika och primitiva samhällen hittade Girard en sorts krishanteringsmekanism som går igenom alla mänskliga civilisationer. Det mimetiska begäret hotar alltid att spilla över i våld på ett sätt som hotar all samhällelig stabilitet. När en sådan upptrappning hotar brukar samhällen gå ihop och peka ut en enda individ som ansvarig för krisen. Genom att utöva kollektivt våld mot en ”syndabock” riktar sig hela samhället i en enda riktning och på så sätt stoppas den mimetiska upptrappningen. Efter att syndabocken har offrats återgår samhället till stabilitet, något som gruppen tolkar som en magisk konsekvens av det kollektiva mordet.</p>
<p>Enligt Girard kan vi fortfarande se kvarlevor av syndabocksmekanismen runt omkring oss. Peter Thiel illustrerar detta i sin studie av techgrundares uppgång och fall i boken <em>Zero to one</em> (2014), hur <strong>Steve Jobs</strong> eller <strong>Mark Zuckerberg</strong> går från att hyllas till skyarna till att bli syndabockar. Men Girard menar också att mekanismen har förlorat sin gemenskapsskapande kraft. Detta delvis på grund av den judiska och kristna religionens omsorg för dem som är offer för samhället, som har gjort det svårare att offra en enskild individ för hela samhällets gagn. Den andra haken är vår moderna medvetenhet om psykologiska processer, som gör det svårare att åstadkomma den magiska stabiliteten som återkommer vid syndabockens utstötande från gemenskapen.</p>
<p>Girard ser denna utveckling som tveeggad. Å ena sidan blir våldets mekanismer blottlagda, vilket är något gott, å andra sidan är just dessa mekanismer den enda möjligheten till att skapa samhällelig stabilitet. Därför befinner vi oss i en situation där inget längre kan stoppa en mimetisk våldsspiral.</p>
<p>För Girard innebär detta att vi lever i en apokalyptisk tidsålder. Drivna av mimetiskt begär införskaffar länder kärnvapen på grund av att andra länder redan har dem. Girard tolkar detta som att vi står på randen till ett apokalyptiskt kärnvapenkrig.</p>
<h2><em>9/11</em> visade liberalismens tillkortakommanden</h2>
<p>I juli 2004 var Peter Thiel med och organiserade en konferens på Stanforduniversitetet om René Girard med temat politik och apokalyps. I samband med detta författade miljardären ett bidrag som numera uppnått en närmast legendarisk status. Uppsatsen heter <em>The Straussian moment</em>.</p>
<p>Öppningsraden lyder: <em>The twenty-first century started with a bang on September 11, 2001.</em><sup>6</sup></p>
<p>Thiel definierar detta ögonblick som ”Straussianskt”, efter den tysk-judiske filosofen<strong> Leo Strauss</strong>. Denne hävdade att den moderna filosofin har glömt de djupaste frågorna som hör till den politiska filosofin: Vad är en människa? Vad är ett gott samhälle? Modernitetens svar är att det inte finns något riktigt svar. Frågorna som intresserar oss nu handlar i stället om medel, aldrig om ändamålen. För att återuppliva dessa frågor menar Strauss att vi måste vända oss tillbaka till antikens politiska filosofi.</p>
<p>Men sättet på vilket Strauss föreslår att vi ska läsa antikens filosofi skiljer sig från den vedertagna uppfattningen. Enligt Strauss har filosofen alltid haft en obekväm relation till staten. Filosofens idéer kan utgöra ett hot mot samhällsordningen, något som gör att han kan råka ut för förföljelse. Strauss hävdar att antika filosofer brukade skriva ”mellan raderna”, det vill säga koda in hemliga budskap som var stötande för dåtidens samhälle.</p>
<p>Strauss lever som han lär. För att tvinga läsaren att läsa mellan raderna är hans skrifter ibland avsiktligt dunkla. Detta gäller i stor grad även för Thiel. <em>The Straussian moment</em> är en svårfångad text.</p>
<p>Kärnan i Thiels resonemang verkar vara detta: när terrorattackerna den 11 september ägde rum, så blottades upplysningsliberalismens tillkortakommanden. I upplysningens anda tolkar liberalismen människan som en rationell ekonomisk aktör. Liberalismen ignorerar därför frågan om våld; våld går alltid att undvika, och kommer slutligen att försvinna tack vare fri handel och framsteg.</p>
<p>Därför är islamisk terrorism fullständigt obegriplig för liberalismen. Här är människor som står helt utanför upplysningsliberalismens ramverk, som tar till våld i Guds namn. Den islamiska terrorismen påminner om ett arv som Väst har lagt bakom sig när den trädde ut ur religionskrigen.<em> 9/11 </em>skakar därför liberalismens grundvalar. Attentatet visar att sanningen om människan är en annan än den som liberalismen berättar för oss. Det är en mörkare och obehagligare sanning, att människan i grunden inte är rationell utan våldsam.</p>
<p>Exakt hur Thiel menar att vi ska lösa denna motsättning förblir oklart. Å ena sidan menar han att svagheten i det liberala projektet har blottlagts, å andra sidan medger han att alternativet att vrida tillbaka klockan till ett tidigare civilisationsstadium innebär alldeles för mycket våld. Man anar att svaret finns någonstans mellan raderna. Svaret är kanske inte teoretiskt utan pragmatiskt, en produkt av avvägningar som till stor del pågår i det fördolda. Man kanske borde leta efter svaret i Thiels praktiska verksamhet. 2002, i kölvattnet av 11 september-attackerna, blev Thiel medgrundare till övervakningsföretaget Palantir, som riktade sig till amerikanska underrättelsetjänster och erbjöd ett sätt att handskas med stora datamängder. Palantir har fått smeknamnet <em>the killer app</em>, efter att den möjliggjorde dödandet av <strong>Usama bin Ladin</strong>.</p>
<p>Namnet Palantir kommer från de magiska stenarna i <em>Sagan om ringen</em>, ett slags kristallkulor som tillåter en att se på avstånd.</p>
<p>Problemet som Thiel sade sig vilja lösa var att ”bekämpa terrorism samtidigt som man behåller medborgerliga rättigheter”.<sup>7</sup> Huruvida ett företag som livnär sig på omfattande civil övervakning kan uppnå detta är tveksamt. Man kan misstänka att något annat skymtar mellan raderna – att friheten, enligt Thiel, bara kan överleva i den nya världsordningen om den tummar lite på sina principer och svarar på våld med våld, övervakning och spionage – men aldrig öppet, utan i det fördolda, precis som Strauss skulle anbefalla.</p>
<h2>Thiel: Slutet är nära, antikrist kommer</h2>
<p>På senare tid har Thiels tänkande kretsat kring ett annat motsatspar, inspirerat av det apokalyptiska stråket i Girards tänkande. Thiel menar att vi står inför ”Skylla och Karybdis” – i enlighet med <em>Odysséens </em>beskrivning av hur <strong>Odysseus</strong> var tvungen att navigera mellan klippmonstret Skylla och malströmmen Karybdis. Thiel tar även till Uppenbarelseboken i Bibeln för att beskriva sina farhågor: Harmagedon och antikrist. Här lånar Thiel fritt från rättsfilosofen och nazisten Carl Schmitt, som läste den politiska historien genom apokalyptiska glasögon.</p>
<p>Harmagedon är Bibelns namn för striden vid världens slut. Thiel menar att Harmagedon är en verklig möjlighet i och med hotet av ett kärnvapenkrig, precis som Girard förutspådde. Thiel verkar numera tro att Harmagedon närmar sig i stormsteg med krigen i Ukraina och Gaza samt upptrappningen mellan Kina och Taiwan.<sup>8</sup></p>
<p>Thiel menar dock att hotet av Harmagedon tar för mycket plats i det allmänna medvetandet. Vi är alldeles för upptagna av undergångsscenarier. Det gör att vi glömmer att oroa oss för det andra hotet, som Thiel kallar för antikrist. Thiel påpekar att enligt Johannesbreven i Bibeln kommer den falske frälsaren antikrist att komma innan sista striden, vilket borde få oss till att vara minst lika bekymrade över antikrist, om inte mer.<sup>9</sup></p>
<p>I Thiels vision är antikrist en världsstat. Entreprenörens värsta mardröm är att en politisk instans (exempelvis FN) skulle ta makten över hela världen och utöva kontroll på en global nivå. I vår rädsla för undergången söker vi frälsning i politiken, vi strävar efter allt mer kontroll över de teknologiska krafter vi har skapat. Politiken tar till allt mer omfattande reglering och övervakning för att förhindra den annalkande katastrofen.</p>
<p>Redan i <em>The Straussian moment</em> citerar Thiel Schmitts dystopiska spådom om en enad världsordning. Denna “trygghetens tidsålder” kan enligt Schmitt enbart frambringas av “den sinistra magikern” antikrist, som kommer med löften om “fred och säkerhet”. Tryggheten har ett pris, och det är att man säljer sin själ till djävulen – eller, som Thiel skriver, att människan i världsstatens sömndruckna tillvaro helt enkelt “glömmer” att hon har en själ. Världsstaten är en slags surrogatvärld, en utopi för trygghetsnarkomaner: ”Likt <em>The matrix </em>för dem som inte har tagit det röda pillret”, enligt Thiel.<sup>10</sup></p>
<p>I Thiels farhågor om antikrist skymtar vi en djup skepsis mot politik i allmänhet. Med spjärn i Carl Schmitt ser Thiel politik som en fråga om vänner och fiender, som oundvikligen eskalerar i mimetisk konflikt. Frihet och demokrati är därför varandras motsatser. Libertarianismen kommer aldrig att röna framgångar i demokratiska val, något som Thiel i stor utsträckning skyller på att kvinnor fått rösträtt.<sup>11</sup></p>
<p>Nära kopplat till oron för att politiken ska svälla över är Thiels fruktan för teknologisk stagnation. Där andra ser en värld som utvecklas snabbare än någonsin teknologiskt ser Thiel stagnation. Risken att alla framsteg kan förvandlas till vapen i ett tredje världskrig har lett till att den teknologiska utvecklingen har stannat av, enligt Thiel. Bland AI-forskare i Silicon Valley finns det många som menar att artificiell intelligens kommer att innebära slutet på den mänskliga civilisationen. Som Thiel brukar sammanfatta situationen: ”Vi blev lovade flygande bilar, men allt vi fick var 140 tecken.” (På Twitter, numera Elon Musk-ägda X, kan man bara skriva 140 tecken åt gången.)</p>
<p>Hur tänker Thiel navigera mänskligheten mellan världsstatens Skylla och kärnvapenkrigets Karybdis? Här är Thiel något klarare: han skissar en ”smal väg” som civilisationens räddning. Thiels uttalade mål är att få vår civilisation att komma ”tillbaka till framtiden”, återerövra det teknologiska framsteget och undvika politik i så stor utsträckning som möjligt.</p>
<p>I ett tal på konferensen Libertopia år 2010 säger Thiel att ”teknologi är ett alternativ till politik”. Libertarianerna är för få för att genomdriva förändring på politisk väg. Men när Thiel kom till Silicon Valley så insåg han att genom teknologi kunde man driva igenom en ”ensidig” förändring: inte förlita sig på att övertyga folk som aldrig kommer bli libertarianer utan rikta sig till deras teknologiska behov.<sup>12</sup></p>
<blockquote><p>I slutändan är detta målet: att fasa ut politiken, avskaffa nationalstaten och bygga libertarianska enklaver där miljardärer innehar den suveräna makten.</p></blockquote>
<p>Det främsta sättet på vilket Thiel försökte göra detta är genom Paypal. Idag framstår digitala betalningslösningar som en del av vardagen. Men för Thiel var grundandet av Paypal nära kopplat med ”nationalstaternas upplösande”. För första gången var det inte en bank som hade kontroll över pengaflödet. Digitala pengar är svårare att spåra och beskatta, nästan omöjliga att kontrollera.<sup>13</sup></p>
<p>Ett annat sätt på vilket Thiel har försökt skapa en parallell värld till politiken var att investera en halv miljard dollar i projektet Seasteading, ledd av anarkokapitalisten <strong>Patri Friedman</strong> (barnbarn till den liberale ekonomen <strong>Milton Friedman</strong>).<sup>14</sup> Projektet kallas även för startup-stater: I stället för att starta företag vill man grunda självständiga stater genom att bygga artificiella plattformar på havet. Tanken är att precis som människor kan välja vilka företag de kan köpa från borde de kunna välja vilken nation som de bor i. Friedman lyckades aldrig ro i land projektet, och Thiels intresse svalnade.</p>
<p>Hur som helst visar det konturerna till Thiels framtidsplan. Att så mycket som möjligt bygga utrymmen vid sidan om politiken och demokratiska processer. Dessa ska på något sätt möjliggöra en sund och exponentiell teknologisk framväxt.</p>
<p>Men detta är inte enbart en teoretisk vision av framtiden. Det är ett projekt som Thiel arbetar hårt för att förverkliga. Delvis genom att investera i futuristiska projekt för att ”ta tillbaka framtiden”. Delvis också genom att investera i politiska kandidater som kan underlätta Thiels politiska vision. I slutändan är detta målet: att fasa ut politiken, avskaffa nationalstaten och bygga libertarianska enklaver där miljardärer innehar den suveräna makten. Man kan undra om den möjligheten låter så mycket bättre än undergångsscenarierna som Thiel så gärna vill undvika.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="154317">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li><a href="https://www.forbes.com/sites/antoniopequenoiv/2024/07/16/jd-vance-and-peter-thiel-what-to-know-about-the-relationship-between-trumps-vp-pick-and-the-billionaire/">https://www.forbes.com/sites/antoniopequenoiv/2024/07/16/jd-vance-and-peter-thiel-what-to-know-about-the-relationship-between-trumps-vp-pick-and-the-billionaire/</a></li>
<li>https://www.politico.com/news/2022/05/03/jd-vance-win-ohio-primary-00029881</li>
<li><a href="https://conversationswithtyler.com/episodes/peter-thiel-political-theology/">https://conversationswithtyler.com/episodes/peter-thiel-political-theology/</a></li>
<li><a href="https://www.businessinsider.com/peter-thiel-kids-screen-time-parenting-social-media-meta-tech-2024-6">https://www.businessinsider.com/peter-thiel-kids-screen-time-parenting-social-media-meta-tech-2024-6</a></li>
<li>https://www.youtube.com/watch?time_continue=2&amp;v=esk7W9Jowtc&amp;embeds_referring_euri=https%3A%2F%2Fwww.google.com%2Fsearch%3Fq%3Dthiel%2Bmet%2Bgirard%26oq%3Dthiel%2Bmet%2Bgirard%26gs_lcrp%3DEgZjaHJvbWUyBggAEEUYOTIHCAEQIRigATIHCAIQIRigATIHCAM&amp;source_ve_path=MjM4NTE</li>
<li><a href="https://gwern.net/doc/politics/2007-thiel.pdf">https://gwern.net/doc/politics/2007-thiel.pdf</a></li>
<li><a href="https://www.forbes.com/sites/andygreenberg/2013/08/14/agent-of-intelligence-how-a-deviant-philosopher-built-palantir-a-cia-funded-data-mining-juggernaut/">https://www.forbes.com/sites/andygreenberg/2013/08/14/agent-of-intelligence-how-a-deviant-philosopher-built-palantir-a-cia-funded-data-mining-juggernaut/</a></li>
<li>https://www.youtube.com/watch?v=SYRunzR9fbk</li>
<li><a href="https://conversationswithtyler.com/episodes/peter-thiel-political-theology/">https://conversationswithtyler.com/episodes/peter-thiel-political-theology/</a></li>
<li><a href="https://gwern.net/doc/politics/2007-thiel.pdf">https://gwern.net/doc/politics/2007-thiel.pdf</a>, 203.</li>
<li><a href="https://www.cato-unbound.org/2009/04/13/peter-thiel/education-libertarian/">https://www.cato-unbound.org/2009/04/13/peter-thiel/education-libertarian/</a></li>
<li><a href="https://poddtoppen.se/podcast/1527549379/thiel-talks/peter-thiel-at-libertopia-2010">https://poddtoppen.se/podcast/1527549379/thiel-talks/peter-thiel-at-libertopia-2010</a></li>
<li><a href="https://www.wired.com/2001/09/paypal/">https://www.wired.com/2001/09/paypal/</a></li>
<li>https://www.wired.com/2008/05/peter-thiel-makes-down-payment-on-libertarian-ocean-colonies/</li>
</ol>
</div>
</div>
<div class="author-byline">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>
</div>
