TCdhbmFsaXN0YSBhZmZlcm1hIGNoZSBpIHRva2VuIEFJIHNvbm8gcGnDuSBoeXBlIGNoZSB2YWxvcmUsIG5vbm9zdGFudGUgZ2xpIHNjYW1iaSByZWRkaXRpemk=

2024-03-20, 03:03

<p><img src="https://gimg2.gateimg.com/image/article/1710903424sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR797740"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Un rapporto di ricerca di Coinbase ha concluso che le attuali prestazioni dei token crittografici AI sono guidate più dalla pubblicità che dall’utilità.</p>
<p>Le sfide più grandi che i progetti di token crittografici AI stanno affrontando includono la concorrenza da parte delle piattaforme centralizzate e le preoccupazioni regolamentari.</p>
<p>Render (RNDR), Bittensor (TAO), <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>(FET), SingularityNet (AGIX), Akash Network (AKT) e AIOZ Network (AIOZ) sono i principali token cripto AI.</p>
<p><strong>Parole chiave</strong>: Token crittografici AI, AI generativa nella criptovaluta, hype AI nella blockchain, analisi del mercato dei token AI, migliori progetti crittografici AI, tecnologia AI nella criptovaluta, criptovaluta guidata dall’AI, il futuro dell’AI nella criptovaluta, integrazione di AI e blockchain, valore dei token AI crittografici, previsioni di prezzo dei token AI, AI nella crittografia, hype AI vs valore nella crittografia, migliori progetti blockchain AI, sostenibilità dell’ecosistema crittografico AI</p>
<h2 id="h2-Introduzione666207"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’incrocio <a href="https://www.gate.io/learn/articles/understanding-the-intersection-of-crypto-and-ai/1853" target="_blank">tra criptovaluta e intelligenza artificiale (IA)</a> sembra trasformativo. Con l’emergere delle organizzazioni autonome decentralizzate (DAO), molti progetti di intelligenza artificiale hanno scelto di utilizzare la tecnologia blockchain per offrire i propri servizi. Nel processo, la maggior parte di loro ha sviluppato i propri token di intelligenza artificiale.</p>
<p>Da inizio anno alcuni di questi token di intelligenza artificiale hanno avuto una performance notevole. In questo post, valutiamo la sostenibilità dei token di intelligenza artificiale e l’incremento della loro popolarità nel 2023. Inoltre, esploreremo le sfide che affrontano i progetti di intelligenza artificiale che hanno adottato il modello decentralizzato. Infine, daremo uno sguardo ai token di intelligenza artificiale più promettenti nel 2024.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3894/ai-tokens-continue-to-rise-is-the-ai-web3-craze-hitting" target="_blank">I token di intelligenza artificiale continuano a salire, sta colpendo la frenesia AI+Web3?</a></p>
<h3 id="h3-LIA20generativa20potenzia20il20sottoecosistema20criptato20di20nicchia20unimpennata20di20popolarit20negli20ultimi20anni951375"><a name="L’IA generativa potenzia il sotto-ecosistema criptato di nicchia: un’impennata di popolarità negli ultimi anni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’IA generativa potenzia il sotto-ecosistema criptato di nicchia: un’impennata di popolarità negli ultimi anni</h3><p>I token di intelligenza artificiale (IA) sono stati in tendenza dal 2023 poiché molte persone credono che offrano utilità che vanno oltre i loro ecosistemi. Il fatto interessante è che alcuni di questi token crittografici AI hanno ottenuto risultati migliori rispetto alle principali criptovalute come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> così come le principali azioni come Nvidia e Microsoft.</p>
<p>Durante i primi due mesi e mezzo del 2024, i prezzi dei token cripto AI sono aumentati portando il valore di mercato totale a $24,3 miliardi. Ad esempio, entro la fine di febbraio, Akash e Render, che sono criptovalute basate sull’IA, hanno guadagnato rispettivamente il 146% e il 99%, superando <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> il cui valore è aumentato solo del 54% nello stesso periodo.</p>
<p>Nonostante una così eccezionale performance dei prezzi nel 2024 <a href="https://coinbase.bynder.com/m/1bc34d14d28d8d4/original/MktIntel_2024-03-06_Ai.pdf" rel="nofollow noopener noreferrer" target="_blank">un rapporto di ricerca da Coinbase</a> Gate.io, uno dei principali scambi di criptovalute, sottolinea che l’attuale aumento dei prezzi dei token AI è stato il risultato dell’euforia per l’AI nelle criptovalute anziché dell’effettiva utilità.</p>
<p>Coinbase ha messo in dubbio l’affermazione che la tecnologia AI sia di natura disruptiva e abbia molto da offrire nell’ecosistema crittografico. Il rapporto afferma che la sostenibilità dell’ecosistema crittografico AI richiede più innovazioni che beneficino l’economia più ampia rispetto alla semplice decentralizzazione dei componenti AI.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/the-promise-and-challenges-of-crypto-ai-applications/1781" target="_blank">Le promesse e le sfide delle applicazioni cripto + AI</a></p>
<p>Secondo <a href="https://coinbase.bynder.com/m/1bc34d14d28d8d4/original/MktIntel_2024-03-06_Ai.pdf" rel="nofollow noopener noreferrer" target="_blank">David Han, un analista di ricerca di Coinbase</a>, alcune modifiche che si stanno verificando nel settore dell’IA generativa portano le persone a interrogarsi sulla sostenibilità a lungo termine della tecnologia dell’IA nelle criptovalute.</p>
<p>Anche se <a href="https://www.gate.io/learn/articles/intersection-of-crypto-and-ai/1286" target="_blank">L’integrazione di intelligenza artificiale e blockchain promette molto sulla carta</a> non ci sono stati molti benefici tangibili. Alcuni dei migliori progetti cripto AI come Akash stanno replicando modelli di prodotto di aziende centralizzate come Amazon sfruttando la potenza di calcolo dei propri utenti per scopi di cloud computing.</p>
<p>Una tale replicazione dei servizi crea molta concorrenza con le imprese centralizzate tradizionali che operano in vari settori. È proprio questa forte concorrenza e gli ostacoli tecnici, nonché le sfide regolatorie, che possono <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Renderizzare</a> la maggior parte di questi migliori progetti blockchain AI non sono fattibili.</p>
<p>Se l’esagerazione sull’IA nelle criptovalute svanisce a causa della mancanza di utilità dei token, diventerà molto difficile per gli investitori apprezzare l’IA nelle criptovalute e immaginare il contributo che i migliori progetti blockchain di IA offriranno in futuro.</p>
<p>Riguardo a ciò, Han, nel rapporto di Coinbase, afferma: “Crediamo che alcune delle tendenze emergenti nel settore dell’IA potrebbero effettivamente rendere più difficile per le innovazioni basate su criptovalute ottenere l’adozione alla luce della concorrenza e delle normative di mercato più ampie.”</p>
<p>Inoltre, Han ha detto che il fatto che alcuni <a href="https://www.gate.io/blog_detail/2239/warum-ubertreffen-ki-fokussierte-kryptowahrungen-den-bitcoin" target="_blank">I token crittografici dell’IA superano Bitcoin in alcune fasi</a> non significa che hanno utilità. È una questione di intelligenza artificiale vs. hype nel crypto che può essere risolta solo attraverso i benefici o i non benefici dei migliori progetti di intelligenza artificiale crypto.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3804/crypto-ai-electricity-consumption-surge" target="_blank">Criptovalute e Intelligenza Artificiale spingeranno un’enorme crescita del consumo di energia elettrica</a></p>
<p>In relazione a questo Han ha chiarito: “Abbiamo riscontrato che le performance dei token crittografici legati all’IA sono supportate dai titoli di mercato dell’IA e possono sostenere movimenti di prezzo positivi anche nei giorni in cui il bitcoin scambia al ribasso. Pertanto, riteniamo che molti token legati all’IA potrebbero continuare a essere scambiati come un proxy più generale per il progresso dell’IA.”</p>
<p>Nello stesso rapporto Han afferma che i token crittografici AI hanno ottenuto ottimi risultati grazie alla natura ribassista delle criptovalute in generale. Questo perché durante lo stesso periodo anche le memecoin che si basano sull’hype e sul supporto della comunità hanno registrato un rally. Il punto di Han è che il mercato ha gonfiato i valori percepiti delle criptovalute AI.</p>
<p>L’attenzione che il mercato sta dando all’IA generativa nella crittografia emana dalla percezione dell’industria del potenziale dell’AI. Ad esempio, molte persone credono che l’IA farà molte cose come generare video , saggi e proposte di progetti in modo più efficiente degli esseri umani. Anche se queste narrazioni sembrano convincenti, il mondo sta ancora aspettando di dimostrare il vero potenziale dell’industria dell’IA.</p>
<h3 id="h3-Tendenze20chiave20nellAI20Crypto361527"><a name="Tendenze chiave nell’AI Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze chiave nell’AI Crypto</h3><p>Ci sono alcune tendenze chiave nel settore dell’IA nel settore delle criptovalute. Una delle principali tendenze nel settore dell’IA è l’adozione di modelli open-source e l’integrazione con piattaforme esistenti per migliorare l’efficienza e aumentare l’efficacia dei costi.</p>
<p>I progetti di intelligenza artificiale nel settore delle criptovalute stanno adottando hardware più avanzato rispetto al passato, il che migliorerà ulteriormente le loro capacità. I progetti stanno inoltre passando dalla fase di addestramento del modello all’inferenza, il che favorisce le loro capacità.</p>
<p>Anche se Coinbase ritiene che l’IA abbia pochi casi d’uso nel settore delle criptovalute <a href="https://twitter.com/VitalikButerin/status/1759369749887332577?lang=en" rel="nofollow noopener noreferrer" target="_blank">Vitalik Buterin, il co-fondatore di Ethereum la pensa diversamente</a>. Ma Buterin afferma che l’IA nel settore delle criptovalute può aiutare a correggere i bug presenti nei protocolli dei contratti intelligenti.<br><img src="https://gimg2.gateimg.com/image/article/17109037084.jpeg" alt=""><br>Source: <a href="https://twitter.com/VitalikButerin/status/1759369749887332577?lang=en" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Inoltre, Buterin ha sottolineato che le verifiche guidate dall’IA possono correggere codici problematici con smart contract come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> In fin dei conti, ciò riduce i rischi derivanti dalle vulnerabilità che possono presentare i protocolli blockchain.</p>
<p>Ancora più interessante, Coinbase ha identificato ciò che l’industria dell’IA deve fare per liberare il potenziale dell’intelligenza artificiale e dell’apprendimento automatico nel settore delle criptovalute. Ad esempio, l’IA nel settore delle criptovalute può utilizzare l’intelligenza artificiale per migliorare l’accessibilità dei dati della blockchain. Altri casi d’uso dell’intelligenza artificiale nel settore includono <a href="https://www.gate.io/price/view/artificial-intelligence" target="_blank">Analisi di mercato dei token AI</a> e previsioni sui prezzi dei token AI.</p>
<h3 id="h3-Sfide20con20i20progetti20di20Crypto20AI559904"><a name="Sfide con i progetti di Crypto AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide con i progetti di Crypto AI</h3><p>Come nel caso di altre piattaforme blockchain, i progetti di cripto AI affrontano anche sfide. La sfida più grande riguarda le loro tecnologie. Nonostante i progetti di cripto AI mirino a implementare una piena decentralizzazione, le loro infrastrutture attuali dipendono molto da fonti di dati e componenti centralizzati.</p>
<p>Riguardo a ciò Han ha detto: “Un futuro di intelligenza artificiale decentralizzata, come attualmente immaginato da molti nell’industria delle criptovalute, non è garantito - infatti, il futuro dell’industria dell’IA stessa è ancora in gran parte indeterminato.”</p>
<p>Ha aggiunto: “Pertanto riteniamo opportuno navigare con attenzione in un mercato del genere e esaminare più a fondo come le soluzioni basate su criptovalute possano realmente offrire un’alternativa significativamente migliore, o quantomeno comprendere la narrativa di trading sottostante.” Nonostante queste sfide, il futuro dell’IA nelle criptovalute è ancora luminoso.</p>
<h3 id="h3-Capitalizzazione20di20mercato20dellIA20e20i20token20AI20pi20promettenti20in20questo20momento20AGIX67204"><a name="Capitalizzazione di mercato dell’IA e i token AI più promettenti in questo momento (AGIX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Capitalizzazione di mercato dell’IA e i token AI più promettenti in questo momento (AGIX</h3><p>Secondo <a href="https://www.coingecko.com/en/categories/artificial-intelligence" rel="nofollow noopener noreferrer" target="_blank">Analisi del mercato dei token AI di CoinGecko</a> le criptovalute legate all’intelligenza artificiale hanno una capitalizzazione di mercato totale di $24.3 miliardi dopo aver perso l’1.2% nelle ultime 24 ore.</p>
<p>In particolare, ci sono molti token AI promettenti che includono <a href="/price/render-rndr" target="_blank" class="blog_inner_link">Render</a> (RNDR), Bittensor (TAO), <a href="/price/fetch-ai-fet" target="_blank" class="blog_inner_link">Fetch.ai</a> (FET), SingularityNet (AGIX), Akash Network (AKT) e AIOZ Network (AIOZ). Ad esempio, RNDR e TAO hanno capitalizzazioni di mercato di $4,454,327,079 e $4,096,150,973 rispettivamente. Le capitalizzazioni di mercato degli altri principali token AI sono mostrate nella prossima immagine.<br><img src="https://gimg2.gateimg.com/image/article/17109037775.jpeg" alt=""><br>Source: <a href="https://www.coingecko.com/en/categories/artificial-intelligence" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Il token AI <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">previsione del prezzo</a> indica una prospettiva rialzista. Nonostante il fatto che i token crittografici AI siano in rosso, è probabile che i loro prezzi aumentino quando la maggior parte delle principali criptovalute come ETH e bitcoin sono in trend al rialzo.</p>
<h2 id="h2-Conclusione488097"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Un recente rapporto di Coinbase ha evidenziato che il principale motore dietro il rally dei token crittografici AI è l’entusiasmo per l’IA nella blockchain piuttosto che l’utilità. Il futuro dei token crittografici AI dipenderà probabilmente dall’innovazione corretta e dall’integrazione con piattaforme centralizzate. Attualmente, il valore di mercato totale dei token crittografici AI ammonta a 24,3 miliardi di dollari.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il riposting dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>