QnVsbCBNYXJrZXQgUnVzaCBSaXNlcyB3ZWVyLCBIb2UgQUkgcmlqZHQgbmlldXdlIHZlcmhhbGVuIGluIEJ1bGwgTWFya2V0cz8=

<p><img src="https://gimg2.gateimg.com/image/article/1716440699sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR15632"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Beïnvloed door de positieve voortgang van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF’s, de algehele markt stopte met dalen en draaide omhoog; De AI-sector heeft opnieuw de stijging geleid en sterke veerkracht getoond.</p>
<p>De fusie van AGI nieuwe munten eind deze maand, de mogelijke iteratie van OpenAI’s ChatGPT-model in juni en de bijdragen van bedrijven zoals NVIDIA geven aan dat de AI-track het hele jaar positief zal worden beïnvloed.</p>
<p>Sommige nieuwe projecten, zoals Triathon PLAI Labs, Reiki, Kaito en anderen, boeken vooruitgang bij het verbeteren van de efficiëntie van gegevensanalyse en decentralisatie door innovatieve oplossingen, waarmee ze de innovatiegrenzen van AI in het cryptotechnologieveld verleggen.</p>
<h2 id="h2-Introductie374954"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Gedreven door een nieuwe ronde van marktverwachtingen, zoals Navida Q1-verkopen die verdubbelen en positieve vooruitgang in <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF’s, neemt de AI-sector opnieuw een belangrijke positie in de populariteitsranglijst in, en wordt het middelpunt van de aandacht op de cryptomarkt.</p>
<p>Als we een diepgaande analyse uitvoeren van het vertelritme en de prijsfluctuaties van de topactiva in de AI-sector, is het gemakkelijk te constateren dat deze trend een uiterst hoge marktveerkracht vertoont. In dit artikel zullen we nieuwe AI-projecten combineren om nieuwe trendkansen voor iedereen te benutten.</p>
<h2 id="h2-De20AIsector20leidt20de20opkomst20met20nieuwe20verhalen20boordevol20vitaliteit918744"><a name="De AI-sector leidt de opkomst, met nieuwe verhalen boordevol vitaliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De AI-sector leidt de opkomst, met nieuwe verhalen boordevol vitaliteit</h2><p>Deze week stopte de algehele markt met dalen en keerde hoger vanwege de positieve voortgang van Ethereum spot ETF’s. De AI-sector, die onlangs een zeer hoge veerkracht had getoond, leidde de markt omhoog, met winsten op de tweede plaats na Layer2.<br><img src="https://gimg2.gateimg.com/image/article/17164408261.jpeg" alt=""><br>Bron: SoSo Value</p>
<p>Het is niet moeilijk om te ontdekken dat bij verder onderzoek de snelle groei in populariteit van AI+Crypto-projecten te wijten is aan significante vooruitgang in kunstmatige intelligentietechnologie en brede maatschappelijke interesse. Als het meest verwachte thema in verschillende velden in 2024, wordt verwacht dat AI een reeks keteneffecten zal genereren.</p>
<p>Al in februari van dit jaar, toen OpenAI het tekst-naar-video-model Sora uitbracht, had de AI-conceptsector al een significante opwaartse trend ervaren. Recentelijk positieve ontwikkelingen en acties van belangrijke technologiebedrijven op het gebied van AI kunnen ook verdere groei van AI-concept-namaakmunten in de cryptobranche stimuleren.</p>
<p>Op de markt zullen de synthetische tokens AGIX, FET en OCEAN ASI naar verwachting eind mei worden uitgebracht, en er zijn ook geruchten dat ChatGPT-5 in juni zal worden uitgebracht. Tegelijkertijd staat de Global Developers Conference van Apple gepland voor 10 juni, wat de marktactiviteit in de AI-sector verder zal versterken.</p>
<p>Bovendien volgt technologiegigant Microsoft volgens Cointelgraph de crypto-industrie nauwlettend, vooral wat betreft het potentieel van blockchaintechnologie en kunstmatige intelligentie om te ondersteunen en te integreren. Dit duidt erop dat in de toekomstige ontwikkeling van de technologie-industrie AI en blockchaintechnologie mogelijk een sterke synergetische werking zullen hebben.</p>
<p>Naast de AI+Infra waar we eerder de nadruk op legden, zijn er ook AI+Data, AI+DePIN, AI+chat, AI+DID en AI+Game, evenals veel andere baanbrekende AI+Crypto nieuwe projecten opgedoken. De volgende tekst zal dit kort beschrijven en we kunnen ook de innovatieve veranderingen in de AI-branche hieruit zien.</p>
<h2 id="h2-Super20AI20FETAGIXOCEANASI782795"><a name="Super AI: FET+AGIX+OCEAN=ASI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Super AI: FET+AGIX+OCEAN=ASI</h2><p>Eind maart van dit jaar hebben SingularityNET (AGIX), <a href="/price/fetch-ai-fet" target="_blank" class="blog_inner_link">Fetch.ai</a> (FET) en Ocean Protocol (OCEAN), drie toonaangevende AI-projecten, een voorstel tot token-samenvoeging gelanceerd, waarbij tokens worden samengevoegd tot ASI’s die eigendom zijn van Superintelligence Collection, waardoor ze een van de grootste open-source en onafhankelijke deelnemers worden op het gebied van onderzoek en ontwikkeling van kunstmatige intelligentie.</p>
<p>Op basis van de goedgekeurde voorstelinhoud zal FET ASI worden met een totale voorraad van 2,63 miljard tokens en een startprijs van $2,82. AGIX zal migreren naar ASI tegen een wisselkoers van 0,433350 tot 1, OCEAN zal migreren naar ASI tegen een wisselkoers van 0,433226 tot 1. Uiteindelijk zal de waardering van ASI $7,5 miljard bereiken.<br><img src="https://gimg2.gateimg.com/image/article/17164408502.jpeg" alt=""><br>Bron: <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a></p>
<p>Er wordt gemeld dat Superintelligence Collective een team zal vormen onder leiding van Sheikh Goertzel als CEO, waarbij Pon en McConaghy het bestuurscomité van Ocean Protocol vertegenwoordigen. Het is vermeldenswaard dat deze bedrijven afzonderlijk zullen opereren en alleen zullen samenwerken in de activiteiten van het ASI-token economie-ecosysteem en Superintelligence Collection.</p>
<p>We hebben eerder verschillende artikelen geschreven waarin deze drie top AI-platforms worden geïntroduceerd: Fetch AI is een Web3-bedrijf dat een gedecentraliseerd multi-agent platform bouwt om AI-toepassingen in te zetten; SingularityNET biedt een op blockchain gebaseerde AI-markt en een democratisch, inclusief en gunstig servicekader voor Kunstmatige Algemene Intelligentie (AGI); en Ocean Protocol is een gedecentraliseerd gegevensuitwisselingsplatform dat privacy beschermt.</p>
<p>Kortom, ASI New Coin zal de fusie van tokens op de cryptomarkt pionieren en wordt het meest verwachte AI-evenement in mei.</p>
<h2 id="h2-AIDeSci20Triatlon855212"><a name="AI+DeSci: Triatlon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+DeSci: Triatlon</h2><p>De combinatie van AI en DeSci opent nieuwe onderzoeks- en toepassingsgebieden. De grote hoeveelheid gedetailleerde datasets gegenereerd door DeSci (gedecentraliseerde wetenschap) kan rijkere trainingsmaterialen bieden voor kunstmatige intelligentiemodellen, waardoor ze nauwkeuriger worden, een breder publiek bereiken en meer innovatieve toepassingen voortbrengen.</p>
<p>En Triathon bouwt zo’n ‘An AI for AI’ ecosysteem, waarbij AI wordt getraind met AI en de token GROW-gouvernantiefunctie wordt geactiveerd. Elke gebruiker kan de groeirichting van AI Agent (AIA) beheersen via GROW en AIA stimuleren om continu dynamisch AI-modellen te trainen.<br><img src="https://gimg2.gateimg.com/image/article/17164408763.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Triathon zal in de volgende fase een betrouwbaar en controleerbaar AI en DeSci (Decentralized Science) Integratiesysteem opbouwen. Bij het opzetten van een betrouwbaar en controleerbaar AI zal Triathon AI+Fuzzy-technologie introduceren om de functionele grenzen van AI te controleren en ervoor te zorgen dat de evolutie van AIA naar een betrouwbaar en betrouwbaar intelligent autonoom systeem wordt gewaarborgd door de dynamische AI-trainingsroute die is ingesteld door Triathon.</p>
<p>En DeSci-integratie, als het systeem dat Triathon in de toekomst zal bouwen, omvat gedecentraliseerde datamarkten, door GROW-token gefinancierd open source-onderzoek en gebruikers AIA-governance DAO, en waarborgt gegevensprivacy en -beveiliging via privacy computing-technologie, om gegevensdeling en samenwerking te bevorderen binnen de AI-onderzoeksgemeenschap.</p>
<h2 id="h2-AI20Zoekmachine20Kaito250632"><a name="AI+ Zoekmachine: Kaito" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+ Zoekmachine: Kaito</h2><p>Als een door AI aangedreven Web3-zoekmachine heeft Kaito onlangs een bètaversie uitgebracht van een crypto-zoekmachine genaamd ‘WHAT’, gebaseerd op LLM (Large Language Model), en heeft potentiële gebruikers toegang gegeven tijdens de bètatestfase.<br><img src="https://gimg2.gateimg.com/image/article/17164408954.jpeg" alt=""><br>Bron: KAITO</p>
<p>Kaito benadrukte dat deze ‘WHIT’ zoekmachine Auto GPT-technologie, geavanceerde grootschalige taalmodellen (zoals GPT-4) en Kaito’s unieke realtime crypto-zoekfunctie integreert.</p>
<h2 id="h2-AISocial20amp20Creator20Economy20Reiki70492"><a name="AI+Social &amp; Creator Economy: Reiki" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Social &amp; Creator Economy: Reiki</h2><p>Reiki is een door data intelligence network Web3Go ondersteund platform voor het creëren van AI-native applicaties. De Reiki AI Bot en AI Bot NFT Mint functies zijn gelanceerd, waarbij de eerste specifiek is ontworpen om gebruikersproblemen in de educatieve sector van blockchain en crypto op te lossen. De functies omvatten het verstrekken van basis <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Kennis en tutorials met betrekking tot kettingen, evenals diepgaande gegevensinhoud over blockchaintechnologie en marktdynamiek. Dit stelt gebruikers in staat om hun gemaakte AI-chatbots om te zetten in NFT’s en deze te maken tot AI-native digitale activa op de ketting.<br><img src="https://gimg2.gateimg.com/image/article/17164409145.jpeg" alt=""><br>Bron: REIKI</p>
<h2 id="h2-AIGameSocial20PLAI20Labs519851"><a name="AI+Game+Social: PLAI Labs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Game+Social: PLAI Labs</h2><p>PLAI Labs is een <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> en AI sociaal platform, en de eerste entertainmentervaring was gebaseerd op het blockchainspel Champion Ascension dat op dit platform is gebouwd.<br><img src="https://gimg2.gateimg.com/image/article/17164409356.jpeg" alt=""><br>Bron: PLAI Labs</p>
<p>PLAI Labs bouwt ook een AI-protocolplatform dat zal helpen bij het verwerken van alle inhoud, van door gebruikers gegenereerde inhoud (UGC) tot het matchen van 2D naar 3D asset-rendering.</p>
<h2 id="h2-Hoeveel20verbeeldingsruimte20is20er20nog20voor20AICrypto23440"><a name="Hoeveel verbeeldingsruimte is er nog voor AI+Crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel verbeeldingsruimte is er nog voor AI+Crypto?</h2><p>Ongetwijfeld zal de AI-cryptomarkt ter waarde van meer dan $42 miljard het meest explosieve nieuwe verhaal van deze bullmarkt zijn.</p>
<p>De iteratie van OpenAI’s ChatGPT-model De samenvoeging van AGI’s nieuwe valuta en de bijdrage van bedrijven zoals NVIDIA duiden erop dat het AI-veld gedurende het jaar positief zal worden beïnvloed.</p>
<p>We zijn verheugd te ontdekken dat sommige nieuwe projecten, zoals Triathon PLAI Labs, Reiki, Kaito, en anderen, door middel van innovatieve oplossingen doorbraken boeken in het verbeteren van de efficiëntie van gegevensanalyse en decentralisatie. Deze projecten breiden de innovatiegrenzen van AI uit op het gebied van cryptotechnologie, wat aangeeft dat kunstmatige intelligentie en blockchaintechnologie gezamenlijk veiligere, efficiëntere en transparantere en zullen opbouwen.<br><img src="https://gimg2.gateimg.com/image/article/17164409527.jpeg" alt=""><br>Bron: CoinMarketCap</p>
<p>Ondanks de veelbelovende vooruitzichten brengen veel nieuwe projecten ook inherente risico’s met zich mee en dienen investeerders grondig onderzoek te doen naar de specifieke situatie van elk project bij het zoeken naar potentieel excessieve rendementen.</p>
<p>Samengevat zullen in 2024 een reeks toonaangevende AI+Crypto-projecten het industrielandschap vormgeven, waarbij veel aandacht wordt besteed aan hun innovatie en toepassingsdiversiteit. Voor investeerders, ontwikkelaars en gebruikers is het behoud van begrip en aanpassingsvermogen aan de ontwikkeling van AI-cryptocurrency van cruciaal belang om de vooruitgang, uitdagingen en kansen in dit veelbelovende interdisciplinaire veld te grijpen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>