UmVjYXAgQU1BIGRhbCB2aXZvIGRpIEdhdGUtQWdvcmFIdWI=

<p><img src="https://gimg2.gateimg.com/image/article/1718950252aga.png" alt=""></p>
<h2 id="h2-Q120Qual2020il20tuo20ruolo20nel20progetto20Agora20La20tua20esperienza20e20come20sei20arrivato20a20guidare20Agora414086"><a name="Q1. Qual è il tuo ruolo nel progetto Agora? La tua esperienza e come sei arrivato a guidare Agora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1. Qual è il tuo ruolo nel progetto Agora? La tua esperienza e come sei arrivato a guidare Agora?</h2><p>Sono il co-fondatore e CEO di Agora, una joint venture creata 2 anni fa tra Swissborg, la prima app di criptovalute in Europa con oltre 800.000 utenti attivi e Ultra, una piattaforma di gioco blockchain di alto livello.</p>
<p>Personalmente, sono stato imprenditore per oltre 12 anni con competenze in gestione aziendale, strategie di vendita &amp; marketing. Sono stato molto coinvolto nel settore delle criptovalute dal 2018.</p>
<p>Inizialmente sono stato Capo degli Asset Digitali per un family office per 2 anni e poi mi sono occupato dello sviluppo di un desk OTC. Nel 2021 mi sono unito al team di <a href="/price/swissborg-chsb" target="_blank" class="blog_inner_link">Swissborg</a> per sviluppare la loro sezione aziendale, seguendo un forte interesse nelle istituzioni finanziarie con fondi e family office.</p>
<p>Prima di fondare Agora nel 2022, un’impresa congiunta di cui sono fiero CEO e che ha guidato con passione per quasi 18 mesi, motivata dall’impegno della nostra comunità.</p>
<h2 id="h2-Q220Ci20puoi20dare20una20breve20panoramica20su20cosa20sta20costruendo20il20tuo20team20e20cosa20vorresti20raggiungere538479"><a name="Q2. Ci puoi dare una breve panoramica su cosa sta costruendo il tuo team e cosa vorresti raggiungere?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2. Ci puoi dare una breve panoramica su cosa sta costruendo il tuo team e cosa vorresti raggiungere?</h2><p>La nostra visione è di connettere i progetti GameFi più promettenti con i giocatori e gli investitori e raggiungere l’adozione di massa dei giochi blockchain. Per avere successo, stiamo costruendo un GameFi Hub con 3 prodotti principali. Un DEX, un’identità digitale e un sistema di casse del bottino decentralizzato. Due di essi sono già sviluppati.</p>
<p>Il primo è il nostro DEX con token legati al gaming sviluppati sulla blockchain di Ultra e propone zero commissioni per i giocatori. Ciò risolve una delle sfide più grandi di questa industria perché sulle catene EVM le commissioni sono troppo alte e incidono sul pagamento.</p>
<p>Il DEX è stato testato dalla community. Abbiamo appena completato l’audit e pianifichiamo di lanciarlo subito dopo l’IDO ad aprile. La V2 sarà completamente cross chain per portare più liquidità dalle catene EVM alla fine dell’anno. Per alimentare il DEX, portare più TVL e raggiungere l’adozione di massa dei giochi blockchain, stiamo sviluppando un’IDENTITÀ DIGITALE che dovrebbe essere pronta nel Q4.</p>
<p>Come funziona?</p>
<p>-Dal punto di vista del giocatore, è un portafoglio cross chain gamificato per raccogliere le ricompense in token che guadagni giocando o i tuoi NFT in un portafoglio uniq, quindi puoi scambiarlo direttamente dall’interfaccia del gioco senza utilizzare una DAPP come <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>. Risolve altre sfide perché DEFI è ancora un argomento complesso che è difficile da capire per molti giocatori.</p>
<p>-Sul lato dei giochi è un SDK molto ben documentato e facile da integrare nel tuo gioco. Un ponte tra il nostro DEX dove creeranno il pool di liquidità (ricompense in token / monete stabili) e i giochi.<br>È una nuova fonte di ricavi per il gioco considerata come una LP perché ogni volta che i giochi effettuano una transazione tramite l’interfaccia del gioco, verrà spinta liquidità nel pool.</p>
<p>E infine il nostro ultimo prodotto principale: il DLS che abbiamo lanciato 6 mesi fa.<br>È una piattaforma di lancio completamente cross-chain e Gamefied che ogni progetto <a href="/web3" target="_blank" class="blog_inner_link">web3</a> può utilizzare per l’acquisizione di utenti, la fidelizzazione degli utenti e ovviamente generare ricavi distribuendo i loro token o NFT attraverso il nostro Loot Box. Il nostro prodotto è già stato implementato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Arbitrum, BSC e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> e l’abbiamo appena annunciato su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> anche.</p>
<p>La nostra scatola del bottino offre tre livelli di rarità, tre gemme (magica, epica e leggendaria) per distribuire NFT o token dal nostro sponsor,<br>Per completare il tutto, abbiamo implementato un sistema di jackpot dinamico (equivalente al 15% del ricavo generato dalle scatole del bottino vendute) accessibile a coloro che hanno accumulato 3 biglietti d’oro. I biglietti d’oro vengono ricevuti quando una scatola del bottino non contiene gemme, quindi alla fine non stai mai perdendo davvero nel nostro sistema. È una funzionalità amata dalla comunità nella precedente edizione.</p>
<p>Abbiamo dedicato del tempo a creare varie immagini e animazioni per garantire un’esperienza utente divertente e piacevole. È sia accattivante dal punto di vista visivo che dinamico.</p>
<h2 id="h2-Q320Cosa20puoi20fare20con20il20token20AGA20Come20verr20utilizzato20sul20DEX20di20Agora20o20sul20tuo20sistema20DLS20Decentralized20Loot20box20901678"><a name="Q3. Cosa puoi fare con il token $AGA? Come verrà utilizzato sul DEX di Agora o sul tuo sistema DLS (Decentralized Loot box )?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3. Cosa puoi fare con il token $AGA? Come verrà utilizzato sul DEX di Agora o sul tuo sistema DLS (Decentralized Loot box )?</h2><p>AGA può essere utilizzato dai membri della nostra comunità in modi diversi per partecipare alla governance del nostro DAO e ricevere una serie di vantaggi. Quindi, sono multi-token con utilità dedicate per ciascun prodotto principale:</p>
<p>CROSS CHAIN DEX</p>
<ul>
<li>Staking → se stai scommettendo il token AGA, guadagnerai una percentuale delle commissioni di trading del protocollo addebitate in tutte le transazioni che avvengono nell’Agora DEX.</li><li>Anche i fornitori di liquidità guadagneranno una percentuale delle commissioni di trading del protocollo addebitate in tutte le transazioni che avvengono nell’Agora DEX.</li></ul>
<p>LOOT BOX</p>
<ul>
<li>Staking per il rendimento: blocca i tuoi token AGA e guarda crescere la tua ricchezza digitale. Beneficia di una quota dei ricavi della loot box come ricompensa per il tuo impegno.</li><li>Staking per l’esclusività: ottieni accesso a loot box in edizione limitata con collezioni premium e rare non disponibili per l’utente medio.</li><li>Sconto sugli acquisti: goditi sconti esclusivi sull’acquisto di loot box, rendendo ogni transazione più gratificante.</li><li>Diritti di governance: hai una voce nel futuro di Agora. Il tuo investimento nei token AGA significa un investimento nei processi decisionali.</li></ul>
<p>Tutte queste utility hanno pensato di evitare la pressione delle vendite.</p>
<h2 id="h2-Q420Potresti20fornire20un20rapido20aggiornamento20sui20principali20successi20e20sulla20roadmap20di20Agora20Come20stanno20procedendo20le20cose20dopo20il20successo20dellIDO20con20SwissBorg79853"><a name="Q4. Potresti fornire un rapido aggiornamento sui principali successi e sulla roadmap di Agora? Come stanno procedendo le cose dopo il successo dell’IDO con SwissBorg?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4. Potresti fornire un rapido aggiornamento sui principali successi e sulla roadmap di Agora? Come stanno procedendo le cose dopo il successo dell’IDO con SwissBorg?</h2><p>PUNTI SALIENTI</p>
<ul>
<li>Partenariati di primo piano garantiti con <a href="/price/swissborg-chsb" rel="nofollow noopener noreferrer" target="_blank">SwissBorg</a> e Ultra.</li><li>Ricevuto una sovvenzione di $500K da loro.</li><li>Esaurite due collezioni NFT con un totale di oltre 2000 articoli in meno di 24 ore, raccogliendo un totale di $430K.</li><li>Raccolti $530K con investitori privati per chiudere il nostro round di finanziamento di $1M.</li><li>Onboardati oltre 30 giochi e progetti all’interno dell’ecosistema.</li><li>Cresciuta la nostra community fino a una base totale di follower di 110K attraverso i nostri principali canali di comunicazione per avviare il nostro slancio verso il lancio di $AGA.</li><li>Completato il nostro ponte cross-chain e il nostro primo DEX auditato pronto per essere lanciato.</li><li>Lanciato il sistema di Loot Box decentralizzato con 4 progetti. Abbiamo esaurito e distribuito oltre $100.000 in premi in pochi minuti durante il nostro miglior evento Loot Box fino ad oggi, proprio prima del nostro accordo alpha con SwissBorg.</li><li>Abbiamo esaurito la nostra Opportunità Alpha di SwissBorg in SECONDI! $1M raccolti dai membri della nostra community posizionandoli per la prima volta come fornitori di liquidità per l’IDO di $AGA, il che significa che è la nostra community a guidare $AGA on-chain!</li><li>Abbiamo stipulato un accordo di partnership con il principale market maker: Kairon Lab</li><li>Abbiamo ampliato Agora per essere omni-chain lanciando con successo le nostre Loot Boxes anche su Solana! Agora e $AGA sono ora posizionati per catturare valore dai due ecosistemi più importanti ed eccitanti su Web3.</li><li>Abbiamo rinnovato e unificato la nostra posizione con la creazione di agorahub.io - il nuovo punto di accesso al mondo dell’ecosistema di Agora.</li></ul>
<p>RIGUARDO A CIÒ CHE STA ARRIVANDO ORA</p>
<ul>
<li>Dopo Gate.io e MEXC, arriveranno altri CEX, con Swissborg e Bitpanda.</li><li>Il lancio del DEX avverrà qualche settimana dopo su Ultra. Stiamo lavorando con loro su una strategia di Go To Market che annunceremo presto per garantire il maggior TVL possibile per il giorno 1. Con TVL garantito dai nostri partner strategici ULTRA.</li><li>L’integrazione dell’ecosistema <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> rappresenta un salto strategico avanti per Agora, specialmente considerando la nostra collaborazione in corso con SwissBorg. L’incorporazione recente di SwissBorg della blockchain Solana nel loro Smart Engine si allinea perfettamente con la visione completa di Agora, guidando la crescita e l’innovazione all’interno del panorama GameFi. Questa collaborazione non solo migliora l’efficienza e la scalabilità della nostra piattaforma, ma ci posiziona anche al vertice dell’industria del gioco blockchain in rapida evoluzione.</li><li>Crediamo che Solana offra un vantaggio unico nell’esperienza utente nell’industria, essendo più economico, più veloce e più facile da navigare rispetto all’ecosistema EVM. I dati recenti lo dimostrano: Solana è stata la catena più utilizzata nei mesi scorsi.</li><li>I nuovi progetti Solana nelle nostre Loot Boxes attireranno nuovi utenti, aumentando la consapevolezza di Agora, attirando più progetti, che a loro volta attireranno ancora più utenti…</li></ul>
<h2 id="h2-Q520Perch20la20nostra20comunit20dovrebbe20investire20in20AGORA20per20lIDO20Potresti20fornire20la20tua20tesi20di20investimento333775"><a name="Q5. Perché la nostra comunità dovrebbe investire in AGORA per l’IDO? Potresti fornire la tua tesi di investimento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5. Perché la nostra comunità dovrebbe investire in AGORA per l’IDO? Potresti fornire la tua tesi di investimento?</h2><p>Siamo estremamente orgogliosi di tutto ciò che abbiamo finora raggiunto e dei valori che abbiamo promosso durante #AgoraArrival e il lancio di $AGA.</p>
<p>Mettendo la nostra comunità al primo posto, inviamo un messaggio forte all’industria su come fare le cose nel modo giusto:</p>
<ul>
<li>Prodotti reali: le nostre casse del tesoro sono eventi di vendita, generando milioni di volumi.</li><li>Incentivi allineati: la nostra comunità è il nostro market maker e fornitore di liquidità, con incentivi e premi distribuiti direttamente a loro.</li><li>Prezzi equi: il nostro TGE è fissato per una scoperta organica dei prezzi senza inflazione artificiale da parte di VC e CEX.</li><li>Float leader: con il 25% sbloccato al TGE &amp; 12 mesi di vesting totale, abbiamo progettato il lancio di AGA per condizioni di prima classe &amp; creazione di valore sostenibile.</li></ul>
<p>Il momento sta crescendo, e non potremmo essere più entusiasti e grati di averti con noi in questo viaggio!</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 il punto di vista del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ri-pubblicazione dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>