U0hFTEwncyBvcGVuYmFyZSBhYW5ib2QgaXMgbWVlciBkYW4gMTAwIGtlZXIgdmVyaG9vZ2QsIHphbCBoZXQgZGUgdmxvZWsgdmFuIGhldCBwaWVrZW4gYmlqIGRlIG9wZW5pbmcgZG9vcmJyZWtlbj8=

2025-02-18, 07:13

<p><img src="https://gimg2.gateimg.com/image/article/1739862400newhotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR512112"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>MyShell-token SHELL was 100 keer overtekend bij de publieke aanbieding, waarbij de daadwerkelijk opgehaalde fondsen meer dan $80 miljoen bedroegen, waarmee een recent record werd gevestigd voor overtekening van IDO’s in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> Het bleef stijgen na TGE, met een marktwaarde die ooit meer dan $600 miljoen bedroeg, wat investeerders’ erkenning van MyShell’s langetermijnwaarde benadrukt.</p>
<p>MyShell is een innovatief project dat een AI-app store, een creatieplatform en een economisch stimuleringsmechanisme voor makers integreert. Door agenten te leveren op basis van verschillende AI-modellen, stelt het gebruikers in staat om eenvoudig gepersonaliseerde AI Chatbots te maken. Tegelijkertijd combineert het gedecentraliseerde opslag- en privacy-rekentechnologieën om de privacy en beveiliging van gebruikersgegevens te waarborgen.</p>
<p>MyShell zal naar verwachting het “AI-waardenetwerk” worden in de <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> tijdperk, waarbij gegevensbijdragers, modelontwikkelaars, toepassingsmakers en gewone gebruikers de groeidividend kunnen delen via de token-economie. Met de doorbraak van multimodellen en de uitbreiding van AI-toepassingsscenario’s zal het een aggregatieplatform worden voor longtailbehoeften.</p>
<h2 id="h2-Introductie353669"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het meest populaire AI-protocol van de afgelopen tijd is MyShell. Met de SHELL-tokenopenbare aanbieding die meer dan 100 keer wordt overschreden en de marktwaarde die blijft stijgen, toont MyShell geleidelijk zijn potentieel om een AI-superportaal te worden door AI-toepassingswinkels, creatieve platforms en mechanismen voor economische prikkels voor makers te integreren. Dit artikel zal de technologische innovatie, het economische model en de marktvooruitzichten van MyShell diepgaand verkennen, analyseren hoe het gebruikerstrouw kan verbeteren door middel van gedecentraliseerde opslag- en privacy-rekentechnologieën terwijl de gebruikersprivacy wordt beschermd, en verder de democratisering van AI en de innovatie van de creatoreconomie kan bevorderen.</p>
<h2 id="h2-SHELL20heeft2010020keer20meer20opgehaald20dan20het20oorspronkelijke20bedrag20wat20de20aandacht20van20de20markt20heeft20getrokken54320"><a name="SHELL heeft 100 keer meer opgehaald dan het oorspronkelijke bedrag, wat de aandacht van de markt heeft getrokken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SHELL heeft 100 keer meer opgehaald dan het oorspronkelijke bedrag, wat de aandacht van de markt heeft getrokken</h2><p>De recente lancering van de openbare aanbieding (InitialDexOffering, IDO) van het AI-protocol MyShell-token SHELL is fenomenaal geweest en heeft veel aandacht van de markt getrokken.</p>
<p>Volgens de bekendgemaakte informatie was het oorspronkelijke plan om $800.000 op te halen. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> en geeft 40 miljoen tokens uit (4% van de totale voorraad), maar het werd uiteindelijk meer dan 100 keer overingeschreven, waarbij de daadwerkelijk opgehaalde fondsen meer dan $80 miljoen bedroegen, wat een recent record vestigde voor overinschrijving van IDO’s op de cryptomarkt.</p>
<p>De openbare aanbieding van het SHELL-token werd op 13 februari het middelpunt van de markt. De discussie op sociale media nam ook snel toe. De waardering van slechts $20 miljoen tijdens de openbare aanbieding trok ongetwijfeld veel investeerders en enthousiastelingen aan om deel te nemen aan de discussie, en uiteindelijk werd een totaal ingezameld bedrag van 11425% genoteerd.</p>
<p>Wat nog opmerkelijker is, is dat na TGE (Token Generation Event) SHELL niet verviel in de vloek van ‘piek bij opening’, maar bleef stijgen, met een stijging van meer dan 300% in de eerste week, en de marktwaarde een keer meer dan $600 miljoen heeft overschreden.</p>
<p>Op de datum van schrijven heeft de circulerende marktwaarde van SHELL $120 miljoen bereikt, en de volledige circulerende marktwaarde heeft $450 miljoen bereikt. Deze prestatie doorbreekt niet alleen het stereotype van de markt dat populaire protocollen, vooral sterk opgeblazen AI-tokens, zijn gedaald na de recente opening, maar benadrukt ook de erkenning van investeerders van de langetermijnwaarde van MyShell.<img src="https://gimg2.gateimg.com/image/article/17398627011.jpeg" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-Myshell20Innovator20van20AI20Democratie20en20Maker20Economie299135"><a name="Myshell: Innovator van AI Democratie en Maker Economie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Myshell: Innovator van AI Democratie en Maker Economie</h2><p>MyShell is een innovatief project dat in 2022 is gelanceerd en een AI-app store, een creatieplatform en een economisch stimuleringsmechanisme voor makers integreert, waardoor gebruikers een handig platform krijgen waarmee ze Agents kunnen gebruiken, creëren en investeren op basis van verschillende AI-modellen.</p>
<p>Volgens de officiële website kunnen gebruikers modellen zoals DeepSeek, GPT-4, Gemini Pro, en 100+ vooraf ingestelde AI-modellen en toolbibliotheken (zoals MeloTTS, OpenVoice) in slechts enkele minuten oproepen, waardoor gebruikers eenvoudig gepersonaliseerde AI-chatbots kunnen maken en combineren.<img src="https://gimg2.gateimg.com/image/article/17398627242.jpeg" alt=""><br>Bron: @myshell_ai</p>
<p>Met betrekking tot privacybescherming combineert MyShell gedecentraliseerde opslag (zoals IPFS) met privacy-rekenkundige technologie om ervoor te zorgen dat gebruikers volledige controle hebben over hun eigen gegevens en kunnen kiezen met wie ze deze delen. Deze functie, in tegenstelling tot andere AI-agentprotocollen, versterkt ongetwijfeld het vertrouwen van gebruikers en hun gevoel van veiligheid op het platform.</p>
<p>In een notendop ligt de kernwaarde van MyShell in zijn innovatie en praktische toepassing, en investeerders kunnen deelnemen aan de bouw en ontwikkeling van het volledige ecosysteem door SHELL-tokens vast te houden.</p>
<p>Volgens officiële documenten loopt SHELL door het hele ecosysteem, en gebruikers moeten tokens consumeren of inzetten om servicekosten te betalen, makers moeten inkomen verdienen, en investeerders moeten deelnemen aan governance. Bovendien kunnen vroege investeerders via het Bonding Curve-mechanisme van de AIPP-store op lange termijn dividenden delen nadat de AI-toepassing getokeniseerd is, en makers kunnen profiteren van transactiekosten.</p>
<p>Door dit economische model heeft MyShell een groep inheemse makers geïncubeerd wiens belangrijkste inhoud AI Agent is. Deze makers kunnen samen met het platform groeien, een unieke inhoudsvoorziening bieden en een deugdzame cirkel vormen. Tegelijkertijd beperkt MyShell ook investeerders om alleen inkomen te verdienen via langetermijndividenden, en kunnen ze geen winst maken via kortetermijn FOMO om grote prijswijzigingen te creëren. Deze opzet moedigt niet alleen de output van hoogwaardige inhoud aan, maar handhaaft ook een stabiele sfeer in de gemeenschap.<img src="https://gimg2.gateimg.com/image/article/17398627503.jpeg" alt=""><br>Bron: @myshell_ai</p>
<p>Gebruikers die de laatste ronde van de DeFi-stierenmarkt hebben meegemaakt, kunnen het duale aandrijvingsstimuleringsmodel gemakkelijk begrijpen. Myshell heeft dit vliegwieleffect geleend om gebruikers in staat te stellen AI-diensten te gebruiken → gegevens bij te dragen → beloningen te krijgen → meer makers aan te trekken → de toepassingssupply te verrijken → de vraag naar tokens te verhogen, waardoor een positieve cyclus van stimulerende effecten ontstaat.</p>
<p>Daarom werd SHELL na dit positieve nieuws beïnvloed en steeg het in 24 uur met 40%, nadat Myshell afgelopen weekend drie belangrijke updates had aangekondigd, waaronder het ShellAgent-componentprotocol, IM-integratie en on-chain-intelligentie.</p>
<h2 id="h2-In20de20AIboom20kan20Myshell20een20AIsuperportaal20worden798295"><a name="In de AI-boom kan Myshell een AI-superportaal worden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In de AI-boom kan Myshell een AI-superportaal worden</h2><p>Op de datum van schrijven vertegenwoordigen Crypto AI-tokens momenteel slechts 2,9% van de marktwaarde van Altcoins. Sinds 2024 heeft de wereldwijde AI-financiering de $50 miljard overschreden, maar 90% van de fondsen is naar de onderliggende modellen en rekenkrachtinfrastructuur gestroomd, en de toepassingslaag bevindt zich nog steeds in een ‘woestijnperiode’ waar de productcompetitiviteit onvoldoende is.</p>
<p>Volgens de prognose van McKinsey zal de AI-toepassingsmarkt na 2025 exploderen met een gemiddeld jaarlijks groeipercentage van 45%, waarbij longtail-scenario’s zoals onderwijs, entertainment en bedrijfsdiensten worden bestreken.<br><img src="https://gimg2.gateimg.com/image/article/17398627794.jpeg" alt=""><br>Bron: BlockBeats</p>
<p>De kernfactoren van deze trend zijn:</p>
<p>Doorbraken in multimodale modellen: DeepSeek, GPT-5, Sora en andere modellen integreren tekst-, beeld- en videogeneratiemogelijkheden om ‘holografische interactie’-scenario’s te creëren (zoals virtuele idolen en 3D-contentgeneratie);</p>
<p>Verlaag de ontwikkeldrempel: Codevrije tools (zoals MyShell Creative Workshop) stellen niet-technische gebruikers in staat om snel AI-toepassingen te bouwen, waardoor grassroots innovatie wordt ontketend;</p>
<p>Dringende behoefte aan commercialisering: OpenAI’s GPT Store is bekritiseerd door ontwikkelaars vanwege het rigide winstdelingsmechanisme. <a href="/web3" target="_blank" class="blog_inner_link">Web3</a>‘s transparante winstdeling en tokenprikkels zijn de sleutel geworden om de impasse te doorbreken.</p>
<p>Vanuit dit macro perspectief heeft MyShell, als het eerste platform dat multimodale modellen integreert en de tokenisatie van AI-toepassingen ondersteunt, meer dan een miljoen gebruikers en worden er elke dag meer dan duizend nieuwe AI-agents toegevoegd. Het wordt inderdaad verwacht dat het de explosieve groeitrajectorie van de App Store in het tijdperk van het mobiele internet zal repliceren en een aggregatieplatform zal worden voor de long-tail vraag naar AI+Crypto.<img src="https://gimg2.gateimg.com/image/article/17398628045.jpeg" alt=""><br>Bron: Duin</p>
<p>Met de doorbraak van multimodale modellen verschuift AI van “technische verkenning” naar “scenario-implementatie.” De positionering van MyShell - het verlagen van de drempel voor de ontwikkeling van AI-toepassingen en het openen van een commerciële gesloten lus - is tijdig en wordt verwacht een aggregatieplatform te worden voor langetermijnbehoeften.</p>
<p>Al met al, beoordelend vanuit de recente reeks acties van MyShell, is de ambitie van MyShell niet alleen om een AI-toepassingswinkel te zijn, maar om het ‘AI-waardenetwerk’ te worden in het Web3-tijdperk - hier kunnen gegevensbijdragers, modelontwikkelaars, toepassingsmakers en gewone gebruikers allemaal groeidividenden delen via de token-economie.</p>
<p>Met een openbare aanbieding van SHELL die meer dan 100 keer is verkocht en de marktprestaties van continue groei sinds de lancering, heeft MyShell brede erkenning gekregen in de markt. Om echter echt de vloek van een piek bij de opening te doorbreken en een duurzame en gestage ontwikkeling te bereiken, moet MyShell nog steeds doorgaan met het optimaliseren van de productervaring, het versterken van de constructie van het economische systeem voor makers, het uitbreiden van applicatiescenario’s en partners, en het versterken van risicobeheer en nalevingsactiviteiten. We zullen aandacht blijven besteden aan de acties van sterprotocollen zoals MyShell en u tijdig onze waarnemingen en inzichten brengen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling. 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>