Insights AI

Autonome codeagenten opschalen: hoe verificatielussen en strikte CI-beveiligingskaders snelle softwarelevering mogelijk maken

Podcast · Luister (20 min)

Cursor工程師讓AI一個月自動合併1000個PR,關鍵不是更聰明

Inhoud
  1. Het vertrouwensknelpunt: waarom het opschalen van codeagenten een managementprobleem binnen softwareontwikkeling is
  2. 1. Vat het kernprobleem samen
  3. 2. Leg de managementanalogie vast
  4. Programmatische verificatie en functionaliteitsmapping: de agentlus sluiten
  5. 1. Leg het stapsgewijze verificatiemechanisme uit
  6. 2. Beschrijf de architectuur van de functionaliteitskaart
  7. 3. Beschrijf de evaluatie en het onderhoud van agentvaardigheden
  8. Harde architecturale begrenzingen: van zachte prompts naar CI-handhaving
  9. 1. Vergelijk zachte regels met harde deterministische beperkingen
  10. 2. Analyseer de casestudy van de "Dune"-architectuur
  11. Automatisering van cloudagenten en sectorbrede productimplicaties
  12. 1. Autonome bugreproductie en cloudwerkstromen
  13. 2. Democratisering van ontwikkeling voor niet-technische functies
  14. Architecturale beperkingen en openstaande technische vragen
  15. 1. Belangrijkste beperkingen en randgevallen documenteren
  16. Kerncijfers
  17. Wat dit beeld zou veranderen
  18. Geraadpleegde bronnen

Moderne softwareontwikkelingsorganisaties voeren een fundamentele paradigmaverschuiving door: van programmeren in duo's met kunstmatige intelligentie [AI] onder micromanagement naar autonome agentvloten die honderden tot duizenden samenvoegverzoeken [PRs] per maand kunnen verwerken. Zoals Lauren Tan, een ingenieur bij SpaceXAI, uiteenzet, is het opschalen van AI-codegeneratie voornamelijk een managementprobleem binnen softwareontwikkeling en niet simpelweg een oefening in het formuleren van prompts. Wanneer ontwikkelteams afhankelijk zijn van handmatig toezicht, regel-voor-regelcode-inspecties en zachte promptrichtlijnen, wordt de menselijke ontwikkelaar een synchroon knelpunt dat het opschalen van agenten beperkt. De overgang naar uitvoering met een hoge mate van autonomie vereist dat menselijk toezicht wordt vervangen door programmatische verificatielussen, gestructureerde functionaliteitsmapping en deterministische begrenzingen voor continue integratie [CI]. Door architectuurinvarianten rechtstreeks vast te leggen in hulpmiddelen voor statische analyse en verificatieomgevingen tijdens uitvoering, kunnen ontwikkelteams de uitvoering delegeren aan parallelle cloudagenten en tegelijkertijd systematisch achteruitgang van de codebasis voorkomen.

Het vertrouwensknelpunt: waarom het opschalen van codeagenten een managementprobleem binnen softwareontwikkeling is#

1. Vat het kernprobleem samen#

Het belangrijkste knelpunt bij AI-ondersteunde softwarelevering is het gebrek aan vertrouwen van ontwikkelaars in de resultaten van agenten. Softwareagenten hallucineren regelmatig abstracties, stellen verkeerde diagnoses van grondoorzaken en stellen vol vertrouwen ongeldige oplossingen voor. Zoals Lauren Tan opmerkte tijdens een interview op het YouTube-kanaal Vision Sabbat, zullen agenten vaak "vol vertrouwen verklaren dat ze voor de honderdste keer het doorslaggevende bewijs hebben gevonden", terwijl het onderliggende probleem volledig onopgelost blijft.

Wanneer ontwikkelteams het gebruik van agenten proberen op te schalen via traditioneel programmeren in duo's waarbij een mens betrokken blijft, bereikt de werkstroom snel een harde bovengrens. Als een ontwikkelaar elke gegenereerde coderegel moet inspecteren, lokale builds handmatig moet testen en codeverschillen moet verifiëren, wordt de menselijke ontwikkelaar het enige punt waar alles sequentieel moet worden verwerkt. Dit synchrone knelpunt beperkt opschaling tot niet meer dan één of twee lokale agenten en verhindert echte parallellisatie binnen ontwikkelwerkstromen.

2. Leg de managementanalogie vast#

