QWdlbnRpIEFJOiBJbCBudW92byBjYXRhbGl6emF0b3JlIHBlciBpbCBtZXJjYXRvIGNyaXB0byBBSQ==

2025-01-02, 07:50

<p><img src="https://gimg2.gateimg.com/image/article/173580439920241231-091957.jpg" alt=""></p>
<h2 id="h2-TLDR154285"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Guardando indietro al 2024, l’impennata dell’IA nel settore finanziario delle criptovalute ha suscitato un’attenzione senza precedenti.</p>
<p>All’inizio dell’anno, il settore dell’IA era composto solo da una manciata di progetti. Alla fine dell’anno, aveva subito una trasformazione drammatica, affermandosi come un percorso indipendente e impossibile da ignorare.</p>
<p>In particolare, durante la seconda metà del 2024, l’ascesa della narrazione dell’Agente AI ha spinto la storia della cripto AI a nuove vette.</p>
<h2 id="h2-Introduzione643531"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nella seconda metà del 2024, la popolarità degli Agenti di Intelligenza Artificiale ha continuato a salire. Tutto è cominciato con un chatbot chiamato “Terminal of Truths”, che ha attirato l’attenzione su larga scala sulla piattaforma X per le sue risposte umoristiche e spiritose. Ciò gli ha anche valso un finanziamento di $50,000 dal fondatore di a16z, Marc Andreessen. Ispirato dal suo contenuto, qualcuno ha creato il token GOAT, che è aumentato del 10,000% in sole 24 ore. Il prezzo del token alle stelle ha portato gli Agenti di Intelligenza Artificiale sotto i riflettori, attirando l’attenzione significativa degli investitori nel mercato finanziario cripto.</p>
<h2 id="h2-Cos20un20agente20AI996735"><a name="Cos’è un agente AI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un agente AI?</h2><p>In parole semplici, un AI Agent può essere compreso come un “assistente digitale intelligente”. Ad esempio, Siri di Apple è un tipo di AI Agent.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804445Siri-assistant-1024x510.jpg" alt=""></p>
<p>Tuttavia, a differenza degli assistenti digitali ordinari, gli agenti AI sono sistemi intelligenti basati su grandi modelli linguistici (LLM). Possono percepire il loro ambiente, ragionare e prendere decisioni, ed eseguire compiti complessi utilizzando strumenti o svolgendo azioni.</p>
<p>Il flusso di lavoro di un agente di intelligenza artificiale segue una sequenza logica: modulo di percezione (acquisizione dell’input) → modello di grandi dimensioni (comprensione, ragionamento e pianificazione) → invocazione dello strumento (esecuzione del compito) → feedback e ottimizzazione (convalida e regolazione). Innanzitutto, l’agente AI raccoglie i dati dall’ambiente esterno attraverso il modulo di percezione. Quindi, il modello di grandi dimensioni esegue il ragionamento logico per generare potenziali soluzioni o formulare piani d’azione. In questo caso, il modello di grandi dimensioni funge da “cervello” dell’agente di intelligenza artificiale, svolgendo un ruolo fondamentale nel processo decisionale. In base alle decisioni prese dal modello di grandi dimensioni, l’agente di intelligenza artificiale richiama strumenti esterni, plug-in o API per completare attività specifiche. Infine, convalida e regola i risultati in base al feedback, formando un processo di ottimizzazione a circuito chiuso.</p>
<p>Quindi, in cosa differisce un agente AI dagli assistenti digitali ordinari in modo specifico <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Scenari di applicazione? In parole semplici, gli AI Agent sono più intelligenti. Prendiamo ad esempio i bot di trading quantitativo. I bot di trading ordinari eseguono programmi di arbitraggio rigorosamente secondo istruzioni preimpostate, anche se le condizioni esterne cambiano. Ad esempio, se un utente imposta una strategia per eseguire negoziazioni solo quando i profitti superano l’1%, il bot seguirà questa regola anche in caso di volatilità del mercato. Gli AI Agent, invece, sono diversi. Mentre possono anche eseguire negoziazioni secondo istruzioni preimpostate in scenari di routine, possono regolare automaticamente le strategie in base alle fluttuazioni di mercato quando cambiano le condizioni.</p>
<p>Quindi, il vantaggio principale degli Agenti AI risiede nella loro capacità di auto-apprendere e di prendere decisioni autonome. Comprendendo il loro ambiente, gli Agenti AI possono continuamente ottimizzare i loro processi decisionali e migliorare l’efficienza nell’esecuzione delle attività. Possono anche rispondere in modo flessibile ai cambiamenti dell’ambiente esterno.</p>
<p>Dal punto di vista dello sviluppo del settore, il mercato ha generalmente due aspettative per gli agenti di intelligenza artificiale. Uno è che gli agenti di intelligenza artificiale agiscano come entità indipendenti con le proprie identità e marchi, capaci di fornire autonomamente servizi agli utenti. L’altro è che gli utenti abbiano agenti di intelligenza artificiale personali, simili agli assistenti personali, per aiutare a gestire le attività. Nella pratica, la maggior parte delle attuali esplorazioni di mercato si concentrano sulla prima direzione.</p>
<h2 id="h2-Debutto20al20picco20GOAT20Token20accende20il20settore20degli20agenti20AI833311"><a name="Debutto al picco: GOAT Token accende il settore degli agenti AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Debutto al picco: GOAT Token accende il settore degli agenti AI</h2><p>Come accennato in precedenza, l’emergere del token GOAT, derivato dal chatbot ‘Terminal of Truths’, ha segnato l’inizio di questo ciclo dell’Agente di AI. Nel ottobre 2024, il token GOAT è aumentato del 10.000% entro 24 ore dal suo lancio, scatenando una frenesia di speculazioni sui token Meme dell’Agente di AI e portando all’emissione in massa di quasi cento token Meme dell’Agente di AI.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804468X.PNG.png" alt=""><br>Con l’aumento del momentum del settore degli AI Agent, si è gradualmente evoluto in una nicchia indipendente all’interno del campo dell’AI criptato. In pochi mesi, la popolarità della discussione sui social media e le opportunità di guadagno sulla catena all’interno del settore degli AI Agent hanno già superato di gran lunga la precedente ondata di token Meme a tema animale. Al momento della pubblicazione da parte di Gate.io, i dati di Coingecko mostrano che la capitalizzazione di mercato totale dei token correlati a AI Agent ha raggiunto 16,9 miliardi di dollari, rappresentando oltre il 30% della capitalizzazione di mercato totale (48 miliardi di dollari) di tutti i progetti nel settore dell’AI criptato. L’entusiasmo che lo circonda continua a crescere.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804485C.PNG.png" alt=""></p>
<p>Ripensando alle tendenze di mercato, l’ascesa degli agenti AI può essere divisa in due fasi:</p>
<p>Fase 1: La fase dei meme guidata da GOAT</p>
<p>GOAT stesso era un token Meme generato da una conversazione tra due agenti AI. Questa è stata la prima volta che l’IA ha dimostrato un comportamento simile a quello umano per raggiungere i suoi obiettivi, rendendolo altamente sperimentale e, all’epoca, considerato avanti rispetto al suo tempo. La narrativa apparentemente senza senso dei token Meme ha fornito terreno fertile per il suo sviluppo. Man mano che GOAT guadagnava slancio, iniziavano a emergere token simili. Tuttavia, la maggior parte di questi token erano limitati a funzionalità come il tweet automatico e la risposta, mancando di applicazioni pratiche. In questa fase, i token degli agenti AI venivano generalmente definiti come token AI + Meme.</p>
<p>Nonostante la natura apparentemente superficiale della tendenza AI Agent Meme, essa non solo ha innescato una nuova ondata di speculazioni nel settore AI crypto ma ha anche spostato l’attenzione del mercato. L’attenzione ha cominciato a distogliersi dai dati decentralizzati tradizionali, dalle GPU e da altre infrastrutture AI crypto verso le applicazioni AI Agent, preparando il terreno per la seconda fase di sviluppo.</p>
<p>Fase 2: Fase di Esplorazione dell’Applicazione</p>
<p>Durante la prima fase, con la proliferazione dei progetti, il mercato ha gradualmente capito che gli Agenti di Intelligenza Artificiale potevano andare oltre le semplici interazioni sui social media per creare un valore tangibile in settori come la produzione di contenuti e l’analisi degli investimenti. Di conseguenza, gli Agenti di Intelligenza Artificiale hanno iniziato a distaccarsi dalle loro origini meme, formando un settore completamente nuovo che continua a guadagnare consenso.</p>
<h2 id="h2-Qual2020il20prossimo20passo20per20il20settore20dellIA20nel202025886158"><a name="Qual è il prossimo passo per il settore dell’IA nel 2025?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il prossimo passo per il settore dell’IA nel 2025?</h2><p>All’inizio del 2025, diverse istituzioni hanno condiviso le loro prospettive sulle tendenze del settore per l’anno. Organizzazioni come a16z, VanEck, Bitwise, Hashed, Blockworks, Messari e Framework hanno tutte espresso <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a> sullo sviluppo dei mercati delle criptovalute e dell’intelligenza artificiale, evidenziando in particolare il potenziale di crescita esplosiva dei prodotti correlati agli agenti di intelligenza artificiale nel 2025.</p>
<p>Tuttavia, alcuni analisti hanno sottolineato che, sebbene la tendenza degli Agenti AI possa persistere per un po’, è probabile che alla fine svanisca. Il socio gestore di Dragonfly ha affermato che la mania degli Agenti AI dovrebbe durare fino al 2025 ma diminuirà gradualmente. Secondo Dragonfly, gli Agenti AI non sono vere entità intelligenti, ma piuttosto chatbot con token Meme allegati. Oltre a pubblicare su Twitter, le loro capacità autonome sono piuttosto limitate. Questo non rappresenta una perturbazione a lungo termine portata dall’AI, ma piuttosto un fenomeno guidato dal loro appeal sociale, che ha catturato l’attenzione della comunità crypto.</p>
<p>Dal più ampio punto di vista dell’industria dell’IA, tuttavia, ci sono effettivamente una serie di eventi che supportano la crescita degli Agenti di intelligenza artificiale. Ad esempio, OpenAI sta attraversando una transizione da GPT a un Agente di intelligenza artificiale generale. Secondo quanto riferito, OpenAI prevede di lanciare un nuovo prodotto AI Agent chiamato “Operator” nel gennaio 2025. Questo prodotto può eseguire automaticamente compiti complessi come la codifica, la prenotazione di viaggi e lo shopping di e-commerce. Alcuni analisti ritengono che il lancio di Operator potrebbe essere rivoluzionario come Sora, potenzialmente riaccendendo il mercato dell’IA. Inoltre, il Summit annuale sull’IA di NVIDIA nel marzo 2025 è un altro punto focale per le industrie della crittografia e dell’IA, con il potenziale per attirare flussi di capitale e accendere ulteriormente il settore dell’IA crittografica.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804507107248194-1685471658101-sacks_jpg_92.jpg" alt=""></p>
<p>Sul fronte delle politiche, ci sono anche buone notizie. A gennaio, il <a href="/price/neo-neo" target="_blank" class="blog_inner_link">neo</a> eletto Presidente degli Stati Uniti, Donald Trump, assumerà ufficialmente l’incarico. Ha annunciato la nomina dell’ex dirigente di PayPal David O. Sacks come direttore degli affari di intelligenza artificiale e criptovaluta della Casa Bianca, incaricato di guidare le politiche governative in questi settori. David Sacks porta con sé un’esperienza di investimento duale nelle industrie della criptovaluta e dell’IA, avendo investito in aziende come Multicoin e diverse società di intelligenza artificiale. Il mercato si aspetta che le sue politiche promuovano l’integrazione tra criptovaluta e intelligenza artificiale.</p>
<p>In sintesi, la crescita degli agenti AI nel 2024 ha iniettato nuova vitalità nel settore AI crypto. Dalla popolarità esplosiva dei token Meme all’istituzione degli agenti AI come un sotto-settore indipendente, i loro vantaggi tecnici e il potenziale di applicazione sono gradualmente diventati evidenti. Questo non solo ha spostato la narrazione all’interno del mercato AI crypto, ma ha anche creato nuove opportunità di investimento.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Orisi</strong>, Ricercatore di Gate.io<br><div>Traduttore: Orisi<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>