R2F0ZS5pbyBBTUEgY29uIERpbWl0cmEtQWdyaWNvbHR1cmEgYmFzYXRhIHN1aSBkYXRpLiBBdW1lbnRhcmUgaWwgcmVuZGltZW50by4gUmlkdXJyZSBpIGNvc3RpLiBNaXRpZ2FyZSBpbCByaXNjaGlv

<p><img src="https://gimg2.gateimg.com/image/article/16865500921.jpg" alt=""><br><strong>Ora: 5 gennaio 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 Jon Trask, CEO di Dimitra in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a></strong><br><strong>Sito ufficiale: <a href="https://dimitra.io/" rel="nofollow noopener noreferrer" target="_blank">https://dimitra.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/dimitratech" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/dimitratech</a></strong><br><strong>Segui Dimitra su <a href="https://twitter.com/dimitratech" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/dimitraofficialgroup" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16865503112.png" alt=""><br><strong>Jon Trask - CEO di Dimitra</strong></p>
<h2 id="h2-QampA20da20Gateio713771"><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-Q120Perch20non20ci20parli20un20po20di20Dimitra666232"><a name="Q1: Perché non ci parli un po’ di Dimitra?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Perché non ci parli un po’ di Dimitra?</h3><p><strong>Jon</strong>: Dimitra è un’azienda internazionale con la missione di fornire tecnologia agricola elegante e semplice (AgTech) a livello globale agli agricoltori tramite la blockchain.</p>
<p>Pensa a Dimitra come il sistema operativo per Ag-Tech e l’utilità del token DMTR guida il valore all’interno dell’ecosistema Dimitra. Dimitra ha membri del team in oltre 60 paesi e ci aspettiamo che questo numero raddoppi nel 2022.</p>
<p>In poche parole, siamo in una missione per aiutare la sicurezza alimentare, la tracciabilità alimentare, aumentare la sostenibilità alimentare e i metodi di agricoltura più sostenibili, e migliorare la vita dei piccoli agricoltori in tutto il mondo.</p>
<h3 id="h3-Q220Capito20E20quale20ruolo20svolge20DMTR20nella20piattaformaecosistema653060"><a name="Q2: Capito! E quale ruolo svolge $DMTR nella piattaforma/ecosistema?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Capito! E quale ruolo svolge $DMTR nella piattaforma/ecosistema?</h3><p><strong>Jon</strong>: Il token $DMTR è centrale alla nostra piattaforma ed ecosistema. Per favore, dai un’occhiata al nostro whitepaper <a href="https://dimitra.io/token" rel="nofollow noopener noreferrer" target="_blank">https://dimitra.io/token</a> e leggi il nostro articolo ‘Perché Dimitra’ qui: <a href="https://dimitratech.medium.com/why-dimitra-54bf7a662956" rel="nofollow noopener noreferrer" target="_blank">https://dimitratech.medium.com/why-dimitra-54bf7a662956</a></p>
<p>Ogni token agisce come catalizzatore per il nostro programma di punti agricoli, i nostri programmi di ecosistema, la nostra economia Dimitra e i nostri programmi di innovazione.</p>
<p>All’interno della piattaforma Dimitra abbiamo quello che chiamiamo il nostro programma “punti agricoli” che incentiva gli agricoltori a inserire i loro dati nella piattaforma Dimitra. Una volta inseriti i dati, vengono convertiti e i nostri algoritmi di apprendimento automatico forniscono informazioni utili agli agricoltori con suggerimenti pratici su come possono 1) migliorare le loro produzioni agricole, cioè produrre più cibo, 2) ridurre le spese (immagina di usare meno pesticidi o meno fertilizzante), e 3) mitigare il rischio (immagina di poter sapere in anticipo che arriverà un clima molto caldo per adattare ciò che fai ai tuoi raccolti o a ciò che pianti).</p>
<p>Un altro modo per immaginare la piattaforma Dimitra è che l’agricoltore utilizza la piattaforma Dimitra e all’agricoltore vengono dati punti Dimitra e poi a un certo livello soglia di punti quei punti possono essere convertiti in token Dimitra e poi l’agricoltore può acquistare servizi ecosistemici all’interno della piattaforma Dimitra come sensori o servizi satellitari, oppure l’agricoltore può scambiare i token Dimitra con altre criptovalute o convertirli nella loro valuta locale.</p>
<p>Il token DMTR gioca un ruolo chiave nella nostra piattaforma ed ecosistema.</p>
<h3 id="h3-Q320Quali20sono20stati20finora20alcuni20dei20maggiori20successi20di20Dimitra471106"><a name="Q3: Quali sono stati finora alcuni dei maggiori successi di Dimitra?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Quali sono stati finora alcuni dei maggiori successi di Dimitra?</h3><p><strong>Jon</strong>: Dimitra è stata elencata su Gate, Kucoin, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> e Bitmart.</p>
<p>In aggiunta a ciò, Dimitra ha vinto alcuni grandi contratti con l’Associazione dei Produttori di Frutta Brasiliana, che è la terza nazione più grande al mondo per la produzione di frutta, in India per 1,3 milioni di fattorie e 350.000 fattorie, in Bangladesh per 1 milione di fattorie, in Uganda e ci saranno ulteriori annunci nel 2022.</p>
<p>Ecco un elenco completo di ciò che abbiamo realizzato nel 2021 <a href="https://dimitratech.medium.com/dimitra-2021-year-end-recap-d7b44b6766d5" rel="nofollow noopener noreferrer" target="_blank">https://dimitratech.medium.com/dimitra-2021-year-end-recap-d7b44b6766d5</a> I nostri affari nazionali di solito sono molto grandi, quindi prevediamo di avere un grande impatto sulla comunità blockchain e sugli agricoltori e le comunità di tutto il mondo.</p>
<p>Oggi stiamo facendo un nuovo annuncio e abbiamo siglato 3 nuovi accordi per iniziare a lavorare in Nepal con oltre 400.000 agricoltori.<br><img src="https://gimg2.gateimg.com/image/article/16865503353.jpg" alt=""><br>Guardando indietro al 2021, sono molto grato per ciò che abbiamo raggiunto e nulla di tutto ciò sarebbe stato possibile senza l’aiuto del nostro incredibile team interno, dei nostri sviluppatori, dei nostri partner Ag e Crypto e, soprattutto, degli agricoltori di tutto il mondo e delle associazioni che lavorano con gli agricoltori.</p>
<h3 id="h3-Q420Ottimo20grazie20per20la20spiegazione20E20incoraggio20tutti20a20dare20unocchiata20al20riepilogo20di20fine20anno20di20Dimitra20Ora20potresti20dirci20qualcosa20in20pi20sul20tuo20piano20di20sviluppo20futuro20Cosa20speri20di20raggiungere20nel202022272856"><a name="Q4: Ottimo, grazie per la spiegazione. E incoraggio tutti a dare un’occhiata al riepilogo di fine anno di Dimitra. Ora, potresti dirci qualcosa in più sul tuo piano di sviluppo futuro? Cosa speri di raggiungere nel 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ottimo, grazie per la spiegazione. E incoraggio tutti a dare un’occhiata al riepilogo di fine anno di Dimitra. Ora, potresti dirci qualcosa in più sul tuo piano di sviluppo futuro? Cosa speri di raggiungere nel 2022?</h3><p><strong>Jon</strong>: Assolutamente! Dimitra ha grandi obiettivi e nel 2022, speriamo di avere accordi in atto con oltre 20 paesi, di avere il nostro modello SaaS attivo e di raddoppiare il nostro organico.</p>
<p>Nel prossimo quinquennio vogliamo che 100 milioni di agricoltori utilizzino la nostra piattaforma. Attualmente, il numero globale di portafogli crittografici è di circa 225 milioni, quindi immagina l’impatto che avrà Dimitra.</p>
<p>Continueremo a costruire, espandere le capacità della piattaforma Dimitra e fornire un valore reale agli agricoltori (il nostro obiettivo principale) e migliorare la vita delle persone in tutto il mondo. Dimitra sta costruendo una piattaforma ecosistema e una comunità mondiale che è la chiave del nostro successo e molti diversi set di competenze e obiettivi da raggiungere sono già in programma.</p>
<h3 id="h3-Q520Puoi20dirci20quali20sono20i20vantaggi20di20possedere20token20DMTR608490"><a name="Q5: Puoi dirci quali sono i vantaggi di possedere token $DMTR?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Puoi dirci quali sono i vantaggi di possedere token $DMTR?</h3><p><strong>Jon</strong>: Ci sono molti vantaggi.</p>
<p>Innanzitutto, l’agricoltura (uno dei settori più grandi al mondo) è in gran parte inesplorata per gli investitori di criptovalute e siamo davvero l’unica azienda che fa ciò che facciamo e adotta il nostro approccio di focalizzarci sugli agricoltori piccoli rispetto alle grandi aziende agricole industriali. La maggior parte delle persone non sa che la maggior parte del cibo in tutto il mondo è prodotto da piccole fattorie e nutre la maggior parte del pianeta.</p>
<p>Plus Ag-Tech è uno dei settori commerciali verticali più grandi al mondo dove tutti hanno bisogno di mangiare! Oltre 500 milioni di aziende agricole impiegano più di 3 miliardi di persone.<br><img src="https://gimg2.gateimg.com/image/article/16865503494.png" alt=""><br>Abbiamo un ottimo articolo che riassume alcune delle ragioni per cui un investitore considererebbe il token Dimitra: <a href="https://dimitratech.medium.com/why-dimitra-54bf7a662956" rel="nofollow noopener noreferrer" target="_blank">https://dimitratech.medium.com/why-dimitra-54bf7a662956</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità di 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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>