Om deze operationele dynamiek te analyseren, trok Lauren Tan een directe parallel tussen het aansturen van AI-codeagenten en het aansturen van menselijke softwareontwikkelaars. In traditioneel ontwikkelmanagement vervalt een manager die geen vertrouwen heeft in rechtstreeks ondergeschikte medewerkers onvermijdelijk in micromanagement: meekijken over de schouders van ontwikkelaars, samenvoegverzoeken voortdurend controleren en elke coderegel inspecteren om productie-uitval te voorkomen.

       HIGH |                                     [ Fleet Autonomy ]
            |                                     Auto-merging PRs &
            |                                     Cloud Parallelization
   TRUST    |                                  /
            |                             /
            |                        /
            |   [ Micromanagement ]
        LOW |   Manual Prompting & 1-in-Loop
            +---------------------------------------------------
                LOW                                     HIGH
                               VELOCITY

Het opschalen van agentautonomie vereist een stijging langs wat Tan de "vertrouwenscurve" noemt. In de eerste fase van agentadoptie werken ontwikkelaars synchroon binnen de uitvoeringslus, waarbij ze individuele agenten handmatig prompts geven en elk codeverschil inspecteren. Het beklimmen van de vertrouwenscurve vereist ontwikkelsystemen die objectieve, geautomatiseerde verificatie van agentresultaten bieden. Het opbouwen van veel vertrouwen verschuift het organisatieparadigma van synchroon micromanagement naar asynchrone delegatie, waardoor autonome vloten van cloudagenten zelfstandig code kunnen bouwen, testen en samenvoegen.

Programmatische verificatie en functionaliteitsmapping: de agentlus sluiten#

1. Leg het stapsgewijze verificatiemechanisme uit#

In ontwikkelarchitecturen met agenten wordt programmatische verificatie gedefinieerd als het aanbieden van expliciete uitvoeringshulpmiddelen waarmee agenten rechtstreeks kunnen communiceren met de uitvoeringsomgevingen van doelapplicaties. In plaats van een groot taalmodel [LLM] te vragen te raden of zijn code correct werkt, stelt een programmatische verificatielus de agent in staat builds uit te voeren, uitvoeringsomgevingen te inspecteren, prestatietraces van de centrale verwerkingseenheid [CPU] vast te leggen, momentopnamen van het heapgeheugen te analyseren en mobiele of browsersimulatoren aan te sturen. Voor web- en desktopapplicaties gebruiken agenten vaardigheden die zijn gebouwd op protocollen zoals het Chrome DevTools Protocol [CDP] om de gebruikersinterface [UI] programmatisch te bedienen.

Lauren Tan illustreerde dit mechanisme met een culinaire analogie: vertrouwen op een agent zonder programmatische verificatie is vergelijkbaar met een restaurantmanager die papieren recepten leest om te raden of een gerecht goed smaakt, terwijl programmatische verificatie de chef-kok uitrust met keukenwerkstations om tijdens de bereiding voortdurend te proeven, meten en bijsturen. Door agenten uitvoeringshulpmiddelen te geven, wordt de terugkoppelingslus automatisch gesloten. Hoewel verificatie geen architecturale elegantie garandeert, valideert zij deterministisch de correctheid van het gedrag voordat menselijke codebeoordeling plaatsvindt.

2. Beschrijf de architectuur van de functionaliteitskaart#

Een cruciaal onderdeel van programmatische verificatie dat is geïntroduceerd in Tans opensourceplug-in PStack (Potato Stack), een hulpmiddel voor ontwikkelaarsvaardigheden waarvan de naam een woordspeling op Gary Tans GStack is, is de "functionaliteitskaart". De functionaliteitskaart lost de uitdaging van navigatie door de codebasis op waarmee agenten worden geconfronteerd wanneer ze fouten proberen op te lossen of functionaliteiten proberen te implementeren in complexe systemen.

+-----------------------------------------------------------------------+
|                             FEATURE MAP                               |
+-----------------------------------------------------------------------+
|  User Context / Vague Report: "Left sidebar is laggy on click"         |
+-----------------------------------------------------------------------+
                                  |
                                  v
+-----------------------------------------------------------------------+
|  DOM Attributes & Selectors : [data-testid="sidebar-toggle"]          |
|  Keyboard Shortcuts         : Cmd+B / Ctrl+B                          |
|  Code Base Location         : src/components/sidebar/Sidebar.tsx      |
|  CDP Execution Action       : cdp.click('#sidebar-toggle')            |
+-----------------------------------------------------------------------+

