R2F0ZS5pbyBBTUEgY29uIEJyYWludHJ1c3Q6IGFjY2VkaSBhaSBtaWdsaW9yaSBsYXZvcmkgZGVsIG1vbmRv

<p><img src="https://gimg2.gateimg.com/image/article/16826664591.jpg" alt=""><br><strong>Ora: 1° marzo 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 Adam Jackson, co-fondatore di Braintrust 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://www.usebraintrust.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.usebraintrust.com/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/usebraintrust" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/usebraintrust</a></strong></p>
<p><strong>Segui Braintrust su <a href="https://t.me/braintrustofficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/rgUS9aHFCB" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16826666322.png" alt=""><br><strong>Adam Jackson - Co-fondatore di Braintrust</strong></p>
<h2 id="h2-QampA20da20Gateio988555"><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-Domanda20120Per20favore20diteci20perch2020stata20fondata20Braintrust20E20perch20sulla20blockchain330444"><a name="Domanda 1: Per favore, diteci, perché è stata fondata Braintrust? E perché sulla blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domanda 1: Per favore, diteci, perché è stata fondata Braintrust? E perché sulla blockchain?</h3><p><strong>Adam</strong>: Felice di farlo! Sono un grande fan di Gate.io!</p>
<p>Ho costruito e investito in mercati abilitati dal web per tutta la mia carriera. Il modello è però fallato: devono raccogliere miliardi di dollari di VC per sovvenzionare uno o entrambi i lati del mercato e creare liquidità.</p>
<p>Se funziona, escono dall’altra parte di una rete interamente di proprietà degli investitori e questi investitori (giustamente) hanno bisogno di un rendimento e questo rendimento deriva da commissioni elevate sul mercato.</p>
<p>Ciò crea incentivi disallineati tra le persone che si guadagnano da vivere con la rete e le persone che la possiedono. Le persone cercano di disintermediare, gli effetti di rete si erodono. Ho pensato che ci dovesse essere un modo migliore, ed è quello che è Braintrust. Abbiamo invertito il modello, dando proprietà e controllo agli utenti il primo giorno, per mantenere allineati gli incentivi.</p>
<p>Braintrust è controllato dai suoi utenti, che si trovano in tutto il mondo. Le azioni di una società tradizionale sono un modo obsoleto per governare una rete globale nativa digitale. I token blockchain sono immutabili e chiunque abbia una connessione internet può possederli. Sono uno strumento perfetto per rappresentare la proprietà e il controllo di una rete globale. È importante sottolineare che con proprietà non intendo il diritto ai profitti - Braintrust è una rete non profit - intendo semplicemente il controllo sul futuro della rete e delle sue regole.<br><img src="https://gimg2.gateimg.com/image/article/16826666523.png" alt=""><br>Ecco un po’ di più su perché abbiamo fondato Braintrust:<br><a href="https://www.usebraintrust.com/blog/why-braintrust-was-founded" rel="nofollow noopener noreferrer" target="_blank">https://www.usebraintrust.com/blog/why-braintrust-was-founded</a></p>
<h3 id="h3-Q220Ottimo20grazie20Adam20per20la20spiegazione20E20come20si20differenzia20Braintrust20dagli20altri20mercati20del20talento220029"><a name="Q2: Ottimo, grazie Adam per la spiegazione. E come si differenzia Braintrust dagli altri mercati del talento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ottimo, grazie Adam per la spiegazione. E come si differenzia Braintrust dagli altri mercati del talento?</h3><p><strong>Adamo</strong> Ciò che rende unico Braintrust è il suo modello: il marketplace è decentralizzato e controllato dagli utenti. Altre piattaforme come Toptal, Upwork, Fiverr, ecc., prendono dal 20 al 40% di ciò che il talento guadagna sulla piattaforma. E la proprietà è altamente concentrata tra poche persone e investitori.</p>
<p>Braintrust non prende nulla di ciò che il talento guadagna ed è controllato dalla sua community di token. Questo approccio consente a Braintrust di attrarre e trattenere talenti di alta qualità.</p>
<p>La tecnologia blockchain è ciò che consente a Braintrust di eliminare gli intermediari e mantenere gli incentivi allineati. Questo riduce drasticamente i costi per i clienti e aumenta i guadagni dei talenti, e quindi attira le persone migliori al mondo distribuendo il valore in modo più equo ai talenti nella rete.</p>
<h3 id="h3-Q320Tornando20indietro20a20concetti20pi20generali20dellindustria20puoi20spiegare20alla20comunit20qual2020la20differenza20tra20una20rete20Web220e20una20rete20Web3817327"><a name="Q3: Tornando indietro a concetti più generali dell’industria, puoi spiegare alla comunità qual è la differenza tra una rete Web2 e una rete Web3?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Tornando indietro a concetti più generali dell’industria, puoi spiegare alla comunità qual è la differenza tra una rete Web2 e una rete Web3?</h3><p><strong>Adamo</strong>: Certamente. Se la Web 1.0 ha costruito la web leggibile, la Web 2.0 ha creato l’internet interattiva che conosciamo oggi.<br>Queste tecnologie hanno reso possibile un’incredibile abbondanza di informazioni e la creazione di ricchezza, ma hanno anche generato enormi commissioni e intermediari di controllo degli accessi.</p>
<p>Ciò ha spinto la maggior parte dell’attività su Internet a consolidarsi attorno a una manciata di aziende Big Tech – vale a dire Amazon, Apple, Facebook, Google e Twitter – che riempiono le tasche dei loro investitori, ma non degli utenti ordinari che danno a queste reti il loro valore.</p>
<p>Al contrario, il Web 3.0 è il web decentralizzato e di proprietà dell’utente, che consente un modello distribuito che restituisce valore agli utenti che lo creano.</p>
<p>È reso possibile dalle blockchain che fungono da registri pubblici immutabili sia del valore che delle persone che lo producono, consentendo transazioni peer-to-peer che eliminano la necessità di intermediari che estraggono commissioni.</p>
<h3 id="h3-Q420Capito20questo2020un20concetto20che20viene20spesso20menzionato20nelle20discussioni20ed2020bene20tornare20indietro20e20ricordare20i20concetti20di20base20quindi20grazie20per20questo20Tornando20al20progetto20come20funziona20esattamente20la20governance20su20Braintrust679818"><a name="Q4: Capito, questo è un concetto che viene spesso menzionato nelle discussioni ed è bene tornare indietro e ricordare i concetti di base, quindi grazie per questo. Tornando al progetto, come funziona esattamente la governance su Braintrust?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Capito, questo è un concetto che viene spesso menzionato nelle discussioni ed è bene tornare indietro e ricordare i concetti di base, quindi grazie per questo. Tornando al progetto, come funziona esattamente la governance su Braintrust?</h3><p><strong>Adam</strong>: La governance di Braintrust è un sistema che permette a chiunque di proporre un’idea che possa migliorare Braintrust.</p>
<p>Tutto ha inizio con un’idea che si materializza in una “proposta”, ovvero un elaborato dell’idea in maggiori dettagli con alcune descrizioni e argomentazioni per sostenere il caso.</p>
<p>I membri della community esprimono poi la loro opinione sulla proposta votandola con i token BTRST che fungeranno da voti segnalando il potere di voto al loro voto. Più token BTRST hai, più potere di voto avrai quando esprimi il tuo voto.</p>
<p>Se i risultati del processo di votazione per una proposta sono favorevoli, la proposta viene eseguita tramite codice sulla blockchain e una nuova governance di Braintrust diventa operativa!<br><img src="https://gimg2.gateimg.com/image/article/16826666624.png" alt=""><br>Un ottimo esempio è il contratto intelligente Fee Converter sviluppato dalla comunità che è stato recentemente approvato:<br><a href="https://www.usebraintrust.com/blog/community-led-fee-converter-spurs-growth" rel="nofollow noopener noreferrer" target="_blank">https://www.usebraintrust.com/blog/community-led-fee-converter-spurs-growth</a></p>
<h3 id="h3-Q520Puoi20anche20condividere20alcuni20dei20successi20della20rete20fino20ad20oggi231307"><a name="Q5: Puoi anche condividere alcuni dei successi della rete fino ad oggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Puoi anche condividere alcuni dei successi della rete fino ad oggi?</h3><p><strong>Adam</strong>: Da quando è uscito allo scoperto nel giugno 2020.</p>
<ul>
<li><p>Il Volume dei Servizi Lordi (GSV) è cresciuto di 34 volte, da $1,2M a $42M+. Grazie al contratto intelligente del Convertitore di Commissioni che preleva il 10% delle commissioni dei clienti, acquista BTRST sul mercato aperto e lo invia al Braintrust DAO, sono stati acquistati oltre 222.000 BTRST per finanziare programmi della comunità come i Contributi (e questo è solo dall’inizio dell’anno). <a href="https://fees.btrstinfo.xyz/" rel="nofollow noopener noreferrer" target="_blank">https://fees.btrstinfo.xyz/</a></p>
</li><li><p>Il numero di aziende (clienti) è aumentato da 63 a oltre 500, tra cui Nike, Nestlé, Airbnb, Mastercard, Walmart e LinkedIn.</p>
</li></ul>
<p>-Il talento si è unito alla piattaforma passando da 2.194 a oltre 46.000.</p>
<p>-E la Community della rete è cresciuta di 70 volte, passando da 10.000 a oltre 700.000.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>