QUkgQWdlbnRzOiBEZSBOaWV1d2UgS2F0YWx5c2F0b3Igdm9vciBkZSBDcnlwdG8gQUkgTWFya3Q=

2025-01-02, 07:50

<p><img src="https://gimg2.gateimg.com/image/article/173580439920241231-091957.jpg" alt=""></p>
<h2 id="h2-TLDR367943"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Terugkijkend op 2024, veroorzaakte de AI-boom in de cryptofinanciële sector ongekende aandacht.</p>
<p>Aan het begin van het jaar bestond de AI-sector uit slechts een handvol projecten. Aan het einde van het jaar had het een ingrijpende transformatie ondergaan en zich gevestigd als een onafhankelijke en niet te negeren baan.</p>
<p>Met name in de tweede helft van 2024 zorgde de opkomst van het AI-agent-verhaal ervoor dat het cryptografische AI-verhaal nieuwe hoogten bereikte.</p>
<h2 id="h2-Inleiding193554"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>In de tweede helft van 2024 bleef de populariteit van AI Agents toenemen. Het begon allemaal met een chatbot genaamd ‘Terminal of Truths’, die brede aandacht trok op het X-platform vanwege zijn humoristische en geestige antwoorden. Dit leverde het zelfs $50.000 aan financiering op van a16z-oprichter Marc Andreessen. Geïnspireerd door de inhoud ervan creëerde iemand de GOAT-token, die binnen slechts 24 uur met meer dan 10.000% steeg. De sterk stijgende prijs van de token bracht AI Agents in de schijnwerpers en trok aanzienlijke aandacht van investeerders op de cryptofinanciële markt.</p>
<h2 id="h2-Wat20is20een20AIagent323336"><a name="Wat is een AI-agent?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een AI-agent?</h2><p>In eenvoudige termen kan een AI Agent worden begrepen als een ‘intelligente digitale assistent’. Apple’s Siri is bijvoorbeeld een soort AI Agent.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804445Siri-assistant-1024x510.jpg" alt=""></p>
<p>AI-agents zijn echter, in tegenstelling tot gewone digitale assistenten, intelligente en gebaseerd op grote taalmodellen (LLM’s). Ze kunnen hun omgeving waarnemen, redeneren en beslissingen nemen, en complexe taken uitvoeren door middel van het gebruik van tools of het uitvoeren van acties.</p>
<p>De workflow van een AI Agent volgt een logische volgorde: Perception Module (inputacquisitie) → Large Model (begrijpen, redeneren en plannen) → Tool Invocation (taakuitvoering) → Feedback en Optimalisatie (validatie en aanpassing). Eerst verzamelt de AI Agent gegevens uit de externe omgeving via de Perception Module. Vervolgens voert het grote model logisch redeneren uit om mogelijke oplossingen te genereren of actieplannen te formuleren. Hier fungeert het grote model als het “brein” van de AI Agent en speelt het een cruciale rol bij de besluitvorming. Op basis van de beslissingen die door het grote model worden genomen, roept de AI-agent externe tools, plug-ins of API’s aan om specifieke taken uit te voeren. Ten slotte valideert en past het de resultaten aan op basis van feedback, waardoor een gesloten optimalisatieproces ontstaat.</p>
<p>Hoe verschilt een AI-agent dan van gewone digitale assistenten op specifieke wijze? <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Toepassingsscenario’s? Simpel gezegd, AI Agents zijn slimmer. Neem kwantitatieve handelsbots als voorbeeld. Gewone handelsbots voeren arbitrageprogramma’s strikt uit volgens vooraf ingestelde instructies, zelfs als de externe omstandigheden veranderen. Als een gebruiker bijvoorbeeld een strategie instelt om alleen transacties uit te voeren wanneer de winst hoger is dan 1%, zal de bot deze regel volgen, zelfs in het g van marktvolatiliteit. AI-agenten zijn echter anders. Hoewel ze in routinescenario’s ook transacties kunnen uitvoeren volgens vooraf ingestelde instructies, kunnen ze strategieën automatisch aanpassen op basis van marktfluctuaties wanneer de omstandigheden veranderen.</p>
<p>Het kernvoordeel van AI-agents is hun vermogen om zelf te leren en autonome beslissingen te nemen. Door hun omgeving te begrijpen, kunnen AI-agents hun besluitvormingsprocessen voortdurend optimaliseren en de efficiëntie van taakuitvoering verbeteren. Ze kunnen ook flexibel reageren op veranderingen in de externe omgeving.</p>
<p>Vanuit een industrieel ontwikkelingsperspectief heeft de markt over het algemeen twee verwachtingen van AI-agents. Een daarvan is dat AI-agents optreden als onafhankelijke entiteiten met hun eigen identiteit en merken, die autonoom gebruikersdiensten kunnen leveren. De andere is dat gebruikers persoonlijke AI-agents hebben, vergelijkbaar met persoonlijke assistenten, om hen te helpen bij het beheren van taken. In de praktijk zijn de meeste huidige verkenningen op de markt gericht op de eerste richting.</p>
<h2 id="h2-Debuut20op20de20piek20GOAT20Token20ontsteekt20de20AI20Agent20Sector517082"><a name="Debuut op de piek: GOAT Token ontsteekt de AI Agent Sector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Debuut op de piek: GOAT Token ontsteekt de AI Agent Sector</h2><p>Zoals eerder vermeld, markeerde de opkomst van de GOAT-token, afgeleid van de chatbot ‘Terminal of Truths’, het begin van deze AI Agent-cyclus. In oktober 2024 steeg de GOAT-token met 10.000% binnen 24 uur na de lancering, wat leidde tot een koortsachtige speculatie over AI Agent Meme-tokens en de massale uitgifte van bijna honderd AI Agent Meme-tokens.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804468X.PNG.png" alt=""><br>Met de toenemende momentum van de AI Agent sector, is het geleidelijk geëvolueerd tot een onafhankelijke niche binnen het crypto AI-veld. In slechts een paar maanden hebben de discussiepopulariteit op sociale media en de winstgevende kansen op de keten binnen de AI Agent sector al ver de vorige golf van dierenthema Meme-tokens overtroffen. Op het moment van publicatie door Gate.io laat Coingecko-gegevens zien dat de totale marktkapitalisatie van AI Agent-gerelateerde tokens $16,9 miljard heeft bereikt, goed voor meer dan 30% van de totale marktkapitalisatie ($48 miljard) van alle projecten in de crypto AI-sector. De hype eromheen blijft groeien.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804485C.PNG.png" alt=""></p>
<p>Terugkijkend op markttrends kan de opkomst van AI-agenten worden verdeeld in twee fasen:</p>
<p>Fase 1: De Meme Fase Geleid door GOAT</p>
<p>GOAT zelf was een Meme-token dat werd gegenereerd uit een gesprek tussen twee AI-agenten. Dit was de eerste keer dat AI menselijk gedrag vertoonde om zijn doelen te bereiken, waardoor het zeer experimenteel was en destijds als vooruitstrevend werd beschouwd. Het ogenschijnlijk onzinnige verhaal van Meme-tokens bood een vruchtbare voedingsbodem voor de ontwikkeling ervan. Naarmate GOAT aan populariteit won, begonnen er soortgelijke tokens op te komen. De meeste van deze tokens beperkten zich echter tot functionaliteiten zoals automatisch tweeten en antwoorden, zonder praktische toepassingen. In deze fase werden AI-agenttokens over het algemeen aangeduid als AI + Meme-tokens.</p>
<p>Ondanks de ogenschijnlijk oppervlakkige aard van de AI Agent Meme trend, heeft deze niet alleen een nieuwe golf van speculatie in de crypto AI sector veroorzaakt, maar ook de focus van de markt verlegd. De aandacht begon zich te verplaatsen van traditionele gedecentraliseerde data, GPU’s en andere crypto AI-infrastructuur naar AI Agent-toepassingen, wat het podium zette voor de tweede fase van ontwikkeling.</p>
<p>Fase 2: De fase van het verkennen van de toepassing</p>
<p>Naarmate projecten zich vermenigvuldigden tijdens de eerste fase, realiseerde de markt zich geleidelijk dat AI Agents zich konden uitbreiden van eenvoudige sociale media-interacties tot het creëren van tastbare waarde op gebieden zoals contentproductie en investeringsanalyse. Als gevolg hiervan begonnen AI Agents zich los te maken van hun Meme-achtergrond en vormden ze een geheel nieuwe sector die steeds meer tractie krijgt.</p>
<h2 id="h2-Wat20staat20er20te20gebeuren20in20de20AIsector20in202025305168"><a name="Wat staat er te gebeuren in de AI-sector in 2025?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat staat er te gebeuren in de AI-sector in 2025?</h2><p>Naarmate 2025 begint, hebben verschillende instellingen hun verwachtingen over trends in de branche voor het komende jaar gedeeld. Organisaties zoals a16z, VanEck, Bitwise, Hashed, Blockworks, Messari en Framework hebben allemaal hun mening gegeven. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a> over de ontwikkeling van de crypto- en AI-markten, waarbij met name wordt gewezen op het potentieel voor explosieve groei in AI Agent-gerelateerde producten in 2025.</p>
<p>Echter hebben sommige analisten erop gewezen dat hoewel de AI Agent trend nog enige tijd kan voortduren, het waarschijnlijk uiteindelijk zal vervagen. De managing partner van Dragonfly heeft verklaard dat de AI Agent rage naar verwachting zal voortduren tot 2025, maar geleidelijk zal afnemen. Volgens Dragonfly zijn AI Agents geen echte intelligente entiteiten, maar eerder chatbots met Meme-tokens eraan gekoppeld. Hun autonome mogelijkheden zijn vrij beperkt, afgezien van het plaatsen op Twitter. Dit vertegenwoordigt geen langdurige verstoring veroorzaakt door AI, maar eerder een fenomeen gedreven door hun sociale aantrekkingskracht, dat de aandacht van de cryptogemeenschap heeft getrokken.</p>
<p>Vanuit het bredere perspectief van de AI-industrie zijn er echter wel een reeks gebeurtenissen die de groei van AI Agents ondersteunen. Zo ondergaat OpenAI een overgang van GPT naar een algemene AI Agent. Naar verluidt heeft OpenAI plannen om in januari 2025 een nieuw AI Agent-product genaamd ‘Operator’ te lanceren. Dit product kan automatisch complexe taken uitvoeren zoals codering, reisboekingen en e-commerce winkelen. Sommige analisten geloven dat de lancering van Operator net zo revolutionair kan zijn als Sora en mogelijk de AI-markt weer kan doen opleven. Bovendien is de jaarlijkse AI-top van NVIDIA in maart 2025 een ander aandachtspunt voor de crypto- en AI-industrie, met het potentieel om kapitaalstromen aan te trekken en de crypto-AI-sector verder aan te wakkeren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1735804507107248194-1685471658101-sacks_jpg_92.jpg" alt=""></p>
<p>Op het beleidsfront is er ook goed nieuws. In januari zal de nieuw verkozen president van de VS, Donald Trump, officieel aan de macht komen. Hij heeft de benoeming aangekondigd van voormalig PayPal-utive David O. Sacks als directeur van de AI- en cryptocurrency-zaken van het Witte Huis, belast met het begeleiden van het regeringsbeleid op deze gebieden. David Sacks brengt dubbele investeringservaring in de crypto- en AI-industrieën, waarbij hij heeft geïnvesteerd in bedrijven zoals Multicoin en verschillende AI-bedrijven. De markt verwacht dat zijn beleid de integratie van crypto en AI zal bevorderen.</p>
<p>Samengevat heeft de opkomst van AI Agents in 2024 nieuwe vitaliteit in de crypto AI sector geïnjecteerd. Van de explosieve populariteit van Meme tokens tot de oprichting van AI Agents als een onafhankelijke subsector, hun technische voordelen en toepassingspotentieel zijn geleidelijk aan duidelijk geworden. Dit heeft niet alleen het verhaal binnen de crypto AI-markt veranderd, maar ook nieuwe investeringsmogelijkheden gecreëerd.</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 mening van de onderzoeker en vormt geen beleggingsaanbevelingen. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>