Wanneer gebruikers gebrekkige, dubbelzinnige foutmeldingen indienen, zoals een Slack-schermafbeelding met alleen de aantekening "???", heeft een agent zonder structurele context moeite om de betrokken componenten te vinden. Een functionaliteitskaart overbrugt deze kloof expliciet door UI-elementen rechtstreeks te koppelen aan bestandspaden in de codebasis, attributen van het documentobjectmodel [DOM], testidentificatoren, sneltoetsen en CDP-uitvoeringsselectors.

Via vaardigheden zoals create_verification_skill en maintain_verification_skill binnen PStack analyseren agenten systematisch codebasissen om gestructureerde functionaliteitsregisters op te bouwen. Door een dubbelzinnige foutmelding te verwerken, kan de agent de functionaliteitskaart raadplegen, rechtstreeks naar de betreffende UI-elementen navigeren, interactiestromen via CDP uitvoeren, prestatiemaatstaven vastleggen en verifiëren dat het defect is opgelost.

3. Beschrijf de evaluatie en het onderhoud van agentvaardigheden#

Om agenthulpmiddelen en -vaardigheden op termijn te onderhouden, moeten ontwikkelteams geautomatiseerde evaluatiekaders inzetten, die functioneren als eenheidstests voor AI-agentvaardigheden. Het evaluatiedraaiboek volgt een uitvoeringspatroon met vier fasen:

  1. Generatie van beoordelingscriteria: Een coördinerende agent stelt een expliciet beoordelingskader vast dat het verwachte gedrag van hulpmiddelen en kwantitatieve scorecriteria definieert.
  2. Uitvoering in geïsoleerde omgevingen: Subagenten voeren taken uit in geïsoleerde tijdelijke mappen met willekeurig toegewezen, versluierde namen. Het versluieren van mapnamen is strikt vereist, omdat LLMs kunnen detecteren wanneer ze zich binnen een evaluatieomgeving bevinden en hun uitvoeringsgedrag kunnen aanpassen, waardoor ernstige evaluatievertekening ontstaat.
  3. Matrixevaluatie met meerdere modellen: Om scorevertekening door één model te elimineren, beoordelen beoordelingsagenten die draaien binnen een matrix van verschillende basismodellen de prestaties van subagenten aan de hand van het beoordelingskader van de coördinator.
  4. Optimalisatielussen met stapsgewijze verbetering: Geautomatiseerde optimalisatielussen, zoals het uitvoeren van /loop in Cursor, verfijnen voortdurend vaardigheidsinstructies en hulpmiddelparameters totdat de beoogde evaluatiescores, bijvoorbeeld 10 van de 10, binnen de volledige modelmatrix worden bereikt.

Tan benadrukte dat het onderhouden van agentvaardigheden voortdurende menselijke observatie en technisch beoordelingsvermogen vereist. Ontwikkelaars moeten actief meekijken en bijsturen, en tijdens de ontwikkeling van vaardigheden logboeken van hulpmiddelaanroepen en denkblokken van agenten inspecteren om subtiele faalwijzen te identificeren en corrigerende instructies vast te leggen in blijvende vaardigheden.

Harde architecturale begrenzingen: van zachte prompts naar CI-handhaving#

1. Vergelijk zachte regels met harde deterministische beperkingen#

Uitsluitend vertrouwen op zachte promptbeperkingen, zoals markdown-stijlgidsen, promptregels of instructiebestanden AGENTS.md, leidt onvermijdelijk tot achteruitgang van de codebasis. Wanneer onbeperkte agenten de weg van de minste weerstand volgen om lokale taken af te ronden, genereren ze een "organische architectuur" die wordt gekenmerkt door ongeldige abstracties, gedupliceerde logica en opgebouwde technische schuld.

Om de structurele integriteit op lange termijn te behouden, moeten softwarearchitecturen het centrale ontwerpparadigma van Lauren Tan implementeren: omdat agenten van nature structurele sluiproutes nemen, moet de architectuur van de codebasis zo worden ontworpen dat de kortste weg structureel de beste en juiste weg is. Ontwikkelteams moeten dit paradigma afdwingen via een gelaagd begrenzingskader dat de afhankelijkheid verschuift van zachte richtlijnen naar harde CI-controles.

