TnVvdm8gYW5ubywgbnVvdmEgdHJhY2NpYSAtIFF1YWxpIG9wcG9ydHVuaXTDoCBwdcOyIHBvcnRhcmUgRGVGQUk/

<h2 id="h2-TLDR354065"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il mercato ha recentemente subito ripetute fluttuazioni, con un sentimento complessivo nel settore degli agenti AI che rimane contenuto.</p>
<p>Tuttavia, in questo contesto, il concetto di DeFAI è emerso controcorrente, diventando un nuovo punto caldo di mercato e portando opportunità senza precedenti per gli investitori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/173693238520250105-191233.jpeg" alt=""></p>
<h2 id="h2-Introduzione488779"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>DeFi è sempre stato un importante gateway per attirare utenti mainstream verso la blockchain, ma la sua complessa esperienza operativa è stata un ostacolo importante all’adozione di massa. È emersa una nuova narrazione - DeFAI (Finanza Decentralizzata + Intelligenza Artificiale) - offrendo speranza di superare questi ostacoli. Seguendo l’entusiasmo intorno ai framework di intelligenza artificiale, DeFAI sta silenziosamente diventando una delle tendenze più calde nel settore dell’agente AI cripto. Allora, cos’è esattamente DeFAI? Come plasmerà lo spazio DeFi? E dove potrebbe portare in futuro?</p>
<h2 id="h2-Cos20DeFAI457523"><a name="Cos’è DeFAI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è DeFAI?</h2><p>In termini semplici, DeFAI è DeFi potenziato con capacità di intelligenza artificiale. L’introduzione di agenti di intelligenza artificiale migliora significativamente l’esperienza dell’utente sostituendo gli utenti nell’esecuzione di complesse operazioni on-chain.</p>
<p>Prendiamo un’operazione DeFi tipica come esempio: se si desidera scambiare 0,1 ETH per SOL, il metodo tradizionale prevede i seguenti passaggi:</p>
<ol>
<li><p>Trova un protocollo di trasferimento per trasferire gli asset cross-chain a <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>;</p>
</li><li><p>Trova uno scambio decentralizzato (DEX) su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>;</p>
</li><li><p>Infine, esegui lo swap.</p>
</li></ol>
<p>Questo processo è complesso, lungo e richiede molto tempo, spesso scoraggiando i principianti e ostacolando l’adozione della blockchain. L’emergere di DeFAI offre speranza per il cambiamento, semplificando potenzialmente tutto.</p>
<p>Con DeFAI, eseguire la stessa operazione - scambiare 0,1 ETH per SOL - richiederebbe solo all’utente di inserire il comando di scambio. L’IA si occupa del resto delle noiose fasi. Non è più necessario spendere una quantità significativa di tempo per imparare come utilizzare l’infrastruttura DeFi come portafogli, DEX o scambi.</p>
<p>Immagina un futuro in cui l’interfaccia di DeFAI assomiglia a ChatGPT. Gli utenti potrebbero non solo interagire con l’IA ma anche eseguire operazioni on-chain. DeFAI potrebbe migliorare l’efficienza e la sicurezza dei progetti DeFi sfruttando le potenti capacità di calcolo e analisi dei dati dell’IA. Allo stesso tempo, l’industria DeFi potrebbe evolversi in un ecosistema finanziario più user-friendly, intelligente ed efficiente.</p>
<h2 id="h2-Quali20possibilit20imaginative20porta20DeFAI439536"><a name="Quali possibilità imaginative porta DeFAI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali possibilità imaginative porta DeFAI?</h2><p>Secondo i dati di CoinGecko, durante le recenti fluttuazioni di mercato, la capitalizzazione di mercato di DeFAI continua a crescere, quasi formando una tendenza indipendente. La sua capitalizzazione di mercato ha ora superato i 2,7 miliardi di dollari, mostrando un immenso potenziale di mercato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17369324040840574a-b488-47a8-9e86-dbd8b36289f7.png" alt=""><br>Tuttavia, dal punto di vista delle operazioni effettive del progetto, DeFAI è ancora nella fase di prova concettuale. Le sue principali aree di esplorazione possono essere riassunte in quattro categorie:</p>
<h3 id="h3-Astrazione20AI273683"><a name="Astrazione AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Astrazione AI</h3><p>L’astrazione AI si riferisce all’incorporamento delle capacità di elaborazione delle informazioni di grandi modelli AI nei prodotti DeFi, consentendo agli utenti di eseguire operazioni con facilità.</p>
<p>Tali prodotti affrontano spesso critiche in questa fase a causa di esperienze di interazione incomplete. Ad esempio, potrebbero esserci discrepanze tra comandi vaghi inseriti dagli utenti e l’esecuzione precisa da parte del backend AI, portando a una scarsa esperienza utente. Tuttavia, con l’ottimizzazione continua e il perfezionamento dell’AI, questi prodotti dimostrano anche un potenziale a lungo termine.</p>
<p>Attraverso nuovi modelli di interazione, questi prodotti potrebbero alla fine soddisfare le esigenze di transazione di base e persino promuovere la formazione di nuovi paradigmi di trading.</p>
<h3 id="h3-Gestione20autonoma20del20portafoglio20e20ottimizzazione20del20rendimento488483"><a name="Gestione autonoma del portafoglio e ottimizzazione del rendimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gestione autonoma del portafoglio e ottimizzazione del rendimento</h3><p>La gestione autonoma del portafoglio e l’ottimizzazione del rendimento sono essenzialmente prodotti della precedente competizione sul mercato DeFi. In poche parole, coinvolgono il monitoraggio e l’analisi in tempo reale dei dati on-chain per sviluppare ed eseguire strategie di ottimizzazione del rendimento.</p>
<p>Il nucleo di tali prodotti risiede nell’unire i dati on-chain in tempo reale con la capacità di catturare opportunità di trading, fornendo una soluzione di ottimizzazione della strategia completa che include l’allocazione dei fondi, l’esecuzione dell’arbitraggio, la previsione del rendimento e il controllo del rischio.</p>
<p>Integrando la tecnologia AI, l’efficienza di questi prodotti viene ulteriormente migliorata. Ad esempio, gli agenti AI possono ottimizzare strategie personalizzate, consentendo agli utenti di avere un assistente commerciale avanzato dedicato che identifica automaticamente le opportunità di investimento on-chain ed esegue transazioni. Questa combinazione non solo continua la logica operativa raffinata di DeFi ma offre agli utenti un’esperienza di investimento più efficiente e personalizzata.</p>
<h3 id="h3-Analisi20di20mercato20o20previsione212308"><a name="Analisi di mercato o previsione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi di mercato o previsione</h3><p>Questi prodotti utilizzano l’IA per fornire analisi delle strategie di trading e previsioni delle tendenze di mercato, che sono già diventate una fonte importante di informazioni per molti trader.</p>
<p>Se tali prodotti possono sostenere la loro crescita nel lungo termine dipende dal fatto che gli agenti AI possano gestire autonomamente gli asset degli utenti ed eseguire automaticamente operazioni di trading basate su informazioni e decisioni in tempo reale. Anche se questo passaggio non è ancora stato completamente realizzato, il potenziale per la monetizzazione guidata dal traffico e commerciale ha già mostrato un significativo promessa.</p>
<h3 id="h3-Infrastruttura20o20piattaforma20DeFAI632269"><a name="Infrastruttura o piattaforma DeFAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Infrastruttura o piattaforma DeFAI</h3><p>Questa categoria di progetti fornisce un supporto fondamentale per l’integrazione di AI e DeFi, comprendendo aspetti come la potenza di calcolo, i dati e il raffinamento.</p>
<p>Il campo di questi protocolli è ampio, compresi piattaforme native AI Agent come #ai16z e #Virtual, così come progetti come Bittensor, Atheir e Vana, che sono legati alla potenza computazionale e ai dati AI.</p>
<p>Queste infrastrutture non solo supportano lo sviluppo e il funzionamento delle applicazioni AI, ma stimolano anche l’innovazione e la crescita nell’ecosistema AI+DeFi. Come supporto fondamentale, sono fondamentali per implementare ed espandere altre applicazioni AI+DeFi, introducendo ulteriori possibilità nell’industria.</p>
<h2 id="h2-Dove20si20sta20dirigendo20DeFAI656859"><a name="Dove si sta dirigendo DeFAI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove si sta dirigendo DeFAI?</h2><p>Gli analisti del settore ritengono in genere che lo sviluppo futuro di DeFAI procederà attraverso quattro fasi:</p>
<h3 id="h3-Fase20120Concentrarsi20sullefficienza813025"><a name="Fase 1: Concentrarsi sull’efficienza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 1: Concentrarsi sull’efficienza</h3><p>La prima fase di DeFi AI si concentrerà sull’efficienza, migliorando l’esperienza dell’utente attraverso strumenti innovativi che consentono agli utenti di completare facilmente operazioni complesse DeFi senza richiedere una conoscenza approfondita dei protocolli.</p>
<p>Lo scopo di questa fase è che l’intelligenza artificiale debba possedere la capacità di comprendere le richieste dell’utente, identificare accuratamente le esigenze e rispondere anche quando il formato di input dell’utente è irregolare. In secondo luogo, dovrebbe essere in grado di completare efficientemente le operazioni di swap nel minor tempo di blocco per migliorare l’efficienza della transazione. Infine, l’analisi del mercato in tempo reale dovrebbe aiutare gli utenti a prendere decisioni ottimali in base ai loro obiettivi di investimento, consentendo una migliore partecipazione all’ecosistema DeFi.</p>
<p>Se queste innovazioni possono essere implementate con successo, ridurranno significativamente le barriere alle transazioni on-chain, risparmiando tempo e sforzo agli utenti. Questa fase potrebbe dare il via a un “momento fantasma” nei prossimi mesi, stimolando un rapido sviluppo nel settore.</p>
<h3 id="h3-Fase20220Trading20autonomo20con20agenti20intelligenti191420"><a name="Fase 2: Trading autonomo con agenti intelligenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 2: Trading autonomo con agenti intelligenti</h3><p>Una volta affrontate le sfide dell’efficienza, DeFi AI entrerà nella seconda fase: il trading autonomo con agenti intelligenti.</p>
<p>Gli agenti intelligenti eseguiranno strategie di trading durante questa fase con minima intervento umano. Regoleranno dinamicamente le decisioni in base a informazioni di terze parti o dati forniti da altri agenti intelligenti. Gli utenti DeFi professionisti o esperti possono ottimizzare i modelli per creare agenti personalizzati, massimizzando i rendimenti per sé stessi o per i propri clienti riducendo significativamente la dipendenza dal monitoraggio manuale.</p>
<h3 id="h3-Fase20320Trasparenza20e20Verifica833792"><a name="Fase 3: Trasparenza e Verifica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 3: Trasparenza e Verifica</h3><p>A seguito dello sviluppo delle prime due fasi, con l’aumento della domanda da parte degli utenti di trasparenza, la gestione del portafoglio e la verifica dell’IA diventeranno aree di focus principali.</p>
<p>Per soddisfare queste esigenze, saranno introdotte tecnologie come Trusted ution Environments (TEE) e Zero-Knowledge Proofs (ZKP) per garantire la sicurezza e la trasparenza dei sistemi AI. Queste tecnologie aumenteranno ulteriormente la fiducia degli utenti in DeFi AI.</p>
<h3 id="h3-Fase20420Strumenti20senza20codice20e20Economia20degli20Agenti156204"><a name="Fase 4: Strumenti senza codice e Economia degli Agenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 4: Strumenti senza codice e Economia degli Agenti</h3><p>Dopo aver completato le fasi precedenti, DeFi AI entrerà nella sua fase finale: la costruzione di un’economia basata su agenti intelligenti.</p>
<p>In questa fase, saranno possibili strumenti di ingegneria AI DeFi senza codice o protocolli AI-as-a-Service. Gli utenti senza competenze di programmazione possono creare e distribuire i propri agenti intelligenti, promuovendo ulteriormente l’adozione e lo sviluppo dell’ecosistema DeFi.</p>
<p>Attraverso questi strumenti, i modelli di intelligenza artificiale addestrati sui dati delle criptovalute possono essere utilizzati direttamente per il trading, formando un’economia guidata da agenti intelligenti. Questo potrebbe ampliare DeFi da un dominio per utenti professionali a una base di utenti più ampia, potenzialmente ridefinendo il panorama dei servizi finanziari.</p>
<p>Naturalmente, lo sviluppo di DeFAI affronta ancora molte sfide. La maggior parte degli strumenti esistenti sono semplicemente versioni riproposte di ChatGPT, prive di vera innovazione. Inoltre, non ci sono standard chiari per valutare la qualità degli strumenti o identificare progetti di alta qualità, rendendo difficile l’emergere di progetti eccezionali.</p>
<p>Inoltre, la frammentazione dei dati on-chain è un problema significativo. La natura decentralizzata e inconsistente dei dati rende i modelli di intelligenza artificiale più inclini alla centralizzazione piuttosto che alla decentralizzazione. Come costruire agenti davvero decentralizzati on-chain in un tale ambiente rimane una sfida fondamentale per l’industria da affrontare.</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 suggerimenti di investimento. Tutti gli investimenti comportano rischi intrinseci; una decisione prudente è essenziale.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>