V2F0IGlzIFNhaGFyYT8gU2FoYXJhIEFJIE1haW5uZXQgc3RhYXQgb3AgaGV0IHB1bnQgdGUgbGFuY2VyZW4gaW4gUTM=

2025-06-23, 09:43

<p><img src="https://gimg2.gateimg.com/image/sahara202506231742394125795260.png" alt="">
</p><p>In het traditionele AI-ontwikkelingsmodel zijn datacontributoren en ontwikkelaars al lange tijd in een staat van onevenwichtige waardeverdeling—mensen leveren gegevens om modellen te trainen, maar ontvangen daar zeer weinig voor terug; ontwikkelaars creëren intelligente activa maar hebben moeite met het bevestigen van rechten en circulatie. De opkomst van Sahara AI is precies bedoeld om deze productierelatie te reconstrueren.</p>
<p>Als de eerste AI-native full stack ter wereld <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Sinds de lancering van de testnet in 2024 heeft het Sahara-platform 3,2 miljoen on-chain accounts en 1,4 miljoen dagelijkse actieve gebruikers aangetrokken die deelnemen aan gegevenslabeling, modelontwikkeling en activaminting, en heeft het ecosysteempartnerschappen gevestigd met meer dan 40 topinstellingen, waaronder Microsoft, Amazon en Google Cloud.</p>
<h2 id="h2-Visie20Positionering20Bouw20het20Web320Besturingssysteem20in20het20AItijdperk353768"><a name="Visie Positionering: Bouw het “Web3 Besturingssysteem” in het AI-tijdperk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Visie Positionering: Bouw het “Web3 Besturingssysteem” in het AI-tijdperk</h2><p>De positionering van Sahara AI gaat veel verder dan een enkel hulpmiddel of markt; het is bedoeld om de volledige infrastructuur te worden die een gedecentraliseerde AI-economie ondersteunt. De kernmissie is om de driedubbele dilemma van “onduidelijke rechtenbevestiging, onevenwichtige verdeling en inefficiënte circulatie” in de AI-ontwikkeling aan te pakken.</p>
<p>In tegenstelling tot de meeste projecten die een <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> laag aan bestaande AI-tools, reconstructeert Sahara de eigendomsregels van slimme activa vanaf de protocollaag. In zijn ontwerp kunnen gegevens, modellen en agenten allemaal worden geregistreerd als on-chain activa, waardoor verifieerbare rechtenbevestiging, permissiebeheer en winstdelingsmechanismen mogelijk zijn.</p>
<p>“Sahara is niet zomaar een ander blockchainproject; het is een oproep tot systematische reflectie en collectieve actie,” benadrukte medeoprichter en CEO Sean Ren. “We hebben echte opbrengsten behaald en keren waarde direct terug naar de bijdragers.”</p>
<p>In augustus 2024 heeft het project $43 miljoen aan financiering veiliggesteld, geleid door Binance Labs en Pantera Capital, met een totaalbedrag aan latere financiering van $51,5 miljoen, wat voldoende munitie biedt voor de implementatie van de technologie.</p>
<h2 id="h2-Technische20Architectuur20en20Product20Ecosysteem20Een20Gesloten20Cirkel20Systeem20van20Gegevens20naar20Model543750"><a name="Technische Architectuur en Product Ecosysteem: Een Gesloten Cirkel Systeem van Gegevens naar Model" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technische Architectuur en Product Ecosysteem: Een Gesloten Cirkel Systeem van Gegevens naar Model</h2><p>De architectuur van Sahara is verdeeld in twee lagen: een zelfontwikkelde EVM-compatibele Layer 1 blockchain die verantwoordelijk is voor assetregistratie en transactieafhandeling; een off-chain AI-uitvoeringsprotocol genereert verifieerbare uitvoeringsbewijzen via een Trusted Execution Environment (TEE), wat zorgt voor transparantie in het proces.</p>
<p>Deze architectuur ondersteunt vier kernproducten die de hele levenscyclus van AI dekken:</p>
<ul>
<li>Gegevensserviceplatform (DSP): Gebruikers dragen bij door gegevensannotatie om on-chain incentives te verdienen. Het taakvolume in het tweede kwartaal bereikte 2,55 miljoen invoer, met een verbetering van de nauwkeurigheid tot 95%, en introduceerde een “demigod level” soul-bound token (SBT) mechanisme om kwaliteitsbijdragers te belonen.</li><li>AI-ontwikkelaarsplatform (Sahara Studio): Lancering in Q2 2025, het integreert modeltraining, implementatie en workflowbeheer tools, wat de ontwikkelingsdrempel aanzienlijk verlaagt.</li><li>AI Handelsmarktplaats: Gepland voor lancering in Q3/Q4 2025, ondersteunt gedecentraliseerde handel en licentieverlening van datasets, modellen en agenten, activeert activacirculatie.</li><li>Kennis Intelligente Agenten (KAs): Inzetbare autonome AI-toepassingen die ecologische terminalen vormen.</li></ul>
<h2 id="h2-Laatste20Update20Mainnet20Aftelling20en20Token20Lancering192865"><a name="Laatste Update: Mainnet Aftelling en Token Lancering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laatste Update: Mainnet Aftelling en Token Lancering</h2><p>Volgens de roadmap die door Sahara AI is vrijgegeven voor 2024 - 2025, wijzen de belangrijkste mijlpalen duidelijk op de lancering van de Mainnet:</p>
<ul>
<li>Q4 2024: Lanceer het testnet en het datadienstenplatform, start het gebruikersbeloningsprogramma.</li><li>Q1 2025: Lancering van de vroege toegang tot de AI-marktplaats</li><li>Q2 2025: Lancering van Sahara Studio Toolkit</li><li>Q3 2025: Sahara Chain Mainnet lancering, ondersteuning van gegevens- en modelactiva handel.</li></ul>
<p>Op 19 mei 2025 lanceerde Sahara het openbare testnet SIWA, dat voor het eerst de functie voor datasetregistratie en het minten van eigendomscertificaten opende, waarmee de ingang van het on-chain bevestigingssysteem in de fase van publieke verificatie werd gemarkeerd.</p>
<p>Op het token niveau zal SAHARA op 26 juni 2025 op meerdere beurzen worden genoteerd.</p>
<p>Deze communityverkoop was bijna 9 keer overtekend, met een initiële volledig verwaterde waardering (FDV) van $600 miljoen, wat sterke marktt vertrouwen in het project weerspiegelt.</p>
<h2 id="h2-Gegevens20van20gebruikers20en20samenwerking20binnen20het20ecosysteem20Groei20van20de20testnetvalidatie20vliegwiel242934"><a name="Gegevens van gebruikers en samenwerking binnen het ecosysteem: Groei van de testnetvalidatie vliegwiel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevens van gebruikers en samenwerking binnen het ecosysteem: Groei van de testnetvalidatie vliegwiel</h2><p>De SIWA testnetgegevens bevestigen het groeipotentieel van Sahara:</p>
<ul>
<li>Het totale aantal accounts is meer dan 3,2 miljoen, met meer dan 1,4 miljoen dagelijkse actieve gebruikers.</li><li>Het aantal deelnemers aan data-annotatie heeft de 200.000 overschreden, met een taakvolumevervulling van 2,55 miljoen in het tweede kwartaal.</li><li>De nauwkeurigheid van de gegevens is verbeterd van 92% in het eerste kwartaal naar 95% in het tweede kwartaal.</li></ul>
<p>Ecologische samenwerking breidt zich synchronisch uit, met de introductie van meer dan 40 partners, waaronder AWS, Google Cloud, UC Berkeley en Together AI, die de velden van cloud computing, open source protocollen en academisch onderzoek bestrijken. Dit vormt een technologisch synergetisch netwerk met eerdere partners zoals Microsoft, Amazon en MIT.</p>
<h2 id="h2-Toekomstige20Betekenis20Het20Startpunt20van20het20DeAI20Tijdperk265350"><a name="Toekomstige Betekenis: Het Startpunt van het De-AI Tijdperk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstige Betekenis: Het Startpunt van het De-AI Tijdperk</h2><p>Het uiteindelijke doel van Sahara is om het onderliggende besturingssysteem te worden dat AI en <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> integreert. De waarde is niet alleen zichtbaar in de verbetering van de tool efficiëntie, maar ook in het tot stand brengen van een gesloten economische cyclus van bevestiging van de rechten van bijdragers → activa circulatie → ontwikkelaarsinnovatie → gebruikersvoordelen.</p>
<p>Als het Mainnet volgens schema wordt gelanceerd in Q3 2025 en volledig functioneel is, zal Sahara drie kernproblemen aanpakken:</p>
<ol>
<li>Databijdragers zullen verifieerbare beloningen ontvangen.</li><li>Modelontwikkelaars zullen geactiveerde intellectuele eigendomsrechten hebben.</li><li>Ondernemingen zullen toegang hebben tot een compliant en transparante AI-leveringsketen.</li></ol>
<p>“We verwelkomen een meer open, eerlijke en duurzame era van AI-samenwerking,” zei Together AI CEO Vipul Ved Prakash, “Dit zal de nieuwe infrastructuur voor Web3 AI worden.”</p>
<p>Met de lancering van de Sahara Chain Mainnet in het derde kwartaal van 2025, krijgen wereldwijde ontwikkelaars voor het eerst toegang tot een full-stack AI-ontwikkelings- en activatialisatieplatform. Gegevenslabelaars, modeltrainers en agentontwikkelaars - elke deelnemer kan vertrouwen op on-chain protocollen om bevestiging van bijdrage-rechten en waarde retouren te bereiken.</p>
<p>Terwijl de traditionele AI-economie nog steeds wordt gemonopoliseerd door technologie-giganten, bouwt Sahara een gedecentraliseerde snelweg van data naar modellen. Op deze weg zijn bijdragen rechten, is intelligentie een activa, en samenwerking brengt winst.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hiervan vormt geen aanbod, verzoek of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van (een deel van) de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <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>