Laag Handhavingsniveau Mechanisme / Hulpmiddelen Kenmerken
1. Architectuur en inkapseling van de codebasis Hard (deterministisch) Functionaliteiten bijeen plaatsen, strikte mapgrenzen, aangepaste importregels Voorkomt architecturale antipatronen structureel door de kortste weg tot de juiste weg te maken
2. Statische analyse en compilerdiagnostiek Hard (deterministisch) Strikte compilers, bijvoorbeeld de leencontrole van Rust, aangepaste lintprogramma's, CI-controles Laat builds deterministisch mislukken bij schendingen van invarianten vóór menselijke beoordeling
3. Geautomatiseerde codebeoordeling Zacht / semideterministisch AI-codebeoordelaars, bijvoorbeeld Bugbot, geautomatiseerde PR-analyse Detecteert contextuele defecten tijdens PR-validatie
4. Agentvaardigheden en stijlgidsen Zacht (niet-deterministisch) Markdown-regels, promptinstructies, stijlgidsen Worden gemakkelijk genegeerd of inconsistent toegepast door modellen

Hoewel zachte richtlijnen in de lagen 3 en 4 nuttige context bieden, zijn harde statische analyse en architecturale inkapseling in de lagen 1 en 2 verplicht om te garanderen dat autonome agenten geen ongeldige code kunnen samenvoegen.

2. Analyseer de casestudy van de "Dune"-architectuur#

De praktische implementatie van deterministische begrenzingen wordt gedemonstreerd in de herstructurering van de Grokbot-desktopapplicatie. Grokbot is gebouwd met "Dune", een gespecialiseerd intern raamwerk dat wordt omschreven als Next.js voor Electron-applicaties en expliciet is ontworpen voor agentgestuurde softwarelevering.

Om de prestaties tijdens de uitvoering van applicaties te beschermen en terugkerende faalwijzen van agenten te elimineren, dwingt de Dune-architectuur strikte deterministische regels af binnen CI-pijplijnen:

  • Verbod op React-hooks: De useEffect-hook van React is volledig verboden binnen de codebasis om fouten bij toestandsynchronisatie en onbedoelde herweergaven te voorkomen. CI-builds mislukken onmiddellijk als useEffect wordt gedetecteerd.
  • Verbod op commentaar binnen de code: Commentaar in applicatiecode is strikt verboden. Tan merkte op dat agenten regelmatig historisch commentaar genereren of tijdelijke opmerkingen uit de beoordeling van samenvoegverzoeken verkeerd interpreteren, bijvoorbeeld door een enkele beoordelingsopmerking zoals "Lauren zei dat je dit nooit moet doen" om te zetten in een statische codeopmerking. Hierdoor worden permanente globale beperkingen gehallucineerd en raken de contextvensters van modellen vervuild. Het verbieden van codecommentaar dwingt zelfdocumenterende code af en voorkomt achteruitgang van de context.
  • Afgedwongen isolatie van procesgrenzen: Electron-applicaties vereisen een strikte scheiding tussen het hoofdproces van Node en de UI-thread van de renderer. Om het uitvoeringsbudget van 16 milliseconden per beeld te beschermen dat vereist is voor soepele prestaties van 60 beelden per seconde [FPS], zijn rekenintensieve bewerkingen en invoer-/uitvoertaken [IO] verboden op de rendererthread. Dune dwingt dit af door logica te isoleren in de mappen electron_main en electron_renderer, met geautomatiseerde CI-controles van afhankelijkheidsgrafen om imports tussen mappen te blokkeren.

Automatisering van cloudagenten en sectorbrede productimplicaties#

1. Autonome bugreproductie en cloudwerkstromen#

Het opzetten van lokale verificatietools en strikte vangrails voor continue integratie maakt het mogelijk om softwarelevering te laten overgaan van lokale promptinvoer naar autonome agentvloten die in de cloud worden gehost. Deze verschuiving wordt geïllustreerd door interne cloudautomatiseringsagenten zoals "Benny" bij Cursor.

  [ User Feedback ] (Slack / Support Channels)
         |
         v
  [ Benny Cloud Agent ] (Spawns Isolated Cursor Cloud Environment)
         |
         v
  [ Execute Verification Skill ] (Launches App, Simulates UI Input)
         |
         +---> Bug Reproduced? ---> Yes ---> Generate Fix & Submit PR
         |
         +---> Already Fixed on Main? ---> Confirm Resolution & Notify Team

