Z2F0ZSBJbnN0aXR1dGlvbmFsIEFNQSBTZXJpZXMgMjIgLSBNb29uYml0OiBEZWNvZGlmaWNhIGRlZ2xpIGludmVzdGltZW50aSBpbiBjcmlwdG92YWx1dGU=

<p><img src="https://gimg2.gateimg.com/image/1712547977363872737blog1.jpeg" alt=""><br><strong>Il Dipartimento Istituzionale di Gate ha ospitato una sessione Ask-Me-Anything con Alexander Thomsen, Fondatore di Moonbit.ai, sul canale YouTube di Gate Group: <a href="https://www.youtube.com/watch?v=UGNa51RY-wg&amp;list=PLE_x6o4N6eXY28rgJA0RRQLadTq-qDbrS&amp;index=11" rel="nofollow noopener noreferrer" target="_blank">https://www.youtube.com/watch?v=UGNa51RY-wg&amp;list=PLE_x6o4N6eXY28rgJA0RRQLadTq-qDbrS&amp;index=11</a>
</strong></p>
<p><strong>Segui Moonbit.ai sui social media</strong><br><strong>Sito web ufficiale: <a href="https://www.moonbit.ai/" rel="nofollow noopener noreferrer" target="_blank">https://www.moonbit.ai/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Moonbitai" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Moonbitai</a></strong><br><strong>Linkedin: <a href="https://www.Linkedin.com/company/moonbit/" rel="nofollow noopener noreferrer" target="_blank">https://www.Linkedin.com/company/moonbit/</a></strong><br><strong>Instagram: <a href="https://www.instagram.com/moonbit.ai/" rel="nofollow noopener noreferrer" target="_blank">https://www.instagram.com/moonbit.ai/</a></strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/1712547977642556024blog2.jpeg" alt=""><br>Alexander Thomsen, Fondatore di Moonbit.ai</p>
<p>Benvenuti al 22 ° episodio della nostra serie di AMA istituzionali di Gate con l’ospite speciale Alexander Thomsen, fondatore di Moonbit.ai. Tuffati nel mondo affascinante di Moonbit mentre Alexander svela il percorso della piattaforma, le strategie innovative e il futuro panorama degli investimenti in criptovalute. Scopri la formazione di Alexander, l’inizio di Moonbit e l’approccio distintivo che la piattaforma adotta per rivoluzionare la gestione degli asset nello spazio cripto. Ottieni una panoramica sulla semplicità di Moonbit, adatta ai principianti, ed esplora le sue caratteristiche uniche che la distinguono dalle altre piattaforme di investimento. Scopri come Moonbit abilmente mitiga i rischi durante le fluttuazioni di mercato e ottieni uno sguardo esclusivo sulla loro partnership dinamica con Gate.io. Non perderti i preziosi insegnamenti che riguardano piani di investimento intelligenti e la competenza cruciale di navigare sia i mercati al rialzo che al ribasso.</p>
<h2 id="h2-Introduzione302458"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p><strong>Gokay (Host)</strong>: Ciao a tutti! Sono Gokay di Gate.io Servizi Istituzionali. Bentornati alla nostra serie di AMA Istituzionali di Gate e oggi segna il 22° episodio del nostro affascinante AMA. Sono entusiasta di presentare l’azienda che ci accompagna oggi - Moonbit.ai. E il nostro ospite speciale è Alexander Thomsen, Fondatore di Moonbit.ai. Grazie, Alexander, per essere parte della nostra serie di AMA. È un piacere averti qui. Come ti senti oggi?</p>
<p><strong>Alexander</strong>: Grazie per avermi ospitato! Mi sento benissimo e sono molto emozionato di condividere di più su di me e su Moonbit.</p>
<p><strong>Gokay</strong>: È fantastico! Alexander, siamo entusiasti di ascoltare i tuoi preziosi contributi e la tua esperienza su Moonbit e il mondo del trading di criptovalute. Quindi, senza ulteriori indugi, immergiamoci nella discussione.</p>
<p><strong>Q1: Quindi, parlaci un po’ di te. Chi è Alexander Thomsen e quale è il tuo background?</strong><br><strong>Alexander</strong>: Okay, potrebbe essere una lunga storia. Sono mezzo danese, mezzo russo, anche se non dico più alle persone di essere russo. Comunque, sono cresciuto in Danimarca. Ho trascorso la maggior parte dei miei anni lì e poi mi sono trasferito nel Regno Unito dove ho fatto l’università. Per quanto riguarda la mia esperienza, ho trascorso gli ultimi 10 anni nella tecnologia della ricchezza e nella gestione della ricchezza. Inizialmente ho lavorato in Corea del Sud e in Giappone dove ho contribuito a creare uno dei primi robot consiglieri in Corea. Poi dalla Corea, mi sono trasferito in Giappone per la stessa azienda dove sono diventato il responsabile della ricerca, assicurandomi che costruissimo diverse strategie di investimento utilizzando gli ETF. Poi da lì sono passato in Germania dove ho fatto product management, quindi gestivo il Product Owner dell’educazione web e mobile per Scalable Capital che è uno dei più grandi servizi di gestione patrimoniale in Europa, ora fanno molte cose diverse, dalla gestione patrimoniale al broker al conto di risparmio, quindi mi occupavo di tutto questo dalla Germania. Poi dopo ho fatto anche qualche attività di venture building e ora sono in Moonbit.ai.</p>
<p><strong>Q2: Come è nato Moonbit e come è posizionato sul mercato?</strong><br><strong>Alexander</strong>: Quindi siamo ufficialmente in giro da un anno e mezzo, ma in realtà la storia di Moonbit è molto più lunga di così. Quindi, ho iniziato a investire in criptovalute nel 2017. Quindi, si potrebbe dire che ho perso circa $ 30.000, e praticamente nel giro di due mesi, erano circa $ 600.000. Quindi, ho pensato: “Wow, ho fatto un sacco di soldi in poco tempo”. Il problema era che non incassavo. Così, dopo due mesi, mi rimanevano solo 15.000 dollari. È stato un vero e proprio ottovolante, vero? Sono passata dal sentirmi ricca a perdere tutto, ed è stato un viaggio così emozionante per me. Vedendo come sono diventato ricco e ho perso tutti i miei soldi nel giro di pochi mesi, ho pensato: “Cosa? Devo fare qualcosa al riguardo, giusto?” Perché è stata un’esperienza così emozionante.<br>Così, ho iniziato a sperimentare diverse strategie di investimento. Tecnicamente, come posso costruire diversi portafogli di criptovalute? Quando è iniziato il prossimo mercato rialzista, avevo creato le mie strategie di portafoglio. In realtà, ho anche investito molto dei miei soldi in gestori di fondi, gestori di fondi crittografici. Quello che è successo è che durante la Bull Run del 2021 tutti hanno fatto soldi, e io ero felice e tutto il resto. Ma poi, quando è iniziato il mercato ribassista ed è avvenuto il crollo di LUNA, ho perso un sacco di soldi a causa dei gestori dei fondi. Ma la cosa interessante è che la mia strategia non ha perso soldi. Quindi, mi sono detto: “Cosa? Perché non ho fatto tutto con la mia strategia?” Ed è così che è iniziato Moonbit. Volevo offrire a tutti allocazioni tattiche, come quello che facciamo in Moonbit, dove essenzialmente cavalchiamo il mercato rialzista, e quando arriva il mercato ribassista, in realtà tiriamo fuori i soldi e proteggiamo la tua creazione di ricchezza. E questo è il punto, giusto? Acquistare e vendere diverse criptovalute è molto difficile, ma con le nostre strategie ci occupiamo di tutto questo creando queste diverse strategie di profilazione del rischio.</p>
<p><strong>Q3: Puoi spiegare il modello di business di Moonbit e i servizi che offri ai tuoi clienti nell’industria delle criptovalute?</strong><br><strong>Alexander</strong>: Certamente. Voglio dire, siamo un software come servizio, quindi offriamo un modello di abbonamento ai clienti. Abbiamo un piano gratuito, quindi se investi meno di $150, è completamente gratuito provarci. Tuttavia, offriamo anche un abbonamento mensile e annuale. L’abbonamento mensile costa $12 al mese; questi sono praticamente i piani di abbonamento che abbiamo, ed è molto semplice, in realtà.<br>Quindi, tutto ciò che devi fare è registrarti, collegare un account di scambio preferito come Gate.io, e poi devi solo compilare un questionario. In base a questo questionario, stabiliamo il tuo profilo di rischio, così sappiamo che tipo di raccomandazioni darti. Dopo di che, tutto ciò che devi fare è selezionare l’importo che desideri investire, e poi puoi rilassarti. La nostra strategia si prenderà cura di tutto per te. Investirà per te, riequilibrerà per te. Non devi preoccuparti di cosa comprare o vendere; noi ci occupiamo di tutto questo.</p>
<p><strong>Q4: Potresti fornire una panoramica delle funzionalità e del funzionamento della piattaforma di gestione degli asset di Moonbit e di come implementa le strategie di trading?</strong><br><strong>Alexande</strong> Certo. Quindi la strategia di investimento è essenzialmente come funziona. Voglio dire, abbiamo più passaggi coinvolti. Innanzitutto, testiamo diverse ipotesi, giusto? Quindi vediamo quale tipo di dati non catenati funziona, a quali dati tecnici di prezzo è coinvolto per generare segnali di acquisto e vendita. Quindi facciamo un po’ di backtesting, facciamo una simulazione per un po’ di tempo, vediamo cosa funziona, cosa non funziona e quindi combiniamo diversi fattori finché non abbiamo una sorta di logica di strategia che ha senso ed è degna di essere testata. Dopo aver fatto la simulazione, poi facciamo un po’ di trading virtuale, il che significa che simuliamo dal vivo come si comporterebbe nel mercato attuale. Se va bene, allora facciamo dei test interni con soldi reali e se va bene anche quello, allora lo lanciamo al cliente. Quindi ci sono molti passaggi coinvolti. Lascia che ti mostri come portiamo effettivamente il prodotto al cliente perché vogliamo assicurarci che faccia bene il suo lavoro, ovviamente proteggendo i soldi del cliente. Questa è praticamente la strategia stessa. A livello operativo, come funziona è simile ad altre società dove si collega la propria API con Moonbit e quindi si effettua il trading tramite il proprio account come un account Gate. Quindi tutto ciò che possiamo fare è prendere il tuo livello utente selezionato, selezionare la criptovaluta, comprare e vendere diverse criptovalute, e questo è tutto ciò che possiamo fare. Non possiamo effettuare depositi, non possiamo effettuare prelievi. Tutto a cui abbiamo accesso è il trading della specifica quantità che ci hai detto di negoziare.</p>
<p><strong>Q5: Di fronte a fluttuazioni di mercato impreviste, come fa Moonbit a mitigare il rischio e mantenere la stabilità nelle sue strategie di gestione del patrimonio? Alexander</strong>: Quindi la mitigazione del rischio è probabilmente uno dei nostri principali obiettivi. Ma questa è la mia esperienza personale: è stata l’esperienza di apprendimento più dolorosa che ho avuto e quanto sia stata traumatizzante. Quindi, nel nostro portafoglio, abbiamo diversi meccanismi di protezione dal rischio. Ad esempio, abbiamo una strategia chiamata Protective Asset Allocation, il modello PA, e questa si basa su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Prezzo Ethereum</a> momentum per decidere essenzialmente quando il momentum del prezzo si indebolisce. Quindi spostiamo parte del denaro in <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USD, e questo protegge essenzialmente il cliente dal rischio al ribasso. Se guardi le nostre performance nel passato durante il mercato ribassista, non abbiamo perso molti soldi perché ci siamo spostati in stable coin durante questi periodi di tempo. Poi abbiamo anche una strategia di inversione VWAP, che è un po’ diversa, dove ci affidiamo all’interesse aperto e al volume on-chain per prendere una decisione su quando passare alla protezione in stable coin. Quindi, ogni strategia ha una protezione dal rischio leggermente diversa ma è una parte fondamentale del nostro prodotto per assicurarci, ancora una volta, di proteggere i soldi che il cliente ha guadagnato con noi.</p>
<p><strong>Q6: Per le persone con diversi livelli di competenza tecnica, quanto è accessibile per i principianti sfruttare la piattaforma Moonbit per la gestione strategica degli asset?</strong><br><strong>Alexander</strong> Penso che sia perfetto per i principianti perché è super semplice. Quindi, sono abbastanza sicuro che in un minuto puoi investire con Moonbit. È appositamente realizzato per principianti o persone che non hanno tempo o conoscenze per investire in criptovalute. La piattaforma è molto snella: ti registri, completi un questionario sul profilo di rischio, ti connetti allo scambio e poi fai un investimento. Tutto il processo è progettato in modo che tu non debba preoccuparti di quale criptovaluta comprare o vendere e non devi monitorare il mercato. Tutti questi compiti, che normalmente gestiresti da solo, vengono gestiti con i nostri portafogli facili da usare.</p>
<p><strong>Gokay</strong>: E quali sono i rendimenti attesi, ad esempio, se mi unisco con $200 e cosa dovrei aspettarmi da esso?</p>
<p><strong>Alexander</strong>: Dovresti aspettarti un aumento del 1000%. No, voglio dire, dipende solo dalla strategia e il pagamento dipende dal tuo profilo di rischio, giusto? Quindi, se sei una persona conservatrice, probabilmente avrai un portafoglio che segue il modello di posizionamento degli asset protettivi. In questo modello, l’attenzione è principalmente su <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> allocazione, basata su tendenze storiche e aspettative per il futuro. Voglio dire, quel portafoglio probabilmente darà un rendimento, non lo so, ma forse da 3 a 5 volte negli anni a venire, giusto? Tuttavia, se hai un profilo di rischio più elevato, come una strategia più avventurosa, potresti probabilmente aspettarti un rendimento da 10 a 15 volte forse nei prossimi 1-2 anni. Quindi, dipende solo dalla strategia. E, soprattutto, che tipo di profilo di rischio hai? Quale è il tuo appetito per il rischio? Pensi al livello di volatilità che puoi accettare?<br>Gokay: Grazie per la grande risposta. Perché in questo settore c’è sempre tempo, ci sono troppi guadagni, ma è importante mantenere effettivamente i tuoi guadagni, non perderli. Ed è davvero importante. Anche 3x, 4x, sono guadagni che alla fine si sommano, e ci danno guadagni significativi da questo.</p>
<p><strong>Q7: Cosa rende Moonbit diverso dalle altre piattaforme di investimento quando si tratta di creare e utilizzare piani di investimento intelligenti?</strong><br><strong>Alexander</strong>: Quindi, penso diversamente dalle altre piattaforme e da ciò che c’è sul mercato. Penso che su un lato abbiamo il fai-da-te, giusto? Dove hai, beh, hai Gate.io e altre borse dove puoi fare tutto il trading da solo, e devi prendere la decisione su cosa comprare e cosa vendere. Dall’altro lato, ci sono di più i bot di trading, giusto? Quindi, i bot di trading sono ovviamente automatizzati, ma devi comunque pensare un po’ a quale criptovaluta vuoi usare per il bot di trading. A volte, potresti dover prendere la decisione di andare long o short per il trading. Ma il bot di trading ha comunque molte configurazioni e ancora molta frizione, penso, per configurare con successo un bot di trading. In realtà, molti di questi bot di trading si concentrano spesso sul tipico trading ad alta frequenza, tutti concentrati sugli stessi indicatori, come RSI, MSD, EMA - indicatori tecnici di prezzo di base.<br>Ora, sul lato Moonbit, siamo abbastanza, direi, diversi perché ci concentriamo principalmente sull’allocazione tattica. Questo significa che si tratta più di un cambiamento del portafoglio a lenta evoluzione, quindi il modello PA si riequilibra solo una volta a settimana. La promozione B4 è decisamente più veloce, ma non è come il trading ad alta frequenza. Inoltre, utilizziamo molti indicatori diversi. Quindi, guardiamo agli indicatori tecnici di prezzo, guardiamo ai dati on-chain, guardiamo ai dati macro, e consideriamo molti fattori diversi coinvolti nei portafogli. Non devi preoccuparti di criptovalute specifiche su cui concentrarti, e non devi preoccuparti se andare long o short. Noi ci occupiamo di tutto questo. Non è solo un semplice bot di trading; tutto è fatto all’interno di Moonbit.</p>
<p><strong>Q8: Come è stata finora l’esperienza di Moonbit lavorando con Gate.io?</strong><br><strong>Alexander</strong>: Lavorare con Gate.io è stato davvero fantastico. Penso che voi ragazzi - intendo, ovviamente, parlando con voi in questo momento, ma siete voi ragazzi che siete stati davvero coinvolti, molto proattivi nel pensare alla nostra partnership. Ogni volta che avevamo domande, come i nostri sviluppatori che chiedevano informazioni sull’integrazione, voi eravate lì subito. Quindi onestamente, è stata una delle partnership più facili che abbiamo avuto finora. Sono molto felice di lavorare insieme a Gate.<br>Gokay: Ottimo sentire il tuo feedback, e spero che la nostra relazione e partnership continueranno. Fiducioso che tutti, inclusi tutti gli utenti, ne trarranno beneficio.</p>
<p><strong>Q9: Puoi fornire qualche insight sul futuro orientamento o piani di Moonbit?</strong><br><strong>Alexander</strong>: Al momento, continueremo a migliorare le strategie che abbiamo. Quindi, le renderemo migliori e amplieremo anche le strategie che abbiamo. Attualmente, abbiamo diverse strategie di profilazione del rischio, ma aggiungeremo presto un’altra strategia. Quindi, la prima cosa da fare è come migliorare il nostro prodotto esistente e migliorare la nostra proposta di valore.<br>Guardando avanti, penso che esploreremo una situazione in cui potremmo approfondire lo staking, magari offrendo un servizio in cui aggregare per offrirti le migliori opzioni di staking sul mercato. Questa è un’opzione. Inoltre, stiamo valutando la modifica del lavoro in modo che tu abbia comunque il pieno controllo sul portafoglio, ma integriamo qualche forma di integrazione DeFi, questo è un altro aspetto che stiamo esplorando.</p>
<p><strong>Q10: Quali dettagli specifici o informazioni possono gli utenti acquisire esplorando le informazioni disponibili sul sito web di Moonbit?</strong><br><strong>Alexander</strong>: Sì, il nostro sito web è pieno di informazioni. Abbiamo una sezione su Moonbit che approfondisce i dettagli di molte cose che facciamo. Abbiamo anche una sezione di apprendimento. Inoltre, offriamo vari strumenti per principianti se vuoi capire il tuo livello di rischio. C’è uno strumento in cui inserisci le tue criptovalute esistenti e ti forniamo un punteggio di rischio basato sul tuo portafoglio attuale. Incorporiamo anche molto gioco in questo. Idealmente, puntiamo a renderlo coinvolgente.<br>Il nostro sito web contiene dettagli estesi sulla nostra strategia. Abbiamo pagine dedicate che spiegano precisamente come funziona ogni strategia. Abbiamo persino creato un video di YouTube su questo per condividere il maggior numero possibile di informazioni. Ci sforziamo di essere trasparenti nel modo in cui sviluppiamo le nostre strategie.</p>
<p><strong>Q11: E infine, qual è il punto più importante che vuoi che il nostro pubblico ricavi dalla sessione AMA di oggi?</strong><br><strong>Alexander</strong>: Penso che dalla mia esperienza sia così: durante un mercato rialzista, tutti sono investitori professionisti e sembra che tutti stiano facendo un buon lavoro; tutti pensano di essere il miglior investitore. Il punto è che quando inizia il mercato ribassista o una correzione, devi assicurarti di avere un piano di gioco: come uscire dal mercato? Prenderai profitto? Non rimarrai solo ad aspettare. Quindi, questa è la cosa più importante; avere un piano di gioco per quello.</p>
<p><strong>Gokay</strong>: Sicuramente. Ed è fantastico perché le persone guadagnano molto denaro nel mercato rialzista perché fondamentalmente, in ogni progetto, tutto ciò che fai, ti porta dei guadagni. Ma è davvero importante essere in grado di conservarlo e in quel momento, forse hai bisogno di migliorarti o di lavorare con professionisti, ed è qui che Moonbit ti assisterà.</p>
<h2 id="h2-Conclusione72222"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p><strong>Gokay</strong>: Alexander, grazie per il tuo tempo! È stato un piacere parlare con te e conoscere tutti i dettagli. Se vuoi saperne di più, non esitare a contattare Moonbit e a visitare il loro sito web.<br>E prima di concludere la nostra sessione, Alexander, vorresti aggiungere qualcos’altro?</p>
<p><strong>Alexander</strong>: Sono passato attraverso due rialzi e due mercati al ribasso e penso che stiamo per iniziare il prossimo mercato rialzista molto presto. Quindi allacciatevi le cinture, godetevi il viaggio e divertitevi.</p>
<p><strong>Gokay</strong>: Esatto. Grazie, Alexander! Grazie a tutti coloro che seguono la nostra serie di AMA. Seguici sui social media, per ulteriori informazioni scrivi ai nostri key account managers.</p>
<p>Twitter: <a href="https://twitter.com/gate_io" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/gate_io</a><br>Twitter istituzionale di Gate.io: <a href="https://twitter.com/Gateio_Inst" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Gateio_Inst</a><br>Telegram: <a href="https://t.me/gate_io" rel="nofollow noopener noreferrer" target="_blank">https://t.me/gate_io</a><br>API Telegram: <a href="https://t.me/gateioapi" rel="nofollow noopener noreferrer" target="_blank">https://t.me/gateioapi</a><br>Linkedin: <a href="https://www.Linkedin.com/company/gateio/" rel="nofollow noopener noreferrer" target="_blank">https://www.Linkedin.com/company/gateio/</a><br>Pagina web: <a href="https://www.gate.io/institution" target="_blank">https://www.gate.io/institution</a></p>
<p>● Nessun contenuto qui costituirà consulenza in materia di investimenti e non costituisce alcuna offerta o sollecitazione di offerta o raccomandazione di alcun prodotto o progetto di investimento.<br>● L’inclusione di qualsiasi prodotto, servizio, entità o contenuto di terze parti non costituisce un’approvazione, raccomandazione o affiliazione da parte di Gate.io. Si prega di condurre una ricerca approfondita e di cercare consigli professionali prima di prendere qualsiasi decisione di investimento.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Moonbit.ai</strong>, Ricercatore 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 venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>