RmluYW5jaWVyaW5nc3N1Y2NlcyB2YW4gUGlwIExhYnM6IEhvZSAkODBNIEJvb3N0IFN0b3J5IFByb3RvY29sIHN0dXd0IG5hYXIgZWVuIHdhYXJkZXJpbmcgdmFuIDIsMjUgbWlsamFyZA==

2024-09-04, 03:17

<p><img src="https://gimg2.gateimg.com/image/article/17254196521690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR681561"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De waardering van Pip Labs heeft $2,25 miljard bereikt na het ophalen van $80 miljoen via de recente financieringsronde.</p>
<p>Story Protocol is een layer-1 blockchain voor het beheer van intellectuele eigendommen.</p>
<p>Het beheren van intellectueel eigendom met behulp van de blockchain zal contentmakers helpen om volledige vergoeding te krijgen voor hun werk.</p>
<h2 id="h2-Introductie654116"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De beste blockchains zijn degene die overtuigende problemen oplossen waar mensen in hun leven tegenaan lopen. Degene die grote financiële voordelen bieden aan hun gemeenschappen, zullen opvallen binnen het crypto-ecosysteem. Een nieuwe dergelijke blockchain, Story Protocol, is onderweg. Het heeft tot doel de uitdagingen op te lossen waarmee content creators vaak te maken hebben, zoals diefstal van intellectueel eigendom. Vandaag bespreken we de weg die Pip Labs bewandelt om zijn visie te realiseren.</p>
<h2 id="h2-Pip20Labs20zekert208020miljoen20financiering20voor20het20opzetten20van20het20Storyprotocol602985"><a name="Pip Labs zekert $80 miljoen financiering voor het opzetten van het Story-protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pip Labs zekert $80 miljoen financiering voor het opzetten van het Story-protocol</h2><p>Pip Labs, de in Palo Alto gevestigde startup, heeft onlangs een succesvolle Series B-financieringsronde van $80 miljoen aangekondigd, om kapitaal op te halen voor de ontwikkeling van het Story Protocol, een blockchain van laag 1 voor het beheer van intellectueel eigendom (IE). Veel toonaangevende bedrijven namen deel aan de financieringsronde, die werd geleid door a16z Crypto en Polychain Capital. Voorbeelden van enkele investeerders die deelnamen aan de ronde zijn Hashed, Foresight Ventures, SparkLabs Global, Angel-investeerders, Samsung Next en Mirana Ventures. Scott Trowbridge, SVP van Stability AI, en Cozomo de’ Medici, een digitale kunstverzamelaar, maakten ook deel uit van het financieringsinitiatief. Pip Labs haalde op 21 augustus $80 miljoen op, waarmee het totale financieringsbedrag op $140 miljoen komt. Vorig jaar haalde het bedrijf tijdens een Series A-financieringsronde, ook geleid door a16z crypto, $54 miljoen op.<br><img src="https://gimg2.gateimg.com/image/article/1725419707img_v3_02ed_b975231f-9d85-4016-b983-b306401af7ix.jpg" alt=""><br>Pip Labs haalt $140 miljoen op - x.com/StoryIP</p>
<p>Zoals je kunt zien op de afbeelding, kondigde Pip Labs op 21 augustus aan dat het al $140 miljoen had opgehaald voor zijn ambitieuze project. Na die financieringsronde bereikte de waardering van de startup $2,25 miljard die het zal gebruiken als onderdeel van zijn groeistrategie.</p>
<h2 id="h2-Pip20Labs20en20Story20Protocol20Overzicht685138"><a name="Pip Labs en Story Protocol: Overzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pip Labs en Story Protocol: Overzicht</h2><p>Pip Labs is een startup durfkapitaal achter de <a href="https://www.gate.io/learn/articles/leading-the-new-wave-of-crypto-with-programmable-ip/1943" target="_blank">Story Protocol, een layer-1 blockchain</a> dat gericht is op de bescherming van intellectueel eigendom (IE) tegen diefstal en misbruik. Het bedrijf heeft uitgelegd dat tijdens het huidige tijdperk van kunstmatige intelligentie intellectueel eigendom moet worden beschermd tegen taalmodel crawls die inhoud verzamelen voor trainingsdoeleinden. Volgens het bedrijf is dit een ‘multi-biljoen-dollar’ project, aangezien het product erg waardevol is in het tijdperk van blockchain technologie.</p>
<p>Story Protocol, een blockchain voor het beheer van intellectueel eigendom, werd opgericht in 2022 door Seung Yoon Lee na de verkoop van zijn bedrijf, Radish Fiction, aan Kakao. Sterker nog, Lee en Jason Zhao, een afgestudeerde van Stanford en voormalig leidinggevende bij DeepMind, richtten Story Protocol op nadat ze zich realiseerden tegen welke problemen content creators aanlopen. Dus, Story Protocol is een blockchain- en cryptocurrency-innovatie die content creators zal helpen meer te profiteren van hun innovatie dan ooit tevoren.</p>
<p>Met Story Protocol registreren content creators hun intellectuele eigendommen op de blockchain, zodat ze het gebruik van hun werk kunnen volgen en controleren. Dit zorgt ervoor dat ze een passende vergoeding krijgen voor hun inhoud. Het systeem houdt bij hoe de inhoud is gebruikt en verspreid. Naast het registreren van hun <a href="https://www.gate.io/learn/articles/on-chain-intellectual-property/1002" target="_blank">intellectuele eigendommen op de blockchain</a> , de makers zullen in staat zijn om regels in te stellen over hoe hun inhoud gebruikt moet worden. De regels kunnen onder meer bevatten hoe de inhoud kan worden aangepast of gedeeld.</p>
<p>Het plaatsen op X Story Protocol legde uit hoe een deel van het systeem werkt. Het <a href="https://x.com/StoryProtocol/status/1826227877970678144" rel="nofollow noopener noreferrer" target="_blank">aangegeven</a>“IP dient als de fundamentele input waarop grote modellen trainen. Zonder IP zal AI waarschijnlijk een plafond bereiken.” Door het gebruik van kunstmatige intelligentie kunnen de IPs worden gebruikt als invoergegevens voor het trainen van modellen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-digital-ownership/938" target="_blank">Wat is Digitale Eigendom?</a></p>
<h2 id="h2-Hoe20financieringsronde20helpen20bij20Tech20en20Blockchain449621"><a name="Hoe financieringsronde helpen bij Tech en Blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe financieringsronde helpen bij Tech en Blockchain</h2><p>Op dit moment zijn er veel startups actief in de tech- en blockchainsector die geld hebben opgehaald met behulp van verschillende crowdfundingmechanismen. Gewoonlijk leiden financiële vermogensbeheerbedrijven de financieringsrondes. Risicokapitaalbedrijven zijn enkele van de organisaties die deelnemen aan het inzamelingsproces. In de meeste glen bereiken de startups hun gestelde doelen, vooral als ze goede investeringsvoorstellen hebben ondersteund door goede producten, zoals in het g van Pip Labs en Story Protocol. Dit financieringsmodel heeft de tech- en blockchainsector geholpen te groeien.</p>
<p>De financieringsrondes laten in principe de grote interesse zien die investeerders hebben in de sector. Ze willen zien dat de industrie groeit en bijdraagt aan de wereldeconomie. Bijvoorbeeld, technologie-investeringen zijn essentieel voor de groei van verschillende sectoren van de economie. Naast Pip Labs hebben verschillende andere startups zoals Space and Time, IO Research en Finality onlangs miljoenen dollars opgehaald via financieringsrondes.</p>
<h2 id="h2-Pip20Labs2014020Miljoen20om20Story20Protocol20naar20een20ander20niveau20te20brengen917666"><a name="Pip Labs’ $140 Miljoen om Story Protocol naar een ander niveau te brengen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pip Labs’ $140 Miljoen om Story Protocol naar een ander niveau te brengen</h2><p>Het doel van het fonds is om de infrastructuur van het Story Protocol verder te ontwikkelen, zodat het veel partijen kan bedienen, waaronder organisaties en individuen. Het team wil er ook voor zorgen dat er binnen korte tijd een wrijvingsloos systeem voor het registreren van intellectueel eigendom bestaat. Om dat te bereiken moeten veel elementen geïntegreerd worden met het systeem om het foutloos te maken. Er zullen ook veel functies deel uitmaken van het systeem. Bijvoorbeeld, makers moeten hun intellectuele eigendommen tokeniseren. Aan de andere kant moet het systeem ook in staat zijn om betalingen te faciliteren.</p>
<p>Op dit moment werkt Story eraan om ervoor te zorgen dat de belangrijkste structuren op hun plaats zijn. Primair is de architectuur van het Story Protocol gebaseerd op twee belangrijke onderdelen, namelijk gegevensstructuren en modules. De gegevensstructuren slaan IP-metadata op, terwijl de modules de functionaliteiten van het protocol bevorderen. Het is belangrijk op te merken dat het Story Protocol compatibel zal zijn met diverse gedecentraliseerde applicaties en blockchains. Zo zal het bijvoorbeeld compatibel zijn met de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Virtual Machine (EVM). Op dit moment gebruiken al meer dan 200 teams Story. Pip Labs streeft er echter naar om de infrastructuur uit te breiden om meer organisaties en individuen te laten profiteren, wat de marktimpact zal vergroten.</p>
<h2 id="h2-Conclusie606805"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Pip Labs heeft via financieringsrondes $140 miljoen weten op te halen. De fondsen zullen worden gebruikt om het Story Protocol verder te ontwikkelen, een blockchain voor het beheren van intellectuele eigendommen. Na de recente financieringsronde heeft de waardering van Pip Labs $2,25 miljard bereikt. De technologie- en blockchainsectoren hebben groei gezien als gevolg van het kapitaal dat is opgehaald via financieringsrondes.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits 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>