Benny verwerkt automatisch onbewerkte gebruikersfeedback en defectmeldingen uit Slack-kanalen. Na ontvangst van een melding start Benny een geïsoleerde desktopinstantie van Cursor in de cloud, voert de applicatie uit en zet opgeslagen verificatievaardigheden in om het gemelde defect programmatisch te reproduceren.

Door te werken in een geïsoleerde omgeving met volledige verificatiemogelijkheden kan Benny zelfstandig bepalen of een probleem nog bestaat of al is opgelost op de hoofdbranch. Deze automatisering maakt het overbodig dat menselijke ontwikkelaars handmatig proberen gebruikersmeldingen van lage kwaliteit te reproduceren.

2. Democratisering van ontwikkeling voor niet-technische functies#

Deterministische vangrails voor continue integratie veranderen de operationele dynamiek van productontwikkelingsorganisaties fundamenteel. Wanneer architecturale invarianten, geheugengrenzen en prestatiebudgetten deterministisch worden afgedwongen door compilers en scripts voor continue integratie, kunnen niet-technische medewerkers—waaronder productmanagers, ontwerpers van gebruikerservaringen en medewerkers voor marktintroductie—veilig functionaliteiten ontwikkelen en pullverzoeken voor productie indienen.

Omdat de infrastructuur implementaties die niet aan de eisen voldoen automatisch afwijst, kunnen niet-technische bijdragers functionele verbeteringen bouwen via interfaces in natuurlijke taal zoals Grokbot, zonder de stabiliteit van de codebasis of de prestatiebudgetten in gevaar te brengen.

Dit operationele model brengt specifieke economische afwegingen en afwegingen rond het rendement op investeringen met zich mee:

  • Initiële kapitaaluitgaven voor tokens: Het bouwen van uitgebreide verificatiesuites, het uitvoeren van evaluatiematrices met meerdere agenten en het doorvoeren van structurele herstructureringen vereisen aanzienlijke initiële tokenuitgaven. Het herstructureren van de Grokbot-applicatie naar de Dune-architectuur vereiste meer dan 600 afzonderlijke pullverzoeken.
  • Efficiëntiewinst bij arbeid: Hoge initiële tokenuitgaven worden gecompenseerd door drastische verminderingen van de menselijke ontwikkelinspanning. Uitvoeringspijplijnen voor agenten met een hoge capaciteit stellen organisaties in staat met kleine teams te werken en de organisatorische overhead van grote ontwikkelafdelingen te vermijden. De economische haalbaarheid van doorlopende beoordelingslussen en evaluatiematrices voor agenten wordt verder versterkt door geavanceerde modellen zoals Grok 4.6, dat de tokenprijzen van versie 4.5 handhaaft en tegelijkertijd betere prestaties op referentietests levert.

Architecturale beperkingen en openstaande technische vragen#

1. Belangrijkste beperkingen en randgevallen documenteren#

Ondanks de snelheidsverbeteringen die worden bereikt met zeer autonome agentvloten, brengen de huidige architectuurpatronen expliciete technische beperkingen en afwegingen met zich mee:

  • Initiële tokenkosten: Het bouwen van doorlopende verificatiepijplijnen en het uitvoeren van herstructureringen met vele honderden pullverzoeken verbruikt enorme hoeveelheden tokens. Voor teams met beperkte tokenbudgetten kan het kapitaal dat nodig is om verificatietools te bouwen een aanzienlijke drempel vormen voordat rendement op de investering wordt gerealiseerd.
  • Risico's bij prototyping vanaf nul: Het snel maken van applicatieprototypes zonder structurele vangrails ("programmeren op gevoel") veroorzaakt ernstige architecturale technische schuld. Bij gebrek aan expliciete inkapselingsgrenzen en statische beperkingen kiezen agenten voor gemakkelijke kortere routes die codebases snel onbeheersbaar maken, waardoor uiteindelijk omvangrijke herstructureringen met vele honderden pullverzoeken nodig zijn om dit te herstellen.
  • Onderhoudslast en vereiste technische oordeelskracht: Geautomatiseerde verificatiesystemen nemen de noodzaak van ervaren technisch oordeelsvermogen niet weg. Het opzetten van evaluaties, het bijwerken van functionaliteitsoverzichten en het vaststellen van beperkingen voor continue integratie vereisen diepgaande domeinkennis en actieve bijsturing vanaf de zijlijn.

