R2F0ZS5pbyBBTUEgbWV0IFhFTFMtQmxvY2tjaGFpbiBvbnRtb2V0IG5hdHV1cmxpamtlIG9wbG9zc2luZ2VuIGluIGRlIHN0cmlqZCB0ZWdlbiBkZSBvcHdhcm1pbmcgdmFuIGRlIGFhcmRl

<p><img src="https://gimg2.gateimg.com/image/article/1676364653123.jpeg" alt=""><br><strong>Tijd: 26 september 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> heeft een AMA (Ask-Me-Anything) sessie gehouden met de Directeur van XELS, Mitchell Hammer in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Community</a>.</strong><br><strong>Officiële Website: <a href="https://www.xels.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.xels.io/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/xels_PR" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/xels_PR</a></strong></p>
<p><strong>Volgen <a href="https://twitter.com/xels_PR" rel="nofollow noopener noreferrer" target="_blank">XELS</a> op Twitter en <a href="https://t.me/xelscoin" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><br><strong>Mitchell Hammer - Directeur van XELS</strong><br>Ik ben Mitch Hammer, directeur bij XELS, een Japanse onderneming die technologie toepast om bedrijven te helpen een positieve stempel op onze planeet te drukken.<br>Ik heb meer dan 8 jaar professionele ervaring als strategisch adviseur, programmamanager, ondernemer en milieuadviseur. Mijn expertise omvat het definiëren en aansturen van fundamentele veranderingen en verbeteringen in strategie, proces en winstgevendheid, het lanceren van nieuwe ondernemingen, go-to-market-strategieën en het leiden van cross-functionele teams in een reeks sectoren, waaronder blockchain, digitale activa, bedrijfssoftware, koolstofmarkten, milieuprojecten, e-commerce en overheid.</p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio603055"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Wat20is20XELS20Er20zijn20een20paar20projecten20die20koolstofkredieten20tokeniseren20wat20maakt20jullie20anders738156"><a name="Q1: Wat is XELS? Er zijn een paar projecten die koolstofkredieten tokeniseren, wat maakt jullie anders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Wat is XELS? Er zijn een paar projecten die koolstofkredieten tokeniseren, wat maakt jullie anders?</h3><p><strong>Mitch</strong>: Xels is een Eco-technologieplatform dat de toekomst is van gedecentraliseerde klimaatrapportage voor bedrijven die transparantie zoeken in hun milieuverslaggeving.<br><img src="https://gimg2.gateimg.com/image/article/1676365205321.png" alt=""><br>Xels stelt bedrijven in staat om nauwkeurige NFT-gebaseerde gegevens van hun gecertificeerde en traceerbare CO2-compensatieactiviteiten te produceren en te onderhouden, evenals kosteneffectieve oplossingen te bieden voor de zakelijke wereld. Bedrijven erkennen dat CO2-uitstoot in de hele supply chain een kritisch onderdeel is van hun maatschappelijke verantwoordelijkheid.</p>
<h3 id="h3-Q220Welk20probleem20probeert20XELS20op20te20lossen20dat20anderen20niet20kunnen20oplossen128872"><a name="Q2: Welk probleem probeert XELS op te lossen dat anderen niet kunnen oplossen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Welk probleem probeert XELS op te lossen dat anderen niet kunnen oplossen?</h3><p><strong>Mitch</strong>: Het ontbreken van transparantie bij het rapporteren van de CO2-voetafdruk, evenals moeilijkheden bij het volgen van emissies in de waardeketen, leidt tot wantrouwen bij klanten in wat bedrijven beloven en een gebrek aan vertrouwen van investeerders in toezeggingen.</p>
<p>Helaas is dat precies waar we vandaag staan met klimaatverandering. Bedrijven als Microsoft, IKEA en Amazon ondernemen wereldveranderende acties op het gebied van klimaatverandering. Maar volgen hun leveranciers dit door het verminderen van hun koolstofvoetafdruk? Weten hun investeerders echt hoe goed hun plannen voor koolstofreductie werken? Het antwoord op al deze vragen is nee.<br><img src="https://gimg2.gateimg.com/image/article/1676365158231.png" alt=""><br>De op blockchain gebaseerde oplossing van XELS zou de industrie in staat stellen om open, transparante records te behouden - van generatie tot bedrijfsinzet voor actie. XELS zal zowel bedrijven als individuen officiële certificaten kunnen verstrekken die kunnen worden gebruikt als bewijs van hun initiatieven voor koolstofvermindering, ondersteund door onveranderlijke blockchain-transacties die door iedereen kunnen worden bekeken.</p>
<h3 id="h3-Q320Waarom20is20dit20het20juiste20moment20voor20XELS918108"><a name="Q3: Waarom is dit het juiste moment voor XELS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Waarom is dit het juiste moment voor XELS?</h3><p><strong>Mitch</strong> Met de wereld die steeds meer aandacht besteedt aan ESG-acties van bedrijven, zijn transparantie en verantwoordelijkheid de belangrijkste zaken.</p>
<p>Volgens de Wereldbank compenseert de mensheid slechts 22% van de wereldwijde emissies door de aankoop en annulering van koolstofkredieten, maar het aandeel van landen die gereguleerde koolstofmarkten exploiteren is gestegen van 40% in 2016 tot 70% in 2020.</p>
<p>Het resultaat is een muur van vraag die mogelijk ver uitstijgt boven de uitgifte van nieuwe koolstofkredieten, die wordt beperkt door het trage en dure proces van certificering van koolstofprojecten.</p>
<p>Aangezien fraude al een bestaand probleem is, is het belangrijk dat de toenemende vraag naar koolstofcompensaties wordt beantwoord met een beter platform om die entiteiten te beschermen die vanaf het begin het juiste willen doen. De klimaatcrisis is ernstig - helaas is de ‘juiste tijd’ al lang voorbij, maar we hopen dat Xels deelname zal vergroten en ons op een beter pad naar koolstofneutraliteit zal brengen.</p>
<h3 id="h3-Q420Waarom20is20jouw20team20het20best20gepositioneerd20om20dit20probleem20op20te20lossen20ten20opzichte20van20anderen1206"><a name="Q4: Waarom is jouw team het best gepositioneerd om dit probleem op te lossen ten opzichte van anderen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Waarom is jouw team het best gepositioneerd om dit probleem op te lossen ten opzichte van anderen?</h3><p><strong>Mitch</strong>: We hebben veel tijd besteed aan het vinden van de juiste mensen en het naar Tokyo krijgen van zoveel mogelijk van hen, gelukkig voordat Covid toesloeg. Japanse startups neigen nogal homogeen te zijn, maar we zijn trots op onze diversiteit.</p>
<p>We hebben momenteel teamleden uit zeven landen die meer dan 10 talen spreken. Onze technisch directeur heeft een PhD in Blockchain behaald aan de University of Memphis, we hebben adviseurs van enkele van de grootste binnenlandse en internationale techbedrijven, en we hebben een s <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> het opbouwen van relaties met de Japanse en regionale overheden.</p>
<h3 id="h3-V520Kunt20u20nu20met20ons20praten20over20hoe20groot20deze20marktkans20is18686"><a name="V5: Kunt u nu met ons praten over hoe groot deze marktkans is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: Kunt u nu met ons praten over hoe groot deze marktkans is?</h3><p><strong>Mitch</strong>: Zeker, Het is echt heel interessant omdat de ESG-ruimte het afgelopen jaar is geëxplodeerd. Het is een zeer interessante ruimte geworden.</p>
<p>Onze initiële focus ligt op Japanse bedrijven die klimaatneutraal willen worden. Japanse initiatieven op het gebied van schone energie lopen 50% achter op die van het Verenigd Koninkrijk, dus het potentieel is enorm. We ondersteunen het doel van voormalig premier Yoshihide Suga om tegen 2050 netto nul uitstoot te bereiken, iets waar alle grote Japanse bedrijven aan boord willen gaan, anders lopen ze het risico op tegenwind van de overheid en consumenten.</p>
<p>Twee derde van de bedrijven die we hebben ingelicht, heeft een langetermijndoelstelling voor emissiereductie of zal er een hebben tegen het einde van dit jaar. Een bescheiden doelstelling voor koolstofcompensatie van 200.000 ton per jaar komt overeen met ongeveer US$2 miljoen aan investeringen per bedrijf - en alleen al in Japan staan er meer dan 3.700 bedrijven genoteerd aan de Tokyo Stock Exchange.</p>
<p>Druk van belanghebbenden - zowel consumenten als investeerders - zal de belangrijkste drijfveer zijn voor actie ter vermindering van koolstof, en Xels staat klaar om elk bedrijf of individu te ondersteunen dat groen wil gaan.</p>
<h3 id="h3-Q720Wie20is20uw20doelklant954388"><a name="Q7: Wie is uw doelklant?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Wie is uw doelklant?</h3><p><strong>Mitch</strong>: Iedereen kan betrokken raken bij het compenseren van koolstof, van individuen tot de grootste wereldwijde bedrijven. Koolstofcompensatie is nu een belangrijk doel van bedrijven zoals Amazon, Microsoft en Nike, die niet langer geïnteresseerd zijn in het wachten op de overheid om het voortouw te nemen. Ze hebben zich ten doel gesteld om hun huidige koolstofvoetafdruk, of zelfs hun hele historische voetafdruk, op eigen initiatief te neutraliseren.</p>
<p>Het gemakkelijker maken voor bedrijven om op transparante wijze hun koolstofemissies te compenseren zonder angst voor fraude zal hen nog bereidwilliger maken om de strijd aan te gaan. En natuurlijk kunnen ook gewone mensen die hun koolstofvoetafdruk willen compenseren, betrokken raken. Het platform staat open voor iedereen.</p>
<h3 id="h3-Vraag20820Wat20is20uw20verdienmodel168873"><a name="Vraag 8: Wat is uw verdienmodel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 8: Wat is uw verdienmodel?</h3><p><strong>Mitch</strong>: Voor elke transactie die plaatsvindt op ons platform, neemt Xels een kleine commissie. Zoals vermeld, voeren we gevorderde besprekingen met vijf grote beursgenoteerde bedrijven hier in Japan die geïnteresseerd zijn in het gebruik van Xels om vrijwillig hun CO2-voetafdruk te compenseren, ook al is dit niet vereist door de overheid.<br><img src="https://gimg2.gateimg.com/image/article/1676365182213.png" alt=""><br>Een van hen heeft specifiek de intentie geuit om jaarlijks 200.000 ton CO2 te compenseren - dat komt overeen met meer dan 43.000 auto’s die een jaar lang worden gereden.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle gevallen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>