Q29zXCfDqCBTYWhhcmE/

2025-06-23, 09:43

<p><img src="https://gimg2.gateimg.com/image/sahara202506231742394125795260.png" alt="">
</p><p>Nel tradizionale modello di sviluppo dell’IA, i contribuenti di dati e gli sviluppatori sono a lungo stati in uno stato di distribuzione del valore sbilanciato: gli esseri umani forniscono dati per addestrare i modelli ma ricevono molto poco in cambio; gli sviluppatori creano asset intelligenti ma faticano con la conferma dei diritti e la circolazione. L’emergere di Sahara AI è precisamente per ricostruire questa relazione di produzione.</p>
<p>Come il primo stack completo nativo AI al mondo <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Dalla lancio della testnet nel 2024, la piattaforma Sahara ha attratto 3,2 milioni di account on-chain e 1,4 milioni di utenti attivi giornalieri che partecipano alla etichettatura dei dati, allo sviluppo di modelli e alla creazione di asset, e ha stabilito partnership ecosistemiche con oltre 40 delle principali istituzioni, tra cui Microsoft, Amazon e Google Cloud.</p>
<h2 id="h2-Posizionamento20della20Visione20Costruire20il20Sistema20Operativo20Web320nellEra20dellAI409019"><a name="Posizionamento della Visione: Costruire il “Sistema Operativo Web3” nell’Era dell’AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Posizionamento della Visione: Costruire il “Sistema Operativo Web3” nell’Era dell’AI</h2><p>Il posizionamento di Sahara AI va ben oltre un singolo strumento o mercato; mira a diventare l’infrastruttura a collegamento completo che supporta un’economia AI decentralizzata. La sua missione principale è affrontare il dilemma triplice di “conferma dei diritti poco chiara, distribuzione sbilanciata e circolazione inefficiente” nello sviluppo dell’AI.</p>
<p>A differenza della maggior parte dei progetti che aggiungono un <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> layer ai strumenti AI esistenti, Sahara ricostruisce le regole di proprietà degli asset intelligenti dal livello del protocollo. Nel suo design, dati, modelli e agenti possono essere registrati come asset on-chain, consentendo la conferma dei diritti verificabili, la gestione dei permessi e meccanismi di condivisione dei profitti.</p>
<p>“Sahara non è solo un altro progetto blockchain; è una chiamata a una riflessione sistematica e a un’azione collettiva,” ha sottolineato il cofondatore e CEO Sean Ren. “Abbiamo raggiunto un reale fatturato e stiamo restituendo valore direttamente ai contributori.”</p>
<p>Nel mese di agosto 2024, il progetto ha ottenuto 43 milioni di dollari in finanziamenti guidati da Binance Labs e Pantera Capital, con un importo totale di finanziamenti successivi che ha raggiunto i 51,5 milioni di dollari, fornendo un’ampia dotazione per l’implementazione della tecnologia.</p>
<h2 id="h2-Architettura20Tecnica20e20Ecosistema20di20Prodotto20Un20Sistema20a20Ciclo20Chiuso20dai20Dati20al20Modello25926"><a name="Architettura Tecnica e Ecosistema di Prodotto: Un Sistema a Ciclo Chiuso dai Dati al Modello" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Architettura Tecnica e Ecosistema di Prodotto: Un Sistema a Ciclo Chiuso dai Dati al Modello</h2><p>L’architettura di Sahara è suddivisa in due livelli: un blockchain Layer 1 compatibile con EVM auto-sviluppato responsabile della registrazione degli asset e del regolamento delle transazioni; un protocollo di esecuzione AI off-chain genera prove di esecuzione verificabili attraverso un Trusted Execution Environment (TEE), garantendo trasparenza nel processo.</p>
<p>Questa architettura supporta quattro prodotti principali che coprono l’intero ciclo di vita dell’IA:</p>
<ul>
<li>Piattaforma di Servizi Dati (DSP): Gli utenti contribuiscono attraverso l’annotazione dei dati per guadagnare incentivi on-chain. Il volume dei compiti nel secondo trimestre ha raggiunto 2,55 milioni di voci, con un’accuratezza migliorata al 95%, e è stato introdotto un meccanismo di token legato all’anima (SBT) di “livello demigod” per incentivare i contributori di qualità.</li><li>Piattaforma Sviluppatore AI (Sahara Studio): In arrivo nel secondo trimestre del 2025, integra strumenti per l’addestramento dei modelli, il deployment e la gestione dei flussi di lavoro, abbassando significativamente la soglia di sviluppo.</li><li>Mercato di Trading AI: Lancio previsto nel Q3/Q4 2025, supportando il trading decentralizzato e la licenza di dataset, modelli e agenti, attivando la circolazione degli asset.</li><li>Agenti Intelligenti per la Conoscenza (KAs): Applicazioni AI autonome implementabili che formano uscite terminali ecologiche.</li></ul>
<h2 id="h2-Ultimo20aggiornamento20conto20alla20rovescia20per20il20Mainnet20e20lancio20del20token36483"><a name="Ultimo aggiornamento: conto alla rovescia per il Mainnet e lancio del token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultimo aggiornamento: conto alla rovescia per il Mainnet e lancio del token</h2><p>Secondo la roadmap pubblicata da Sahara AI per il 2024 - 2025, i suoi traguardi chiave indicano chiaramente il lancio del Mainnet:</p>
<ul>
<li>Q4 2024: Lancio della testnet e della piattaforma di servizi dati, avvio del programma di ricompense per gli utenti.</li><li>Q1 2025: Lancio dell’accesso anticipato al Marketplace AI</li><li>Q2 2025: Lancio del Sahara Studio Toolkit</li><li>Q3 2025: lancio del Mainnet di Sahara Chain, supportando il trading di dati e asset modello.</li></ul>
<p>Il 19 maggio 2025, Sahara ha lanciato la rete di test pubblica SIWA, che ha aperto per la prima volta la registrazione del dataset e la funzione di conio del certificato di proprietà, segnando l’ingresso del suo sistema di conferma on-chain nella fase di verifica pubblica.</p>
<p>A livello di token, SAHARA sarà quotato su più exchange il 26 giugno 2025.</p>
<p>Questa vendita comunitaria è stata sovrascritta di quasi 9 volte, con una valutazione iniziale completamente diluita (FDV) di 600 milioni di dollari, riflettendo una forte fiducia del mercato nel progetto.</p>
<h2 id="h2-Dati20Utente20e20Cooperazione20nellEcosistema20Crescita20del20Volano20di20Validazione20del20Testnet96692"><a name="Dati Utente e Cooperazione nell’Ecosistema: Crescita del Volano di Validazione del Testnet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dati Utente e Cooperazione nell’Ecosistema: Crescita del Volano di Validazione del Testnet</h2><p>I dati del testnet SIWA confermano il potenziale di crescita di Sahara:</p>
<ul>
<li>Il numero totale di account ha superato i 3,2 milioni, con utenti attivi giornalieri che superano 1,4 milioni.</li><li>Il numero di partecipanti all’annotazione dei dati ha superato i 200.000, con un volume di completamento dei compiti che ha raggiunto 2,55 milioni nel secondo trimestre.</li><li>L’accuratezza dei dati è migliorata dal 92% nel primo trimestre al 95% nel secondo trimestre.</li></ul>
<p>La cooperazione ecologica si sta espandendo in modo sincrono, con l’introduzione di oltre 40 partner tra cui AWS, Google Cloud, UC Berkeley e Together AI, coprendo i settori del cloud computing, dei protocolli open source e della ricerca accademica. Questo forma una rete di sinergia tecnologica con partner precedenti come Microsoft, Amazon e MIT.</p>
<h2 id="h2-Significato20Futuro20Il20Punto20di20Partenza20dellEra20DeAI594378"><a name="Significato Futuro: Il Punto di Partenza dell’Era De-AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Significato Futuro: Il Punto di Partenza dell’Era De-AI</h2><p>L’obiettivo finale di Sahara è diventare il sistema operativo sottostante che integra AI e Web3. Il suo valore non si riflette solo nel miglioramento dell’efficienza degli strumenti, ma anche nell’istituzione di un modello economico a circuito chiuso di conferma dei diritti dei contributori → circolazione degli attivi → innovazione degli sviluppatori → benefici per gli utenti.</p>
<p>Se il Mainnet sarà lanciato secondo programma nel terzo trimestre del 2025 e sarà completamente funzionante, Sahara affronterà tre questioni fondamentali:</p>
<ol>
<li>I contributori di dati riceveranno ricompense verificabili.</li><li>Gli sviluppatori di modelli avranno diritti di proprietà intellettuale assetizzati.</li><li>Le imprese avranno accesso a una catena di approvvigionamento AI conforme e trasparente.</li></ol>
<p>“Stiamo dando il benvenuto a un’era di collaborazione AI più aperta, equa e sostenibile,” ha dichiarato il CEO di Together AI Vipul Ved Prakash, “Questa diventerà la nuova infrastruttura per l’AI Web3.”</p>
<p>Con il lancio del Sahara Chain Mainnet nel terzo trimestre del 2025, gli sviluppatori globali avranno accesso per la prima volta a una piattaforma completa per lo sviluppo e l’assetizzazione dell’IA. Etichettatori di dati, formatori di modelli e sviluppatori di agenti: ogni partecipante può fare affidamento sui protocolli on-chain per ottenere la conferma dei diritti di contribuzione e i ritorni di valore.</p>
<p>Mentre l’economia tradizionale dell’IA è ancora monopolizzata dai giganti della tecnologia, Sahara sta costruendo un’autostrada decentralizzata dai dati ai modelli. Su questa strada, i contributi sono diritti, l’intelligenza è un bene e la collaborazione porta profitto.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>