Kerncijfers#

  • 1,000 pullverzoeken: Aantal pullverzoeken dat Lauren Tan in de vorige maand met autonome agenten bij Cursor heeft laten integreren.
  • Bijna 800 pullverzoeken: Aantal pullverzoeken dat Lauren Tan in de huidige maand heeft laten integreren (tot en met dag 12 van de maand).
  • 20 pullverzoeken: Aantal door agenten gegenereerde pullverzoeken dat gedurende één nacht automatisch werd samengevoegd en op één dag op de hoofdbranch werd geverifieerd.
  • 600+ pullverzoeken: Aantal pullverzoeken dat is uitgevoerd om de volledige herstructurering van de architectuur van de Grokbot-codebasis te voltooien.
  • 16 milliseconden: Maximaal uitvoeringsvenster per beeld dat nodig is op de renderthread van Electron om soepele prestaties van de gebruikersinterface met 60 beelden per seconde te behouden.
  • 5 maanden geleden: Moment waarop Lauren Tan bij Cursor begon, waarbij zij aanvankelijk een lage productiviteit ervoer tijdens het opbouwen van vertrouwen in agenten en het ontwikkelen van verificatievaardigheden.
  • Grok 4.6: Nieuw aangekondigde modelversie die de tokenkosten van modelversie 4.5 handhaaft en tegelijkertijd de prestaties op referentietests verbetert.

Wat dit beeld zou veranderen#

  1. Verschuiving naar in de compiler ingebouwde vangrails voor agenten: Brede invoering van strikt gecompileerde talen met strikt geheugeneigenaarschap en strikte typesystemen (zoals Rust) in plaats van dynamische softwareframeworks, waarbij structurele handhaving verschuift van aangepaste scripts voor continue integratie naar rechtstreekse compilerdiagnostiek.
  2. Standaardisatie van programmatische verificatieprotocollen: Brede invoering in de sector van uniforme, platformonafhankelijke verificatiestandaarden tussen agenten en gebruikersinterfaces, die verder gaan dan het Chrome DevTools Protocol, om desktop-, mobiele en webinterfaces rechtstreeks toegankelijk te maken voor agenten op basis van kunstmatige intelligentie.
  3. Brede invoering van autonoom samenvoegen via continue integratie: Overgang van reguliere commerciële softwareteams van pijplijnen voor handmatige codebeoordeling naar volledig geautomatiseerde samenvoegwachtrijen voor continue integratie, aangestuurd door synthetische evaluatiescores en doorlopende integratietests.
  4. Verlaging van tokenkosten bij evaluaties met meerdere agenten: Aanzienlijke structurele verlagingen van de inferentiekosten van basismodellen, waardoor ontwikkelteams buiten grote ondernemingen continu en tegen economisch haalbare kosten beoordelingsmatrices met meerdere agenten en optimalisatielussen via stapsgewijze verbetering kunnen uitvoeren.

Wilt u meer weten over de implementatie van geavanceerde ontwikkelraamwerken voor kunstmatige intelligentie en autonome uitvoeringspijplijnen? Bekijk dan het opensourceonderzoek op de website van DeepValues Research of probeer vandaag nog de DeepValues-app.

Geraadpleegde bronnen#

Lauren Tan - SpaceXAI engineer, interview published on YouTube channel Vision Sabbat

Kijken

Bronlinks

Kijken & luisteren

Onderzoekstekst onder CC BY 4.0, citeer als: DeepValues Research, Autonome codeagenten opschalen: hoe verificatielussen en strikte CI-beveiligingskaders snelle softwarelevering mogelijk maken, https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-nl/

Gratis wekelijkse e-mail

Margin of Safety Weekly

Elke zaterdag een e-mail: de temperatuur van de markt, wat grote beleggers kochten en verkochten (13F-meldingen), het nieuwe onderzoek van de week en onze video's en podcasts — gratis, geen account nodig.

Send me the DeepValues Margin of Safety Weekly, one email every Saturday. I can unsubscribe at any time. Information only, not investment advice. Privacy

Ga verder

Voer deze analyse in 2 minuten uit voor elk aandeel

Deep Value Intelligence, de AI-analist met meerdere AI-agenten achter dit rapport, maakt op verzoek hetzelfde rapport voor elk beursgenoteerd bedrijf.

Open Deep Value Intelligence

Volg 300+ aandelen in de DeepValues-app

Visies, intrinsieke waarde en de nieuwste rapporten op je telefoon.

Ontwikkelaars: visies en rapporten via de API

De fundamentele gegevens, intrinsieke waarden, visies en rapportlinks achter deze pagina's, als JSON.

API-documentatie

Meepraten