R2F0ZS5pbyBBTUEgY29uIFhFTFMtQmxvY2tjaGFpbiBpbmNvbnRyYSBsZSBzb2x1emlvbmkgYmFzYXRlIHN1bGxhIG5hdHVyYSBuZWxsYSBsb3R0YSBjb250cm8gaWwgcmlzY2FsZGFtZW50byBnbG9iYWxl

<p><img src="https://gimg2.gateimg.com/image/article/1676364653123.jpeg" alt=""><br><strong>Orario: 26 settembre 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con il Direttore di XELS, Mitchell Hammer nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web ufficiale: <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>Seguire <a href="https://twitter.com/xels_PR" rel="nofollow noopener noreferrer" target="_blank">XELS</a> su Twitter e <a href="https://t.me/xelscoin" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><br><strong>Mitchell Hammer — Direttore di XELS</strong><br>Sono Mitch Hammer, Direttore presso XELS, una start-up giapponese che applica la tecnologia per aiutare le aziende a lasciare un’impronta positiva sul nostro pianeta. Ho più di 8 anni di esperienza professionale come consulente strategico, program manager, imprenditore e consulente ambientale. La mia esperienza include la definizione e la guida di cambiamenti e miglioramenti fondamentali nella strategia, nei processi e nella redditività, il lancio di nuove start-up, le strategie di go-to-market e la guida di team cross-funzionali in una vasta gamma di settori, tra cui blockchain, asset digitali, software enterprise, mercati del carbonio, progetti ambientali, e-commerce e governo.</p>
<h2 id="h2-QampA20da20Gateio859418"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Cos20XELS20Ci20sono20alcuni20progetti20che20tokenizzano20crediti20di20carbonio20cosa20ti20rende20diverso461062"><a name="Q1: Cos’è XELS? Ci sono alcuni progetti che tokenizzano crediti di carbonio, cosa ti rende diverso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è XELS? Ci sono alcuni progetti che tokenizzano crediti di carbonio, cosa ti rende diverso?</h3><p><strong>Mitch</strong>: Xels è una piattaforma di eco-tecnologia che rappresenta il futuro della divulgazione decentralizzata del clima per le aziende che cercano trasparenza nella loro relazione ambientale.<br><img src="https://gimg2.gateimg.com/image/article/1676365205321.png" alt=""><br>Xels consente alle aziende di produrre e mantenere registrazioni accurate basate su NFT delle loro attività di compensazione delle emissioni di carbonio, che sono certificate e tracciabili, offrendo anche soluzioni economiche per il mondo aziendale. Le aziende riconoscono che le emissioni di carbonio lungo la catena di approvvigionamento sono una parte critica della loro responsabilità sociale aziendale.</p>
<h3 id="h3-Q220Qual2020il20problema20che20XELS20sta20cercando20di20risolvere20che20gli20altri20non20possono772372"><a name="Q2: Qual è il problema che XELS sta cercando di risolvere che gli altri non possono?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Qual è il problema che XELS sta cercando di risolvere che gli altri non possono?</h3><p><strong>Mitch</strong>: L’assenza di trasparenza nella segnalazione dell’impronta di carbonio, così come le difficoltà nel tracciare le emissioni lungo la catena del valore, comporta la diffidenza dei clienti verso ciò che le aziende promettono e la mancanza di fiducia degli investitori nelle promesse.</p>
<p>Purtroppo, è esattamente dove ci troviamo oggi con il cambiamento climatico. Aziende come Microsoft, IKEA e Amazon stanno compiendo azioni che cambieranno il mondo sul cambiamento climatico. Ma i loro fornitori stanno davvero riducendo le proprie impronte di carbonio? I loro investitori sanno davvero quanto bene stiano funzionando i loro piani di riduzione del carbonio? La risposta a tutto ciò è no.<br><img src="https://gimg2.gateimg.com/image/article/1676365158231.png" alt=""><br>La soluzione basata su blockchain XELS consentirebbe all’industria di mantenere registri aperti e trasparenti - dalla generazione all’impegno aziendale per l’azione. Xels sarà in grado di fornire sia alle aziende che alle singole persone certificati ufficiali che possono essere utilizzati come prova delle loro iniziative di riduzione delle emissioni di carbonio, supportati da transazioni blockchain immutabili che possono essere visualizzate da chiunque.</p>
<h3 id="h3-Q320Perch2020questo20il20momento20giusto20per20XELS878489"><a name="Q3: Perché è questo il momento giusto per XELS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Perché è questo il momento giusto per XELS?</h3><p><strong>Mitch</strong> Con il mondo che inizia a prestare maggiore attenzione all’azione ESG delle aziende, la trasparenza e la responsabilità sono le cose più importanti.</p>
<p>Secondo la Banca Mondiale, l’umanità compensa solo il 22% delle emissioni globali attraverso l’acquisto e il ritiro dei crediti di carbonio, tuttavia la percentuale dei paesi che operano mercati carbonio regolamentati è passata dal 40% nel 2016 al 70% nel 2020.</p>
<p>Il risultato è un muro di domanda che potrebbe superare di gran lunga l’emissione di nuovi crediti di carbonio, limitata dal lento ed costoso processo di certificazione dei progetti di carbonio.</p>
<p>Poiché le frodi sono già un problema esistente, è importante che l’aumento della domanda di compensazioni di carbonio sia soddisfatto con una piattaforma migliore per proteggere quelle entità che vogliono fare la cosa giusta in primo luogo. La crisi climatica è terribile: purtroppo il “momento giusto” è già passato da tempo, ma speriamo che Xels aumenti la partecipazione e ci porti su un percorso migliore verso la neutralità carbonica.</p>
<h3 id="h3-Q420Perch20il20tuo20team2020in20una20posizione20migliore20per20risolvere20questo20problema20rispetto20agli20altri844171"><a name="Q4: Perché il tuo team è in una posizione migliore per risolvere questo problema rispetto agli altri?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Perché il tuo team è in una posizione migliore per risolvere questo problema rispetto agli altri?</h3><p><strong>Mitch</strong>: Abbiamo impiegato molto tempo nel trovare le persone giuste e farle arrivare a Tokyo il più possibile, fortunatamente prima che colpisse Covid. Le startup giapponesi tendono ad essere piuttosto omogenee, ma siamo orgogliosi della nostra diversità.</p>
<p>Attualmente abbiamo membri del team provenienti da sette paesi che parlano più di 10 lingue. Il nostro direttore tecnico ha ottenuto un dottorato di ricerca in Blockchain presso l’Università di Memphis, abbiamo consulenti provenienti da alcune delle più grandi aziende tecnologiche nazionali e internazionali, e abbiamo costruito s <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> stabilire relazioni con i governi giapponesi e regionali.</p>
<h3 id="h3-Q520Puoi20ora20parlarci20di20quanto20sia20grande20questa20opportunit20di20mercato902919"><a name="Q5: Puoi ora parlarci di quanto sia grande questa opportunità di mercato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Puoi ora parlarci di quanto sia grande questa opportunità di mercato?</h3><p><strong>Mitch</strong>: Certamente, è davvero molto interessante perché lo spazio ESG è esploso nell’ultimo anno. È diventato uno spazio molto interessante.</p>
<p>Il nostro focus iniziale è sulle aziende giapponesi che cercano di diventare neutre dal punto di vista del carbonio. Le iniziative giapponesi per l’energia pulita sono indietro di circa il 50% rispetto a quelle del Regno Unito, quindi il potenziale è enorme. Sosteniamo l’obiettivo dell’ex primo ministro Yoshihide Suga di raggiungere emissioni nette zero entro il 2050, cosa che tutte le grandi aziende giapponesi vorranno adottare, altrimenti si troveranno di fronte a reazioni negative da parte del governo e dei consumatori.</p>
<p>Due terzi delle aziende che abbiamo informato hanno un obiettivo di riduzione delle emissioni a lungo termine o lo avranno entro la fine di quest’anno. Un modesto obiettivo di compensazione delle emissioni di carbonio di 200.000 tonnellate all’anno equivale a circa 2 milioni di dollari di investimento per azienda - e solo il Giappone ha oltre 3.700 aziende quotate alla Borsa di Tokyo.</p>
<p>La pressione da parte degli stakeholder - sia dai consumatori che dagli investitori - sarà il principale motore dell’azione di riduzione delle emissioni di carbonio e Xels è pronto a sostenere qualsiasi azienda o individuo che desideri diventare sostenibile.</p>
<h3 id="h3-Q720Chi2020il20tuo20cliente20target590327"><a name="Q7: Chi è il tuo cliente target?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Chi è il tuo cliente target?</h3><p><strong>Mitch</strong> Chiunque può partecipare all’offsetting di carbonio, dalle singole persone alle più grandi società globali. L’offsetting di carbonio è ora un obiettivo importante per aziende come Amazon, Microsoft e Nike, che non sono più interessate ad aspettare che i governi prendano il controllo. Si sono impegnati a neutralizzare la loro attuale impronta di carbonio, o addirittura l’intera impronta storica, per loro iniziativa.</p>
<p>Rendere facile per le aziende compensare in modo trasparente le proprie emissioni di carbonio senza timore di frodi le renderà ancora più disposte a entrare in gioco. E naturalmente, anche le persone comuni che vogliono compensare la propria impronta di carbonio possono partecipare. La piattaforma è aperta a tutti.</p>
<h3 id="h3-Q820Qual2020il20tuo20modello20di20revenue404921"><a name="Q8: Qual è il tuo modello di revenue?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Qual è il tuo modello di revenue?</h3><p><strong>Mitch</strong>: Per ogni transazione che avviene sulla nostra piattaforma, Xels prende una piccola commissione. Come già detto, siamo in discussioni avanzate con cinque grandi aziende quotate qui in Giappone che sono interessate a utilizzare Xels per compensare volontariamente le proprie impronte di carbonio, anche se non è richiesto dal governo.<br><img src="https://gimg2.gateimg.com/image/article/1676365182213.png" alt=""><br>Uno di loro ha espressamente espresso l’intenzione di compensare 200.000 tonnellate di CO2 all’anno, equivalente a oltre 43.000 auto guidate per un anno.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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 re-post dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>