TmlldXcgSmFhciwgTmlldXdlIEtvZXJz4oCU4oCUV2Vsa2UgS2Fuc2VuIEthbiBEZUZBSSBCcmVuZ2VuPw==

<h2 id="h2-TLDR146928"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De markt heeft onlangs herhaalde schommelingen meegemaakt, waarbij het algemene sentiment in de AI Agent sector gedempt blijft.</p>
<p>Echter, te midden van deze achtergrond is het concept van DeFAI tegen de stroom in opgekomen, waardoor het een nieuwe markt-hotspot is geworden en ongekende kansen heeft geboden voor investeerders.</p>
<p><img src="https://gimg2.gateimg.com/image/article/173693238520250105-191233.jpeg" alt=""></p>
<h2 id="h2-Inleiding495440"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>DeFi is altijd een belangrijke toegangspoort geweest voor blockchain om mainstream gebruikers aan te trekken, maar de complexe operationele ervaring is een grote hindernis geweest voor massale adoptie. Er is een nieuw verhaal ontstaan—DeFAI (Decentralized Finance + Artificial Intelligence)—wat hoop biedt om door deze knelpunten heen te breken. Naar aanleiding van de hype rond AI-frameworks, wordt DeFAI stilletjes een van de heetste tracks in de crypto AI Agent sector. Dus, wat is precies DeFAI? Hoe zal het de DeFi-ruimte hervormen? En waar zou het in de toekomst naartoe kunnen leiden?</p>
<h2 id="h2-Wat20is20DeFAI980854"><a name="Wat is DeFAI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is DeFAI?</h2><p>In eenvoudige bewoordingen is DeFAI DeFi verbeterd met AI-mogelijkheden. De introductie van AI-agenten verbetert de gebruikerservaring aanzienlijk door gebruikers te vervangen bij het uitvoeren van complexe on-chain operaties.</p>
<p>Neem een typische DeFi-operatie als voorbeeld: als je 0,1 ETH wilt omwisselen voor SOL, zijn de traditionele stappen als volgt:</p>
<ol>
<li><p>Zoek een brugprotocol om activa cross-chain over te dragen naar <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>;</p>
</li><li><p>Zoek een gedecentraliseerde exchange (DEX) op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>;</p>
</li><li><p>Tenslotte, voer de swap uit.</p>
</li></ol>
<p>Dit proces is complex, langdurig en tijdrovend, wat vaak beginners ontmoedigt en de adoptie van blockchain hindert. De opkomst van DeFAI biedt hoop op verandering, waarbij alles mogelijk wordt vereenvoudigd.</p>
<p>Met DeFAI zou dezelfde handeling – het omwisselen van 0,1 ETH voor SOL – alleen vereisen dat de gebruiker het omwisselingscommando invoert. De AI handelt de rest van de tijdrovende stappen af. Je hoeft niet langer een aanzienlijke hoeveelheid tijd te besteden aan het leren gebruiken van DeFi-infrastructuur zoals wallets, DEXs of swaps.</p>
<p>Stel je een toekomst voor waarin de interface van DeFAI lijkt op ChatGPT. Gebruikers kunnen niet alleen communiceren met AI, maar ook on-chain operaties uitvoeren. DeFAI zou de efficiëntie en veiligheid van DeFi-projecten kunnen verbeteren door gebruik te maken van de krachtige reken- en data-analysemogelijkheden van AI. Tegelijkertijd zou de DeFi-industrie kunnen evolueren naar een gebruiksvriendelijker, intelligenter en efficiënter financieel ecosysteem.</p>
<p>Welke verbeeldingsmogelijkheden brengt DeFAI met zich mee?<br>Volgens gegevens van CoinGecko is de marktkapitalisatie van DeFAI tijdens recente marktfluctuaties blijven stijgen, bijna als een onafhankelijke trend. De marktkapitalisatie is nu meer dan $2,7 miljard, wat een immense marktpotentie laat zien.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17369324040840574a-b488-47a8-9e86-dbd8b36289f7.png" alt=""><br>Echter, vanuit het perspectief van de feitelijke projectactiviteiten bevindt DeFAI zich nog steeds in de proof-of-concept fase. De belangrijkste gebieden van verkenning kunnen worden samengevat in vier categorieën:</p>
<h3 id="h3-AI20Abstractie958215"><a name="AI Abstractie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI Abstractie</h3><p>AI abstractie verwijst naar het inbedden van de informatie-verwerkingsmogelijkheden van grote AI-modellen in DeFi-producten, waardoor gebruikers gemakkelijk handelingen kunnen uitvoeren.</p>
<p>Dergelijke producten worden vaak bekritiseerd in deze fase vanwege onvolledige interactie-ervaringen. Zo kunnen er bijvoorbeeld verschillen zijn tussen vage opdrachten die door gebruikers worden ingevoerd en de nauwkeurige uitvoering door de AI-backend, wat leidt tot een slechte gebruikerservaring. Met voortdurende optimalisatie en verfijning van AI tonen deze producten ook op de lange termijn potentieel.</p>
<p>Met behulp van nieuwe interactiemodellen kunnen deze producten uiteindelijk aan basis transactiebehoeften voldoen en zelfs de vorming van nieuwe handelsparadigma’s bevorderen.</p>
<h3 id="h3-Autonoom20portefeuillebeheer20en20rendementsoptimalisatie238728"><a name="Autonoom portefeuillebeheer en rendementsoptimalisatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Autonoom portefeuillebeheer en rendementsoptimalisatie</h3><p>Autonoom portefeuillebeheer en rendementsoptimalisatie zijn in wezen producten van de vorige ronde van DeFi-marktcompetitie. Simpel gezegd, ze omvatten real-time monitoring en analyse van on-chain data om rendementsoptimalisatiestrategieën te ontwikkelen en uit te voeren.</p>
<p>De kern van dergelijke producten ligt in het combineren van real-time on-chain data met de mogelijkheid om handelsmogelijkheden vast te leggen, waardoor een uitgebreide strategie-optimalisatieoplossing wordt geboden die fondsallocatie, arbitrage-uitvoering, opbrengstprognoses en risicobeheer omvat.</p>
<p>Door het integreren van AI-technologie wordt de efficiëntie van deze producten verder verbeterd. Bijvoorbeeld, AI-agenten kunnen gepersonaliseerde strategieën finetunen, waardoor gebruikers een toegewijde geavanceerde handelsassistent hebben die automatisch on-chain investeringsmogelijkheden identificeert en transacties uitvoert. Deze combinatie behoudt niet alleen de verfijnde operationele logica van DeFi, maar biedt gebruikers ook een efficiëntere en gepersonaliseerde beleggingservaring.</p>
<h3 id="h3-Marktanalyse20of20voorspelling168804"><a name="Marktanalyse of -voorspelling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse of -voorspelling</h3><p>Deze producten gebruiken AI om handelsstrategie-analyse en markttrendvoorspellingen te bieden, die al een belangrijke bron van informatie zijn geworden voor veel handelaren.</p>
<p>Of dergelijke producten op lange termijn kunnen blijven groeien, hangt af van de vraag of AI-agents gebruikersactiva autonoom kunnen beheren en automatisch handelsactiviteiten kunnen uitvoeren op basis van realtime informatie en beslissingen. Hoewel deze stap nog niet volledig is gerealiseerd, heeft het potentieel voor verkeersgestuurde en commerciële monetisatie al veelbelovende resultaten laten zien.</p>
<h3 id="h3-DeFAIinfrastructuur20of20platform647644"><a name="DeFAI-infrastructuur of -platform" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFAI-infrastructuur of -platform</h3><p>Deze categorie van projecten biedt een fundamentele ondersteuning voor het integreren van AI en DeFi, met betrekking tot aspecten zoals rekenkracht, gegevens en het verfijnen ervan.</p>
<p>Het bereik van deze protocollen is breed, inclusief AI Agent-native platforms zoals #ai16z en #Virtual, evenals projecten zoals Bittensor, Atheir en Vana, die gerelateerd zijn aan AI-computatiekracht en data.</p>
<p>Deze infrastructuur ondersteunt niet alleen de ontwikkeling en werking van AI-toepassingen, maar stimuleert ook innovatie en groei in het AI+DeFi-ecosysteem. Als fundamentele ondersteuning zijn ze essentieel voor het implementeren en uitbreiden van andere AI+DeFi-toepassingen en bieden ze meer mogelijkheden voor de industrie.</p>
<h2 id="h2-Waar20gaat20DeFAI20naartoe106743"><a name="Waar gaat DeFAI naartoe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar gaat DeFAI naartoe?</h2><p>Industrieanalisten geloven over het algemeen dat de toekomstige ontwikkeling van DeFAI zal verlopen via vier fasen:</p>
<h3 id="h3-Fase20120Focus20op20Efficintie973300"><a name="Fase 1: Focus op Efficiëntie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 1: Focus op Efficiëntie</h3><p>De eerste fase van DeFi AI zal zich richten op efficiëntie, waarbij de gebruikerservaring wordt verbeterd door innovatieve tools die gebruikers in staat stellen om gemakkelijk complexe DeFi-operaties uit te voeren zonder diepgaande kennis van protocollen te vereisen.</p>
<p>De focus van deze fase ligt op de noodzaak voor kunstmatige intelligentie om in staat te zijn gebruikersinstructies te begrijpen, behoeften nauwkeurig te identificeren en te reageren, zelfs wanneer het invoerformaat van de gebruiker onregelmatig is. Ten tweede moet het in staat zijn om efficiënt swap-operaties uit te voeren binnen de kortste bloktijd om de transactie-efficiëntie te verbeteren. Ten slotte moet real-time marktanalyse gebruikers helpen bij het nemen van optimale beslissingen op basis van hun beleggingsdoelen, waardoor ze beter kunnen deelnemen aan het DeFi-ecosysteem.</p>
<p>Als deze innovaties succesvol kunnen worden geïmplementeerd, zullen ze de drempels voor on-chain transacties aanzienlijk verlagen, waardoor gebruikers tijd en moeite besparen. Deze fase kan een ‘spookmoment’ in gang zetten in de komende maanden, wat leidt tot snelle ontwikkeling in de industrie.</p>
<h3 id="h3-Fase20220Autonome20handel20met20intelligente20agenten256122"><a name="Fase 2: Autonome handel met intelligente agenten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 2: Autonome handel met intelligente agenten</h3><p>Nadat de efficiëntie-uitdagingen zijn aangepakt, zal DeFi AI de tweede fase ingaan - autonome handel met intelligente agenten.</p>
<p>Intelligente agenten zullen tijdens deze fase handelsstrategieën uitvoeren met minimale menselijke tussenkomst. Ze zullen dynamisch beslissingen aanpassen op basis van inzichten van derden of gegevens die worden verstrekt door andere intelligente agenten. Professionele of ervaren DeFi-gebruikers kunnen modellen verfijnen om gepersonaliseerde agenten te creëren, waardoor ze rendementen maximaliseren voor zichzelf of hun klanten terwijl ze aanzienlijk minder afhankelijk zijn van handmatige monitoring.</p>
<h3 id="h3-Fase20320Transparantie20en20Verificatie696961"><a name="Fase 3: Transparantie en Verificatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 3: Transparantie en Verificatie</h3><p>Na de ontwikkeling van de eerste twee fasen, zullen portefeuillebeheer en AI-verificatie de belangrijkste aandachtsgebieden worden naarmate de vraag naar transparantie van gebruikers toeneemt.</p>
<p>Om aan deze behoeften te voldoen, zullen technologieën zoals Trusted ution Environments (TEE) en Zero-Knowledge Proofs (ZKP) worden geïntroduceerd om de beveiliging en transparantie van AI-en te waarborgen. Deze technologieën zullen het vertrouwen van gebruikers in DeFi AI verder vergroten.</p>
<h3 id="h3-Fase20420NoCode20Tools20en20Agent20Economy147136"><a name="Fase 4: No-Code Tools en Agent Economy" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fase 4: No-Code Tools en Agent Economy</h3><p>Na het voltooien van de bovenstaande fasen, zal DeFi AI de laatste fase ingaan: het opbouwen van een economie gebaseerd op intelligente agents.</p>
<p>In deze fase zullen no-code DeFi AI-engineeringstoolkits of AI-as-a-Service-protocollen mogelijk worden. Gebruikers zonder programmeervaardigheden kunnen hun eigen intelligente agenten maken en implementeren, waardoor verdere adoptie en ontwikkeling van het DeFi-ecosysteem wordt gestimuleerd.</p>
<p>Met behulp van deze tools kunnen AI-modellen die zijn getraind op cryptocurrency-gegevens rechtstreeks worden gebruikt voor handel, waardoor een economie ontstaat die wordt aangedreven door intelligente agenten. Dit zou DeFi kunnen uitbreiden van een domein voor professionele gebruikers naar een breder gebruikersbestand, en mogelijk het landschap van financiële diensten hervormen.</p>
<p>Natuurlijk staat de ontwikkeling van DeFAI nog voor vele uitdagingen. De meeste bestaande tools zijn slechts gerecyclede versies van ChatGPT en missen echte innovatie. Bovendien zijn er geen duidelijke normen voor het ueren van de kwaliteit van tools of het identificeren van hoogwaardige projecten, waardoor het moeilijk is voor opvallende projecten om naar voren te komen.</p>
<p>Bovendien is de fragmentatie van on-chain data een belangrijk probleem. De gedecentraliseerde en inconsistente aard van data maakt AI-modellen eerder geneigd tot centralisatie dan tot decentralisatie. Hoe men in zo’n omgeving daadwerkelijk gedecentraliseerde on-chain agents kan bouwen, blijft een kernuitdaging waar de industrie zich op moet richten.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Orisi</strong>, Gate.io-onderzoeker<br><div>Vertaler: Orisi<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies. Alle beleggingen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>