UmllcGlsb2dvIEFNQSBkaSBnYXRlTGl2ZSAtIE1BUjMgQUk=

2024-01-26, 10:13

<p><img src="https://gimg2.gateimg.com/image/article/170626417420240126-181208.jpeg" alt=""></p>
<h2 id="h2-120Per20favore20presentati20e20raccontaci20un20po20del20tuo20ruolo20presso20Mar320AI290533"><a name="1. Per favore, presentati e raccontaci un po’ del tuo ruolo presso Mar3 AI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Per favore, presentati e raccontaci un po’ del tuo ruolo presso Mar3 AI?</h2><p><strong>Phoebe Grace (Responsabile Marketing di Mar3 AI):</strong><br>Sono Phoebe Grace - Sono Marketing Manager presso Mar3 AI. Grazie per avermi qui oggi! Sono davvero emozionato per questo AMA!</p>
<p>Mar3 è un leader AI SocialFi dApp in cui chiunque può fare amicizia e guadagnare in Web3.</p>
<p>Mi sono unito a Mar3 AI nel 2022. In quel momento, c’erano molte piattaforme di intelligenza artificiale in Web2, come ChatGPT o Midjourney, ma mancavano piattaforme di intelligenza artificiale per gli utenti di Web3.</p>
<h2 id="h2-220Per20favore20raccontaci20un20po20di20pi20sulla20tua20piattaforma20e20il20suo20punto20di20vendita20unico219025"><a name="2. Per favore, raccontaci un po’ di più sulla tua piattaforma e il suo punto di vendita unico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Per favore, raccontaci un po’ di più sulla tua piattaforma e il suo punto di vendita unico?</h2><p><strong>Phoebe Grace (Responsabile Marketing di Mar3 AI):</strong><br>Mar3 AI come già sapete, è il principale AI SocialFi dApp in cui chiunque può fare amicizia e ottenere profitti nel mondo web3. Abbiamo combinato l’Intelligenza Artificiale e la Finanza Sociale per creare un ecosistema innovativo.</p>
<p>Mar3 AI si ispira a una famosa piattaforma socialFi chiamata FriendTech. FriendTech si basa su Base chain, e Mar3 AI è attiva su <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> catena. E ora siamo la principale applicazione AI e SocialFi di tendenza su <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> chain e Magic Store.</p>
<p>La nostra piattaforma offre strumenti avanzati come il generatore AI NFT, il chatbot AI GPT, il generatore di testo AI, il post social AI, Crea/partecipa a una chat di gruppo e Task per guadagnare. Puoi deloy NFT sulla blockchain utilizzando il nostro strumento AI in soli un minuto e pubblicarlo sulla nostra piattaforma social.</p>
<p>In soli 3 mesi, la nostra piattaforma ha guadagnato 150.000 utenti attivi, oltre 200.000 transazioni e 20.000 installazioni di app su Android e iOS.</p>
<p>Oltre a ciò, abbiamo permesso ad altri progetti <a href="/web3" target="_blank" class="blog_inner_link">web3</a> di creare collezioni NFT o campagne di marketing utilizzando il nostro generatore AI NFT e il task per guadagnare piattaforma - questa è una caratteristica unica che solo Mar3 AI possiede.</p>
<p>E ultimo ma non meno importante, apriamo il codice sorgente e il nostro token nativo è stato sottoposto a verifica da Verichains, una famosa azienda di revisione nello spazio. Quindi credo che questi siano i punti chiave principali su Mar3 AI.</p>
<h2 id="h2-320Potresti20parlare20un20po20del20tuo20team20dei20progetti20partner20e20dei20sostenitori133704"><a name="3. Potresti parlare un po’ del tuo team, dei progetti partner e dei sostenitori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Potresti parlare un po’ del tuo team, dei progetti partner e dei sostenitori?</h2><p><strong>Phoebe Grace (Responsabile Marketing di Mar3 AI):</strong><br>Il nostro team ha sede a Singapore. Onestamente, abbiamo un team di sviluppatori forte, siamo bravi nello sviluppo del prodotto. Sono orgoglioso di dirlo.</p>
<p>Il nostro CTO - il signor Louis ha 10 anni di esperienza nella tecnologia e 5 anni di intelligenza artificiale. Ecco perché siamo tra i primi 4 dApp di intelligenza artificiale sulla catena BNB e abbiamo ricevuto il premio catalizzatore di BNB.</p>
<p>Il nostro progetto ha anche forti sostenitori e una profonda collaborazione con oltre 40 progetti nell’ecosistema BNB, come BNB chain, BSCS, NFP, Dechat, Dmail, Magic Square e Space ID.</p>
<p>Facciamo cross-marketing creando una collezione di NFT utilizzando i nostri strumenti AI e consentiamo all’utente di svolgere attività, ottenere NFT gratuiti e ricevere ricompense. In questo modo possiamo supportare tutti i progetti web3 per realizzare campagne di marketing sulla nostra piattaforma, sicuramente</p>
<h2 id="h2-420Per20favore20raccontaci20un20po20di20token20MAR320La20sua20utilit20tokenomics20e20perch20dovremmo20tenerlo812762"><a name="4. Per favore, raccontaci un po’ di token MAR3. La sua utilità, tokenomics e perché dovremmo tenerlo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Per favore, raccontaci un po’ di token MAR3. La sua utilità, tokenomics e perché dovremmo tenerlo?</h2><p><strong>Phoebe Grace (Responsabile Marketing di Mar3 AI):</strong><br>Innanzitutto, il token Mar3 è il token nativo del nostro ecosistema e ha diversi utilizzi diversi.</p>
<p>Il primo caso d’uso del token Mar3 è la governance. I detentori del token possono partecipare alla presa di decisioni decentralizzata nel Mar3 DAO. Poiché siamo un progetto web3, lo renderemo molto più decentralizzato.</p>
<p>Quindi puoi utilizzare il token Mar3 per accedere a Mar3 AI e sbloccare ulteriori funzionalità premium come l’utilizzo di strumenti AI, l’utilizzo dei social media e giocare a giochi sulla nostra piattaforma. Puoi anche utilizzare il nostro token per fare donazioni ai tuoi KOL o influencer. Questo è il secondo caso d’uso.</p>
<p>Il prossimo caso d’uso è lo staking. Guadagnerai più ricompense facendo lo staking del token Mar3 e avrai la possibilità di ottenere il WL per la collezione NFT dei nostri giochi sociali in un prossimo futuro. E lanceremo il programma di staking dopo l’IDO.</p>
<p>E ultimo ma non meno importante, il token Mar3 viene utilizzato come principale ricompensa per incentivare gli utenti che contribuiscono alla nostra piattaforma. E tutto</p>
<h2 id="h2-520Puoi20condividere20di20pi20sui20tuoi20piani20e20sulla20roadmap197890"><a name="5. Puoi condividere di più sui tuoi piani e sulla roadmap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>5. Puoi condividere di più sui tuoi piani e sulla roadmap?</h2><p><strong>Phoebe Grace (Marketing Manager di Mar3 AI):</strong><br>In questo mese, abbiamo un piano per lanciare il nostro primo gioco sociale chiamato Virtual Pets, che permette agli utenti di giocare, fare amicizia e guadagnare profitti sulla nostra piattaforma.</p>
<p>Governance e processo decisionale: saremo un token di governance, dando agli utenti voce nel processo decisionale e garantendo un ecosistema equo e trasparente.</p>
<p>Collaborazioni e partnership: Mar3 cercherà collaborazioni e partnership con altri progetti e organizzazioni per espandere il proprio raggio d’azione e far crescere il proprio ecosistema.</p>
<p>Formazione e crescita della comunità: Mar3 fornirà risorse e supporto per aiutare gli utenti a comprendere le capacità e il potenziale della piattaforma, promuovendo una cultura di crescita e innovazione.</p>
<p>Concentrandosi su queste strategie, Mar3 mira a costruire un ecosistema sostenibile e prospero che attirerà e tratterrà nel tempo gli utenti, garantendo il successo a lungo termine della piattaforma.</p>
<div class="blog-details-info"><br><div>Autore:<strong> GateLive</strong>, Team Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<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, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>