R2F0ZS5pbyBBTUEgbWV0IEJyYWludHJ1c3QgLSBUb2VnYW5nIHRvdCAncyB3ZXJlbGRzIGJlc3RlIGJhbmVu

<p><img src="https://gimg2.gateimg.com/image/article/16826664591.jpg" alt=""><br><strong>Tijd: 1 maart 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> georganiseerd een AMA (Vraag-Me-Alles) sessie met Adam Jackson, mede-oprichter van Braintrust in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <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>Volg Braintrust op <a href="https://t.me/braintrustofficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/rgUS9aHFCB" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16826666322.png" alt=""><br><strong>Adam Jackson - Medeoprichter van Braintrust</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio552103"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Vraag20120Vertel20ons20alstublieft20waarom20is20Braintrust20opgericht20En20waarom20op20blockchain104508"><a name="Vraag 1: Vertel ons alstublieft, waarom is Braintrust opgericht? En waarom op blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 1: Vertel ons alstublieft, waarom is Braintrust opgericht? En waarom op blockchain?</h3><p><strong>Adam</strong>: Graag gedaan! Ik ben een grote fan van Gate.io!</p>
<p>Ik heb mijn hele carrière gebouwd en geïnvesteerd in op het web gebaseerde marktplaatsen. Het model is echter gebroken - ze moeten miljarden aan VC-geld ophalen om één of beide kanten van de marktplaats te subsidiëren en liquiditeit op te bouwen.</p>
<p>Als het werkt, komen ze aan het einde van een volledig door investeerders beheerd netwerk en die investeerders (terecht) hebben een rendement nodig, en dat rendement komt uit hoge kosten op de marktplaats.</p>
<p>Dat schept onjuist afgestemde prikkels tussen de mensen die hun brood verdienen op het netwerk en de mensen die het bezitten. Mensen proberen te ontintermediairen, netwerkeffecten eroderen. Ik dacht dat er een betere manier moest zijn - en dat is wat Braintrust is. We hebben het model omgekeerd, waardoor gebruikers al vanaf dag 1 eigendom en controle hebben om prikkels op één lijn te houden.</p>
<p>Braintrust wordt gecontroleerd door zijn gebruikers, die over de hele wereld verspreid zijn. Aandelen in een traditioneel bedrijf zijn een verouderde manier om een digitaal inheems, mondiaal netwerk te regeren. Blockchain tokens zijn onveranderlijk en iedereen met een internetverbinding kan ze bezitten. Ze zijn een perfect instrument om eigendom en controle over een mondiaal netwerk te vertegenwoordigen. Het is belangrijk om op te merken dat met eigendom ik niet het recht op winst bedoel - Braintrust is een non-profit netwerk - ik bedoel eenvoudigweg de controle over de toekomst van het netwerk en zijn regels.<br><img src="https://gimg2.gateimg.com/image/article/16826666523.png" alt=""><br>Hier is nog wat meer informatie over waarom we Braintrust hebben opgericht:<br><a href="https://www.usebraintrust.com/blog/why-braintrust-was-founded" rel="nofollow noopener noreferrer" target="_blank">https://www.usebraintrust.com/blog/waarom-braintrust-is-opgericht</a></p>
<h3 id="h3-Q220Geweldig20bedankt20Adam20voor20de20uitleg20En20hoe20verschilt20Braintrust20van20andere20talentmarktplaatsen635150"><a name="Q2: Geweldig, bedankt Adam voor de uitleg. En hoe verschilt Braintrust van andere talentmarktplaatsen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Geweldig, bedankt Adam voor de uitleg. En hoe verschilt Braintrust van andere talentmarktplaatsen?</h3><p><strong>Adam</strong> Wat Braintrust uniek maakt, is het model: de marktplaats is gedecentraliseerd en door de gebruiker gecontroleerd. Andere platforms zoals Toptal, Upwork, Fiverr, enzovoorts, nemen 20-40% van wat het talent op het platform verdient. En eigendom is sterk geconcentreerd bij een paar mensen en investeerders.</p>
<p>Braintrust neemt 0% van wat het talent verdient, en het wordt gecontroleerd door de token-gemeenschap. Deze benadering stelt Braintrust in staat om hoogwaardig talent aan te trekken en te behouden.</p>
<p>Blockchain-technologie stelt Braintrust in staat om de tussenpersonen uit te schakelen en prikkels op één lijn te houden. Dit verlaagt de kosten voor klanten drastisch en verhoogt de inkomsten van talent, en trekt daardoor de beste mensen ter wereld aan, terwijl de waarde gelijker wordt verdeeld over het talent in het netwerk.</p>
<h3 id="h3-Q320Als20we20een20stap20terug20doen20naar20meer20algemene20concepten20in20de20industrie20kunt20u20aan20de20gemeenschap20uitleggen20wat20het20verschil20is20tussen20een20Web220en20een20Web3netwerk194846"><a name="Q3: Als we een stap terug doen naar meer algemene concepten in de industrie, kunt u aan de gemeenschap uitleggen wat het verschil is tussen een Web2- en een Web3-netwerk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Als we een stap terug doen naar meer algemene concepten in de industrie, kunt u aan de gemeenschap uitleggen wat het verschil is tussen een Web2- en een Web3-netwerk?</h3><p><strong>Adam</strong>:Dat is zeker. Als Web 1.0 het leesbare web bouwde, creëerde Web 2.0 het interactieve internet dat we vandaag kennen.<br>Deze technologieën maakten een onvoorstelbare overvloed aan informatie en het creëren van rijkdom mogelijk, maar genereerden ook enorme vergoedingen en tussenpersonen voor poortwachters.</p>
<p>Dit dreef de meeste internetactiviteit naar consolidatie rond een handvol grote techbedrijven - namelijk Amazon, Apple, Facebook, Google en Twitter - waardoor de zakken van hun investeerders werden gevuld, maar niet die van de gewone gebruikers die deze netwerken hun waarde geven.</p>
<p>In tegenstelling daarentegen is Web 3.0 het gedecentraliseerde en door gebruikers eigendom web, waardoor een gedistribueerd model mogelijk wordt dat waarde teruggeeft aan de gebruikers die het creëren.</p>
<p>Het wordt mogelijk gemaakt door blockchains die dienen als onveranderlijke openbare grootboeken van zowel waarde als de mensen die het produceren, waardoor peer-to-peer transacties mogelijk zijn zonder de noodzaak van bemiddelaars die kosten in rekening brengen.</p>
<h3 id="h3-Q420Begrepen20dit20is20een20begrip20dat20vaak20ter20sprake20komt20in20discussies20en20het20is20goed20om20terug20te20gaan20en20de20basis20ervan20te20onthouden20dus20bedankt20daarvoor20Terugkomend20op20het20project20hoe20werkt20het20bestuur20precies20op20Braintrust704999"><a name="Q4: Begrepen, dit is een begrip dat vaak ter sprake komt in discussies en het is goed om terug te gaan en de basis ervan te onthouden, dus bedankt daarvoor. Terugkomend op het project, hoe werkt het bestuur precies op Braintrust?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Begrepen, dit is een begrip dat vaak ter sprake komt in discussies en het is goed om terug te gaan en de basis ervan te onthouden, dus bedankt daarvoor. Terugkomend op het project, hoe werkt het bestuur precies op Braintrust?</h3><p><strong>Adam</strong>: Governance bij Braintrust is een systeem dat iedereen in staat stelt om een idee voor te stellen dat Braintrust kan verbeteren.</p>
<p>Het begint allemaal met een idee dat zich materialiseert in een ‘voorstel’, dat een beschrijving is van het idee in meer detail met wat beschrijving en argumentatie om de zaak te maken.</p>
<p>Leden van de gemeenschap uiten vervolgens hun mening over het voorstel door erop te stemmen met de BTRST-tokens, die fungeren als stemmen en stemkracht aangeven voor hun stem. Hoe meer BTRST-tokens je hebt, hoe meer stemkracht je hebt bij het uitbrengen van je stem.</p>
<p>Als de resultaten van het stemproces voor een voorstel gunstig zijn, wordt het voorstel uitgevoerd via code op de blockchain en gaat er een nieuwe governance van Braintrust live!<br><img src="https://gimg2.gateimg.com/image/article/16826666624.png" alt=""><br>Een geweldig voorbeeld is het door de community ontwikkelde Fee Converter smart contract dat onlangs is goedgekeurd:<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-Q520Kunt20u20ook20alstublieft20enkele20van20de20successen20van20het20netwerk20tot20nu20toe20delen737676"><a name="Q5: Kunt u ook alstublieft enkele van de successen van het netwerk tot nu toe delen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kunt u ook alstublieft enkele van de successen van het netwerk tot nu toe delen?</h3><p><strong>Adam</strong>: Sinds de onthulling in juni 2020.</p>
<ul>
<li>Het bruto dienstenvolume (GSV) is met 34 keer gestegen, van $1,2 miljoen naar $42 miljoen+. Dankzij het Fee Converter slimme contract, dat de 10% klantenvergoedingen inneemt, BTRST op de open markt koopt en naar de Braintrust DAO stuurt, zijn er meer dan 222.000 BTRST gekocht om gemeenschapsprogramma’s zoals subsidies te financieren (en dat is alleen al sinds januari). <a href="https://fees.btrstinfo.xyz/" rel="nofollow noopener noreferrer" target="_blank">https://fees.btrstinfo.xyz/</a></li></ul>
<p>-Het aantal bedrijven (klanten) steeg van 63 naar 500+ inclusief Nike, Nestle, Airbnb, Mastercard, Walmart en LinkedIn.</p>
<p>-Het aantal talenten op het platform is gegroeid van 2.194 naar meer dan 46.000.</p>
<ul>
<li>En de gemeenschap van het netwerk groeide met 70x van 10.000 naar meer dan 700.000.</li></ul>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>