eEFJIFVsdGltZSBOb3RpemllOiBMYSB2YWx1dGF6aW9uZSBzdXBlcmEgaSAxMDAgbWlsaWFyZGkgZGkgZG9sbGFyaSwgR3JvayByaWFmZmVybWEgY2hlIG5vbiBsYW5jZXLDoCB1biB0b2tlbg==

2025-06-06, 08:26

<p><img src="https://gimg2.gateimg.com/image/xai202506061625005698996048.png" alt="">
</p><p>L’azienda di intelligenza artificiale di Musk, xAI, ha lanciato una vendita di azioni per dipendenti da 300 milioni di dollari con una valutazione di 113 miliardi di dollari, stabilendo un nuovo record di finanziamento per le startup di intelligenza artificiale. Tra questi, la valutazione core di xAI raggiunge gli 80 miliardi di dollari, mentre la piattaforma sociale X (ex Twitter) è valutata 33 miliardi di dollari, creando una sinergia di integrazione delle risorse.</p>
<p>Allo stesso tempo, la meme coin con lo stesso nome, XAICorp (XAI), ha visto il suo prezzo aumentare del 107% in 24 ore, con un volume di scambi giornaliero che ha raggiunto fino a 940 milioni di dollari. Musk ha risposto rapidamente: “È molto chiaro che nessuna delle mie aziende creerà token di criptovaluta.”</p>
<h2 id="h2-valutazione20di2010020miliardi20di20dollari20e20dinamiche20di20finanziamento867092"><a name="valutazione di 100 miliardi di dollari e dinamiche di finanziamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>valutazione di 100 miliardi di dollari e dinamiche di finanziamento</h2><p>La valutazione più recente di xAI ha raggiunto i 113 miliardi di dollari, avviando un finanziamento di 300 milioni di dollari attraverso la vendita di azioni, consentendo agli investitori di acquistare azioni dei dipendenti. Se un finanziamento di maggiore scala verrà completato successivamente, la valutazione potrebbe superare i 120 miliardi di dollari.</p>
<p>Questa scala di valutazione è seconda solo ai 300 miliardi di dollari di OpenAI, rendendola la seconda valutazione di un’impresa AI più grande al mondo. Il suo posizionamento strategico sta diventando sempre più chiaro: condivisione delle risorse di potenza di calcolo con la piattaforma X, concentrandosi su tre principali linee di business: xAI, X e Tesla.</p>
<p>Elon Musk prevede di unire xAI con la piattaforma sociale X e sta trattando con investitori per circa 20 miliardi di dollari di finanziamenti, che sarebbe il secondo round di finanziamento più grande per una startup nella storia.</p>
<h2 id="h2-Grok20Una20doppia20rivoluzione20di20umorismo20e20informazioni20in20tempo20reale895928"><a name="Grok: Una doppia rivoluzione di umorismo e informazioni in tempo reale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Grok: Una doppia rivoluzione di umorismo e informazioni in tempo reale</h2><p>xAI apre ufficialmente i test preliminari per il chatbot Grok, con Musk che afferma che il suo design principale è “essere più umoristico nelle risposte.”</p>
<p>Rispetto a concorrenti come ChatGPT, Grok ha un vantaggio unico: l’integrazione profonda di flussi di informazioni in tempo reale dalla piattaforma X. Quando gli utenti chiedono informazioni sull’andamento del processo dell’ex fondatore di FTX SBF, Grok descrive in tono di pettegolezzo l’istituzione delle sue accuse di frode e la possibile pena detentiva di 110 anni che potrebbe affrontare.</p>
<p>Dopo il completamento dei test, Grok sarà disponibile per tutti gli abbonati X Premium+, offrendo un’esperienza AI senza soluzione di continuità per gli utenti delle piattaforme social.</p>
<h2 id="h2-La20ferma20posizione20di20non20emettere20monete20e20il20suo20impatto20sul20mercato945483"><a name="La ferma posizione di non emettere monete e il suo impatto sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La ferma posizione di non emettere monete e il suo impatto sul mercato</h2><p>Di fronte alla crescita esplosiva della moneta Meme con un nome simile, Musk si è rapidamente distaccato sui social media. Questo continua la sua posizione coerente: nell’agosto 2024, ha dichiarato pubblicamente che la piattaforma X non lancerà mai una criptovaluta.</p>
<p>Nonostante le speculazioni nel mercato sull’uso della blockchain per emettere token, Musk preferisce costruire valore ecologico utilizzando metodi Web2. Questo atteggiamento non ha smorzato l’entusiasmo del capitale, e il piano tecnologico di xAI continua ad accelerare.</p>
<h2 id="h2-Layout20tecnico20e20sinergia20strategica664193"><a name="Layout tecnico e sinergia strategica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Layout tecnico e sinergia strategica</h2><p>Per supportare prodotti come Grok, xAI sta costruendo un grande centro dati AI paragonabile a OpenAI. Musk ha sottolineato che xAI è “il più forte in certi aspetti importanti dei tempi contemporanei”, accennando al suo vantaggio di differenziazione tecnologica.</p>
<p>La sua strategia fondamentale è quella di collegare dati, potenza di calcolo e cicli applicativi: la piattaforma X fornisce dati in tempo reale e scenari utente, Tesla contribuisce con hardware e requisiti di dominio verticale, mentre xAI si concentra sullo sviluppo di modelli.</p>
<h2 id="h2-Piano20di20mercato20del20nome20account20della20piattaforma20X834940"><a name="Piano di mercato del nome account della piattaforma X" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Piano di mercato del nome account della piattaforma X</h2><p>Come azione collaborativa ecologica, la piattaforma X prevede di rilasciare 1,5 miliardi di nomi account occupati da robot e stabilire un mercato commerciale a pagamento. Secondo le notizie, la piattaforma invierà email di offerta a potenziali acquirenti, con una soglia di acquisto di 50.000 dollari. Questo piano è stato avviato nel novembre 2022 e, entro maggio 2025, ha iniziato a disattivare gli account inattivi.</p>
<p>Contesto il completamento da parte di Musk di un finanziamento di 650 milioni di dollari per la sua azienda di interfaccia cervello-macchina Neuralink, xAI si posiziona come un componente chiave del futuro puzzle tecnologico. Mentre OpenAI stabilisce il soffitto del settore con una valutazione di 300 miliardi di dollari, xAI sta creando un nuovo campo di battaglia nella competizione tra giganti con una valutazione di centinaia di miliardi, dati in tempo reale e la fusione di intelligenza artificiale umoristica.</p>
<p>E quella dichiarazione di “nessuna emissione di monete” funge da chiaro confine, tagliando attraverso la nebbia dell’innovazione tecnologica e della speculazione cripto.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o proibire l’uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="1">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>