Z2F0ZUxpdmUgQU1BIFJlY2FwLUFnb3JhSHVi

<p><img src="https://gimg2.gateimg.com/image/article/1718950252aga.png" alt=""></p>
<h2 id="h2-Q120Wat20is20jouw20rol20in20het20Agora20project20Jouw20achtergrond20en20hoe20ben20je20Agora20gaan20leiden577034"><a name="Q1. Wat is jouw rol in het Agora project? Jouw achtergrond en hoe ben je Agora gaan leiden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1. Wat is jouw rol in het Agora project? Jouw achtergrond en hoe ben je Agora gaan leiden?</h2><p>Ik ben medeoprichter en CEO van Agora, een joint venture die 2 jaar geleden is opgericht tussen Swissborg, de eerste crypto wealth app in Europa met meer dan 800.000 actieve gebruikers, en Ultra, een top-tier blockchain gaming platform.</p>
<p>Persoonlijk ben ik al meer dan 12 jaar een ondernemer met vaardigheden op het gebied van bedrijfsmanagement, verkoop &amp; marketingstrategieën. Sinds 2018 ben ik zeer betrokken geweest bij crypto.</p>
<p>Eerst was ik 2 jaar lang hoofd van digitale activa voor een familiekantoor en daarna was ik verantwoordelijk voor de ontwikkeling van een OTC-desk. In 2021 ben ik lid geworden van het Swissborg-team om hun bedrijfsafdeling te ontwikkelen, na een grote interesse in financiële instellingen met fondsen en familiekantoren.</p>
<p>Voor de oprichting van Agora in 2022, een joint venture waarvan ik een trotse CEO ben en die al bijna 18 maanden met passie leidt, gemotiveerd door het engagement van onze gemeenschap.</p>
<h2 id="h2-Q220Kun20je20ons20een20korte20samenvatting20geven20van20wat20je20team20aan20het20bouwen20is20en20wat20je20wilt20bereiken164619"><a name="Q2. Kun je ons een korte samenvatting geven van wat je team aan het bouwen is en wat je wilt bereiken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2. Kun je ons een korte samenvatting geven van wat je team aan het bouwen is en wat je wilt bereiken?</h2><p>Onze visie is om de meest veelbelovende GameFi-projecten te verbinden met gamers en investeerders, en massale adoptie van blockchain-gaming te bereiken. Om te slagen bouwen we een GameFi Hub met 3 kernproducten. Een DEX, een digitaal identiteit en een Gedecentraliseerd Loot Box Systeem. Twee daarvan zijn al ontwikkeld.</p>
<p>De eerste is onze DEX met gaming-gerelateerde tokens ontwikkeld op het Ultra blockchain en stelt 0 gasvergoedingen voor gamers voor. Dat lost een van de grootste uitdagingen in deze branche op, omdat op EVM-ketens de gasvergoedingen te hoog zijn en de uitbetaling beïnvloeden.</p>
<p>De DEX is getest door de gemeenschap. We hebben zojuist de controle afgerond en we zijn van plan om deze kort na de IDO in april te lanceren. De V2 zal volledig cross-chain zijn om tegen het einde van het jaar meer liquiditeit van EVM-ketens te brengen. Om de DEX te voeden, meer TVL binnen te halen en massale adoptie van blockchain-gaming te bereiken, ontwikkelen we een DIGITALE IDENTITEIT die klaar moet zijn in Q4.</p>
<p>Hoe werkt het?</p>
<p>Aan de gamerskant is het een gamified cross-chain wallet om de tokenbeloningen te verzamelen die je verdient door te spelen of je NFT’s in één unieke wallet, waarna je het rechtstreeks kunt ruilen via de interface van het spel zonder een DAPP te gebruiken, zoals gate. <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>. Het lost andere uitdagingen op omdat DEFI nog steeds een complex onderwerp is dat moeilijk te begrijpen is voor veel gamers.</p>
<p>-Aan de games kant is het een SDK die zeer goed gedocumenteerd en gemakkelijk in je spel te integreren is. Een brug tussen onze DEX waar ze een pool van liquiditeit (beloningen in tokens / stabiele munten) gaan creëren en de games.<br>Het is een nieuwe bron van inkomsten voor het spel, beschouwd als een LP omdat games altijd een transactie doen via de interface van het spel die liquiditeit in de pool zal brengen.</p>
<p>En tot slot ons laatste kernproduct: het DLS dat we 6 maanden geleden hebben gelanceerd.<br>Het is een lanceringplatform dat volledig cross-chain is en Gamefied, waarmee elk web3-project gebruikersacquisitie, gebruikersbehoud en natuurlijk inkomsten kan genereren door hun tokens of NFT’s te distribueren via onze Loot Box. Ons product is al ingezet op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Arbitrum, BSC en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> en we hebben het net aangekondigd op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> too.</p>
<p>Onze lootbox biedt drie niveaus van zeldzaamheid, drie edelstenen (magisch, episch en legendarisch) om NFT’s of tokens te verspreiden van onze sponsor, Bovendien hebben we een dynamisch jackpot systeem geïmplementeerd (gelijk aan 15% van de omzet gegenereerd door de verkochte lootboxen) toegankelijk voor degenen die 3 gouden tickets hebben verzameld. Gouden tickets worden ontvangen wanneer een lootbox geen edelstenen bevat, dus u verliest eigenlijk nooit echt aan ons systeem. Het is een functie die geliefd is bij de gemeenschap in de vorige editie.</p>
<p>We hebben de tijd genomen om verschillende visuals en animaties te maken om een speelse en plezierige gebruikerservaring te garanderen. Het is zowel visueel aantrekkelijk als dynamisch.</p>
<h2 id="h2-V320Wat20kun20je20doen20met20de20AGAtoken20Hoe20zal20het20worden20gebruikt20op20Agoras20DEX20of20jouw20DLS20gedecentraliseerd20loot20boxsysteem905504"><a name="V3. Wat kun je doen met de $AGA-token? Hoe zal het worden gebruikt op Agora’s DEX of jouw DLS (gedecentraliseerd loot boxsysteem)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3. Wat kun je doen met de $AGA-token? Hoe zal het worden gebruikt op Agora’s DEX of jouw DLS (gedecentraliseerd loot boxsysteem)?</h2><p>AGA kan door onze gemeenschapsleden op verschillende manieren worden gebruikt om deel te nemen aan het bestuur van onze DAO en om een reeks voordelen te ontvangen. Het is dus een multi-token met speciale toepassingen voor elk kernproduct:</p>
<p>CROSS CHAIN DEX</p>
<ul>
<li>Staking → als je de AGA-token staked, verdien je een percentage van de protocolhandelskosten die in alle transacties worden berekend die plaatsvinden in de Agora DEX.</li><li>Liquidity Providers verdienen ook een percentage van de protocolhandelskosten die in alle transacties worden berekend die plaatsvinden in de Agora DEX.</li></ul>
<p>LOOT BOX</p>
<ul>
<li>Staken voor opbrengst: Zet je AGA-tokens vast en zie je digitale vermogen groeien. Profiteer van een deel van de opbrengsten van de lootbox als beloning voor je betrokkenheid.</li><li>Staken voor exclusiviteit: Verkrijg toegang tot limited edition Loot Boxes met premium, zeldzame collecties die niet beschikbaar zijn voor de gemiddelde gebruiker.</li><li>Korting op aankopen: Geniet van exclusieve kortingen op Loot Box-aankopen, waardoor elke transactie belonender wordt.</li><li>Governance-rechten: Heb invloed op de toekomst van Agora. Je belang in AGA-tokens betekent een belang in besluitvormingsprocessen.</li></ul>
<p>Alle hulpprogramma’s hebben nagedacht over het vermijden van verkoopdruk.</p>
<h2 id="h2-Q420Kun20je20een20korte20update20geven20over20de20belangrijkste20prestaties20en20routekaart20van20Agora20Hoe20is20het20gegaan20sinds20de20succesvolle20IDO20met20SwissBorg446347"><a name="Q4. Kun je een korte update geven over de belangrijkste prestaties en routekaart van Agora? Hoe is het gegaan sinds de succesvolle IDO met SwissBorg?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4. Kun je een korte update geven over de belangrijkste prestaties en routekaart van Agora? Hoe is het gegaan sinds de succesvolle IDO met SwissBorg?</h2><p>BELANGRIJKSTE PUNTEN</p>
<ul>
<li>Beveiligde toonaangevende partnerschappen met <a href="/price/swissborg-chsb" rel="nofollow noopener noreferrer" target="_blank">SwissBorg</a> en Ultra.</li><li>Ontving een subsidie van $ 500K van hen.</li><li>Twee NFT-collecties met in totaal meer dan 2000 items uitverkocht in minder dan 24 uur, waarmee in totaal $ 430K werd opgehaald.</li><li>$ 530K opgehaald bij particuliere investeerders om onze seed-ronde van $ 1 miljoen af te sluiten.</li><li>Aan boord van meer dan 30 games en projecten binnen het ecosysteem.</li><li>Onze community hebben we laten groeien tot een totaal volgersbestand van 110K via onze belangrijkste communicatiekanalen om ons momentum op gang te brengen richting de lancering van $AGA.</li><li>Voltooi onze cross-chain bridge en onze eerste gecontroleerde DEX die klaar is om te worden gelanceerd.</li><li>Gedecentraliseerd Loot Box-systeem gelanceerd met 4 projecten. We waren binnen enkele minuten uitverkocht en verdeelden meer dan $ 100.000 aan prijzen tijdens ons beste Loot Box-evenement tot nu toe, net voor onze alfa-deal met SwissBorg.</li><li>We hebben onze <a href="/price/swissborg-chsb" target="_blank" class="blog_inner_link">SwissBorg</a> Alpha Opportunity in SECONDEN uitverkocht! $ 1 miljoen opgehaald bij onze communityleden, waardoor ze voor het eerst liquiditeitsverschaffers positioneren voor de IDO van $AGA, wat betekent dat het onze community is die $AGA on-chain stimuleert!</li><li>We hebben een samenwerkingsovereenkomst gesloten met de top market maker: Kairon Lab</li><li>We hebben Agora uitgebreid tot omni-chain door onze succesvolle Loot Boxes ook op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> te lanceren! Agora en $AGA zijn nu gepositioneerd om waarde te halen uit de twee belangrijkste en meest opwindende ecoen op Web3.</li><li>We hebben onze positionering een nieuwe naam gegeven en verenigd met de oprichting van agorahub.io - ‘s werelds nieuwe toegangspunt tot het Agora-ecosysteem.</li></ul>
<p>OVER WAT ER NU GAAT KOMEN</p>
<ul>
<li>Na Gate.io en MEXC komen er meer CEX, met Swissborg en Bitpanda.</li><li>De lancering van de DEX komt een paar weken later op Ultra. We werken met hen samen aan een Go To Market-strategie die we binnenkort zullen aankondigen om evenveel als TVL voor dag 1 te garanderen. Met gegarandeerde TVL van onze strategische partners ULTRA.</li><li>De integratie van het Solana-ecosysteem betekent een strategische sprong voorwaarts voor Agora, vooral gezien onze voortdurende samenwerking met SwissBorg. SwissBorg’s recente integratie van de Solana-blockchain in hun Smart Engine sluit naadloos aan bij de uitgebreide visie van Agora, die groei en innovatie binnen het GameFi-landschap stimuleert. Deze samenwerking verbetert niet alleen de efficiëntie en schaalbaarheid van ons platform, maar positioneert ons ook in de voorhoede van de snel evoluerende blockchain-gamingindustrie.</li><li>Wij zijn van mening dat Solana een uniek voordeel op het gebied van gebruikerservaring biedt in de branche, omdat het goedkoper, sneller en gemakkelijker te navigeren is dan het EVM-ecosysteem. Recente gegevens bewijzen dat het-Solana de meest gebruikte keten is in de afgelopen maanden.</li><li>Nieuwe Solana-projecten in onze Loot Boxes zullen nieuwe gebruikers aantrekken, de bekendheid van Agora vergroten en meer projecten aantrekken, die nog meer gebruikers zullen aantrekken…</li></ul>
<h2 id="h2-Vraag20520Waarom20zou20onze20gemeenschap20moeten20investeren20in20AGORA20voor20de20IDO20Kunt20u20uw20beleggingsthesis20geven364823"><a name="Vraag 5. Waarom zou onze gemeenschap moeten investeren in AGORA voor de IDO? Kunt u uw beleggingsthesis geven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 5. Waarom zou onze gemeenschap moeten investeren in AGORA voor de IDO? Kunt u uw beleggingsthesis geven?</h2><p>We zijn buitengewoon trots op alles wat we tot nu toe hebben bereikt en de waarden die we hebben gepromoot tijdens #AgoraArrival en de lancering van $AGA.</p>
<p>Met onze gemeenschap op de eerste plaats sturen we een krachtige boodschap naar de industrie over hoe dingen goed moeten worden aangepakt:</p>
<ul>
<li>Echte Producten: Onze Loot Boxes zijn uitverkochte evenementen, die miljoenen aan volume genereren.</li><li>Op elkaar afgestemde prikkels: Onze gemeenschap is onze market maker en liquiditeitsverschaffer, met prikkels en beloningen die rechtstreeks aan hen worden uitgekeerd.</li><li>Eerlijke prijsstelling: Onze TGE is ingesteld voor organische prijsvinding zonder kunstmatige inflatie van VCs en CEXs.</li><li>Toonaangevende vrije verhandeling: Met 25% ontgrendeld bij TGE &amp; 12 maanden totale vestiging hebben we de lancering van AGA ontworpen voor de beste omstandigheden in zijn klasse &amp; duurzame waardecreatie.</li></ul>
<p>De momentum groeit en we kunnen niet enthousiaster en dankbaarder zijn om u bij ons op deze reis te hebben!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>