TCdvZmZlcnRhIHB1YmJsaWNhIGRpIFNIRUxMIMOoIGF1bWVudGF0YSBkaSBwacO5IGRpIDEwMCB2b2x0ZSwgcml1c2NpcsOgIGEgcm9tcGVyZSBpbCB0YWLDuSBkZWwgcGljY28gYWxsJ2FwZXJ0dXJhPw==

2025-02-18, 07:13

<p><img src="https://gimg2.gateimg.com/image/article/1739862400newhotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR562294"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il token MyShell SHELL è stato sottoscritto oltre 100 volte nell’offerta pubblica, con fondi effettivi raccolti superiore a 80 milioni di dollari, stabilendo un record recente per la sovrasottoscrizione degli IDO nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>. È continuato a salire dopo il TGE, con un valore di mercato che ha superato una volta i 600 milioni di dollari, evidenziando il riconoscimento degli investitori del valore a lungo termine di MyShell.</p>
<p>MyShell è un progetto innovativo che integra un negozio di app AI, una piattaforma di creazione e un meccanismo di incentivi economici per i creatori. Fornendo agenti basati su vari modelli di intelligenza artificiale, consente agli utenti di creare facilmente Chatbot AI personalizzati. Allo stesso tempo, combina tecnologie di archiviazione decentralizzata e di calcolo della privacy per garantire la privacy e la sicurezza dei dati dell’utente.</p>
<p>MyShell è destinato a diventare la “rete di valore AI” nel <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> era, consentendo ai contributori di dati, ai developer di modelli, ai creatori di applicazioni e agli utenti ordinari di condividere il dividendo della crescita attraverso l’economia dei token. Con la rottura dei modelli multimodali e l’espansione degli scenari di applicazione dell’IA, diventerà una piattaforma di aggregazione per le esigenze a lunga coda.</p>
<h2 id="h2-Introduzione113989"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il protocollo AI più popolare degli ultimi tempi è MyShell. Con l’offerta pubblica di token SHELL che supera di oltre 100 volte e il suo valore di mercato in continuo aumento, MyShell sta gradualmente dimostrando il suo potenziale di diventare un super portale AI integrando negozi di applicazioni AI, piattaforme creative e meccanismi di incentivi economici per i creatori. Questo articolo esplorerà in modo approfondito l’innovazione tecnologica di MyShell, il modello economico e le prospettive di mercato, analizzando come può aumentare la fiducia degli utenti attraverso tecnologie di archiviazione decentralizzata e calcolo della privacy, proteggendo nel contempo la privacy degli utenti e promuovere ulteriormente la democratizzazione dell’IA e l’innovazione dell’economia dei creatori.</p>
<h2 id="h2-SHELL20ha20raccolto2010020volte20di20pi20rispetto20allimporto20originale20attirando20lattenzione20del20mercato399726"><a name="SHELL ha raccolto 100 volte di più rispetto all’importo originale, attirando l’attenzione del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SHELL ha raccolto 100 volte di più rispetto all’importo originale, attirando l’attenzione del mercato</h2><p>Il recente lancio dell’offerta pubblica (InitialDexOffering, IDO) del token SHELL del protocollo AI MyShell è stato fenomenale e ha attirato grande attenzione dal mercato.</p>
<p>Secondo le informazioni divulgate, il piano originale prevedeva di raccogliere $800,000 worth of <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> e emettere 40 milioni di token (4% dell’offerta totale), ma alla fine è stata sottoscritta per più di 100 volte, con fondi effettivi raccolti che superano gli 80 milioni di dollari, stabilendo un record recente per sovrasottoscrizione di IDO nel mercato crittografico.</p>
<p>L’offerta pubblica del token SHELL è diventata il focus del mercato il 13 febbraio. Anche la discussione sui social media è aumentata rapidamente. La valutazione di soli $20 milioni durante l’offerta pubblica ha indubbiamente attirato molti investitori e appassionati a partecipare alla discussione, registrando infine un importo totale raccolto del 11425%.</p>
<p>Ciò che è ancora più notevole è che dopo l’evento di generazione dei token (TGE), SHELL non è caduto nella maledizione del “picco all’apertura”, ma ha continuato a salire, con un aumento di oltre il 300% nella prima settimana, e il suo valore di mercato ha superato una volta i 600 milioni di dollari.</p>
<p>Alla data della scrittura, il valore di mercato circolante di SHELL ha raggiunto $120 milioni, e il suo pieno valore di mercato circolante ha raggiunto $450 milioni. Questa performance non solo rompe lo stereotipo di mercato che i protocolli popolari, in particolare i token AI altamente gonfiati, sono diminuiti dopo l’apertura di recente, ma evidenzia anche il riconoscimento degli investitori del valore a lungo termine di MyShell.<img src="https://gimg2.gateimg.com/image/article/17398627011.jpeg" alt=""><br>Sorgente: Gate.io</p>
<h2 id="h2-Myshell20Innovatore20della20Democratizzazione20dellIA20e20dellEconomia20dei20Creatori82869"><a name="Myshell: Innovatore della Democratizzazione dell’IA e dell’Economia dei Creatori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Myshell: Innovatore della Democratizzazione dell’IA e dell’Economia dei Creatori</h2><p>MyShell è un progetto innovativo lanciato nel 2022 che integra un negozio di app di intelligenza artificiale, una piattaforma di creazione e un meccanismo di incentivi economici per i creatori, fornendo agli utenti una piattaforma conveniente che consente loro di utilizzare, creare e investire in Agenti basati su vari modelli di intelligenza artificiale.</p>
<p>Secondo il sito ufficiale, gli utenti possono richiamare modelli come DeepSeek, GPT-4, Gemini Pro e oltre 100 modelli AI predefiniti e librerie di strumenti (come MeloTTS, OpenVoice) in pochi minuti, consentendo agli utenti di creare e combinare facilmente Chatbot AI personalizzati.<img src="https://gimg2.gateimg.com/image/article/17398627242.jpeg" alt=""><br>Fonte: @myshell_ai</p>
<p>Per quanto riguarda la protezione della privacy, MyShell combina lo storage decentralizzato (come IPFS) con la tecnologia informatica della privacy per garantire che gli utenti possano controllare completamente i propri dati e scegliere con chi condividerli. Questa caratteristica, a differenza di altri protocolli di AI Agent, senza dubbio rafforza la fiducia degli utenti e il senso di sicurezza nella piattaforma.</p>
<p>In poche parole, il valore principale di MyShell risiede nella sua innovazione e praticità, e gli investitori possono partecipare alla costruzione e allo sviluppo dell’intero ecosistema detenendo i token SHELL.</p>
<p>Secondo documenti ufficiali, SHELL si sviluppa in tutto l’ecosistema e gli utenti devono consumare o impegnare token per pagare le commissioni di servizio, i creatori devono guadagnare reddito e gli investitori devono partecipare alla governance. Inoltre, attraverso il meccanismo della Curva di Bonding del negozio AIPP, gli investitori precoci possono condividere dividendi a lungo termine dopo che l’applicazione di intelligenza artificiale è tokenizzata e i creatori possono beneficiare delle commissioni di transazione.</p>
<p>Attraverso questo modello economico, MyShell ha incubato un gruppo di creatori nativi il cui contenuto principale è l’AI Agent. Questi creatori possono crescere insieme alla piattaforma, fornire un’offerta di contenuti unica e creare un circolo virtuoso. Allo stesso tempo, MyShell limita anche gli investitori a guadagnare reddito solo attraverso dividendi a lungo termine e non possono ottenere profitti attraverso FOMO a breve termine per creare grandi variazioni di prezzo. Questo design non solo incoraggia la produzione di contenuti di alta qualità, ma mantiene anche un’atmosfera stabile nella comunità.<img src="https://gimg2.gateimg.com/image/article/17398627503.jpeg" alt=""><br>Fonte: @myshell_ai</p>
<p>Gli utenti che hanno sperimentato l’ultima fase del mercato rialzista DeFi potrebbero facilmente capire il modello di incentivi a doppia ruota motrice. Myshell ha preso in prestito questo effetto volano per consentire agli utenti di utilizzare servizi AI → contribuire ai dati → ottenere ricompense → attirare più creatori → arricchire l’offerta di applicazioni → aumentare la domanda di token, formando così un ciclo positivo di effetti incentivanti.</p>
<p>Ecco perché, dopo che Myshell ha annunciato tre importanti aggiornamenti lo scorso fine settimana, tra cui il protocollo dei componenti ShellAgent, l’integrazione IM e l’intelligence on-chain, SHELL è stata colpita da questa notizia positiva ed è aumentata del 40% in 24 ore.</p>
<h2 id="h2-Nel20boom20dellIA20Myshell20potrebbe20diventare20un20super20portale20AI914268"><a name="Nel boom dell’IA, Myshell potrebbe diventare un super portale AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nel boom dell’IA, Myshell potrebbe diventare un super portale AI</h2><p>Alla data della stesura, i token Crypto AI rappresentano attualmente solo il 2,9% del valore di mercato delle Altcoin. Dal 2024, il finanziamento globale dell’AI ha superato i 50 miliardi di dollari, ma il 90% dei fondi è affluente ai modelli sottostanti e all’infrastruttura di potenza di calcolo, e il livello di applicazione è ancora in un periodo “deserto” in cui la competitività del prodotto è insufficiente.</p>
<p>Secondo le previsioni di McKinsey, dopo il 2025, il mercato delle applicazioni di intelligenza artificiale esploderà a un tasso annuo medio del 45%, coprendo scenari di coda come l’istruzione, l’intrattenimento e i servizi aziendali.<br><img src="https://gimg2.gateimg.com/image/article/17398627794.jpeg" alt=""><br>Sorgente: BlockBeats</p>
<p>I principali driver di questo trend sono:</p>
<p>Avanzamenti nel modello multimodale: DeepSeek, GPT-5, Sora e altri modelli integrano capacità di generazione di testo, immagini e video per creare scenari di “interazione olografica” (come idoli virtuali e generazione di contenuti 3D);</p>
<p>Soglia di sviluppo più bassa: gli strumenti senza codice (come MyShell Creative Workshop) consentono agli utenti non tecnici di creare rapidamente applicazioni di intelligenza artificiale, scatenando l’innovazione di base;</p>
<p>Urgente necessità di commercializzazione: il GPT Store di OpenAI è stato criticato dagli sviluppatori per il suo meccanismo rigido di condivisione dei profitti. La condivisione trasparente dei profitti e gli incentivi token di <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> sono diventati la chiave per sbloccare l’impasse.</p>
<p>Da questa prospettiva macro, MyShell, come prima piattaforma che integra modelli multimodali e supporta la tokenizzazione delle applicazioni AI, conta oltre un milione di utenti e oltre un migliaio di nuovi agenti AI aggiunti ogni giorno. È infatti previsto che replichi la traiettoria esplosiva dell’App Store nell’era di Internet mobile e diventi una piattaforma di aggregazione per la domanda a lunga coda di AI+Crypto.<img src="https://gimg2.gateimg.com/image/article/17398628045.jpeg" alt=""><br>Sorgente: Dune</p>
<p>Con la rottura dei modelli multimodali, l’IA sta passando dall’“esplorazione tecnica” all’“implementazione dello scenario”. Il posizionamento di MyShell - abbassando la soglia per lo sviluppo di applicazioni AI e aprendo un loop chiuso commerciale - è tempestivo e ci si aspetta che diventi una piattaforma di aggregazione per le esigenze a lunga coda.</p>
<p>Nel complesso, giudicando dalle recenti azioni di MyShell, l’ambizione di MyShell non è solo quella di essere un negozio di applicazioni AI, ma di diventare la “rete di valore AI” nell’era di <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> - qui, i contributori di dati, gli sviluppatori di modelli, i creatori di applicazioni e gli utenti ordinari possono condividere tutti i dividendi di crescita attraverso l’economia dei token.</p>
<p>Con l’offerta pubblica di SHELL che supera le 100 volte e le prestazioni di mercato in continuo aumento fin dal suo lancio, MyShell ha ottenuto ampia riconoscenza sul mercato. Tuttavia, per rompere veramente la maledizione del picco all’apertura e raggiungere uno sviluppo sostenuto e costante, MyShell deve ancora continuare a ottimizzare l’esperienza del prodotto, rafforzare la costruzione del sistema economico del creatore, espandere gli scenari di applicazione e i partner, e rafforzare le operazioni di gestione del rischio e di conformità. Continueremo a prestare attenzione alle azioni dei protocolli stellari come MyShell e vi proporremo le nostre osservazioni e riflessioni in modo tempestivo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</strong>, Ricercatore di Gate.io<br><div>Translator: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>