---
title: "Skalning av autonoma kodagenter: Hur verifieringsloopar och strikta skyddsräcken för kontinuerlig integration möjliggör snabb mjukvaruleverans"
author: "DeepValues Research"
publisher: "DeepValues Research (DeepValues / LuLu Ventures LLC)"
type: "Research article"
date: "2026-11-02"
language: "sv"
section: "Insights"
machine_translated: true
translation_method: "machine translation (gpt-6.1-sol, Azure OpenAI)"
translated_from: "https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents/"
original_url: "https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents/"
original_language: "en"
translated_on: "2026-11-15"
translation_note: "Machine-translated from the original report; the original is authoritative."
canonical_url: "https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-sv/"
markdown_url: "https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-sv/index.md"
license: "CC BY 4.0"
license_url: "https://creativecommons.org/licenses/by/4.0/"
cite_as: "DeepValues Research, Skalning av autonoma kodagenter: Hur verifieringsloopar och strikta skyddsräcken för kontinuerlig integration möjliggör snabb mjukvaruleverans, https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-sv/"
publisher_url: "https://deepvalues.ai"
app: "https://deepvalues.ai"
api: "https://app.deepvalues.ai/developers"
data_note: "Reports are dated snapshots. Current data via the DeepValues API: https://app.deepvalues.ai/developers"
disclaimer: "Educational research, not investment advice."
disclosure: "AI-assisted"
generated_by: "NotebookLM + DeepValues editors"
category: "ai"
sources:
  - title: "Lauren Tan - SpaceXAI engineer"
    url: "https://www.youtube.com/watch?v=EWSUvEyFwjc"
audio: "https://anchor.fm/s/119061124/podcast/play/128667982/https%3A%2F%2Fd3ctxlq1ktw2nl.cloudfront.net%2Fstaging%2F2026-10-3%2Fe64d5fed-62d8-b448-e1f2-97513e908b3f.m4a"
audio_kind: "podcast episode"
audio_page: "https://open.spotify.com/episode/4zd36X5aJZaVenfToy1SfN"
---
# Skalning av autonoma kodagenter: Hur verifieringsloopar och hårda CI-skyddsräcken möjliggör snabb programvaruleverans

Moderna programvaruutvecklingsorganisationer genomför ett grundläggande paradigmskifte, från detaljstyrd parprogrammering med artificiell intelligens [AI] till autonoma agentflottor som kan få hundratals till tusentals ändringsförslag [PR] införlivade per månad. Som Lauren Tan, ingenjör på SpaceXAI, har beskrivit är skalning av AI-genererad kod framför allt ett problem inom ledning av utvecklingsarbete, snarare än en enkel övning i att formulera instruktioner. När utvecklingsteam förlitar sig på manuell tillsyn, kodgranskning rad för rad och mjuka instruktionsriktlinjer blir den mänskliga utvecklaren en synkron flaskhals som begränsar agentskalningen. Övergången till högautonomt utförande kräver att mänsklig tillsyn ersätts med programmatiska verifieringsloopar, strukturerad funktionskartläggning och deterministiska skyddsräcken för kontinuerlig integration [CI]. Genom att koda in arkitekturinvarianter direkt i verktyg för statisk analys och verifieringsramverk för körning kan utvecklingsteam delegera utförandet till parallella molnagenter och samtidigt systematiskt förhindra att kodbasen försämras.

---

## Tillitsflaskhalsen: Varför skalning av kodagenter är ett problem inom ledning av utvecklingsarbete

### 1. Sammanfatta kärnproblemet
Den främsta friktionspunkten i AI-assisterad programvaruleverans är utvecklarnas bristande tillit till agenternas resultat. Programvaruagenter hallucinerar ofta abstraktioner, feldiagnostiserar grundorsaker och föreslår självsäkert ogiltiga korrigeringar. Som Lauren Tan konstaterade under en intervju på YouTube-kanalen Vision Sabbat kommer agenter ofta att ”självsäkert hävda att de har hittat det avgörande beviset för hundrade gången”, medan det underliggande problemet fortfarande är helt olöst.

När utvecklingsteam försöker skala agentanvändningen genom traditionell parprogrammering med en människa i loopen når arbetsflödet snabbt ett hårt tak. Om en ingenjör måste granska varje genererad kodrad, manuellt testa lokala byggen och verifiera kodskillnader blir den mänskliga utvecklaren en enda serialiseringspunkt. Denna synkrona flaskhals begränsar skalningen till en eller två lokala agenter och förhindrar verklig parallellisering av utvecklingsarbetsflöden.

### 2. Etablera ledningsanalogin
För att analysera denna operativa dynamik drog Lauren Tan en direkt parallell mellan att leda AI-kodagenter och att leda mänskliga programvaruutvecklare. Inom traditionell ledning av utvecklingsarbete faller en chef som saknar tillit till sina direkt underställda medarbetare oundvikligen tillbaka på detaljstyrning – att titta över utvecklarnas axlar, kontinuerligt granska ändringsförslag och inspektera varje kodrad för att förhindra driftavbrott i produktion.

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

Skalning av agentautonomi kräver att man tar sig uppför det som Tan definierar som ”tillitskurvan”. I den inledande fasen av agentinförandet arbetar utvecklarna synkront inne i utförandeloopen, ger enskilda agenter instruktioner manuellt och granskar varje kodskillnad. Att ta sig uppför tillitskurvan kräver utvecklingssystem som tillhandahåller objektiv, automatiserad verifiering av agenternas resultat. Hög tillit förskjuter organisationens paradigm från synkron detaljstyrning till asynkron delegering, vilket gör det möjligt för autonoma flottor av molnagenter att självständigt bygga, testa och slå samman kod.

---

## Programmatisk verifiering och funktionskartläggning: Att sluta agentloopen

### 1. Förklara verifieringsmekanismen steg för steg
I agentbaserade utvecklingsarkitekturer definieras programmatisk verifiering som att ge agenter uttryckliga körverktyg för att interagera direkt med målapplikationernas körmiljöer. I stället för att be en stor språkmodell [LLM] gissa om dess kod fungerar korrekt ger en programmatisk verifieringsloop agenten möjlighet att köra byggen, inspektera körmiljöer, samla in prestandaspår från centralprocessorn [CPU], analysera ögonblicksbilder av heapminnet och styra mobil- eller webbläsarsimulatorer. För webb- och skrivbordsapplikationer använder agenter färdigheter byggda ovanpå protokoll som Chrome DevTools Protocol [CDP] för att programmatiskt styra användargränssnittet [UI].

Lauren Tan illustrerade denna mekanism med en kulinarisk analogi: att förlita sig på en agent utan programmatisk verifiering motsvarar att en restaurangchef läser recept på papper för att gissa om en rätt smakar gott, medan programmatisk verifiering ger kökschefen arbetsstationer där maten kontinuerligt kan smakas av, mätas och justeras under tillagningen. Att ge agenter körverktyg sluter återkopplingsloopen automatiskt. Även om verifiering inte garanterar arkitektonisk elegans validerar den deterministiskt korrekt beteende innan mänsklig kodgranskning sker.

### 2. Beskriv funktionskartans arkitektur i detalj
En kritisk komponent i programmatisk verifiering som introducerats i Tans insticksmodul PStack (Potato Stack) med öppen källkod – ett färdighetsverktyg för utvecklare vars namn är en ordlek på Gary Tans GStack – är ”funktionskartan”. Funktionskartan löser de navigationsproblem i kodbasen som agenter möter när de försöker åtgärda fel eller implementera funktioner i komplexa system.

```
+-----------------------------------------------------------------------+
|                             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')            |
+-----------------------------------------------------------------------+
```

När användare skickar in tvetydiga felrapporter av låg kvalitet – exempelvis en Slack-skärmbild som endast har kommenterats med ”???” – har en agent utan strukturell kontext svårt att hitta de berörda komponenterna. En funktionskarta överbryggar uttryckligen denna klyfta genom att koppla UI-element direkt till kodbasens filsökvägar, attribut i dokumentobjektmodellen [DOM], testidentifierare, kortkommandon och CDP-selektorer för körning.

Genom färdigheter som `create_verification_skill` och `maintain_verification_skill` i PStack analyserar agenter systematiskt kodbaser för att skapa strukturerade funktionsregister. När en tvetydig felrapport läses in kan agenten korsreferera funktionskartan, navigera direkt till de berörda UI-elementen, köra interaktionsflöden via CDP, samla in prestandamått och verifiera att felet har åtgärdats.

### 3. Beskriv utvärdering och underhåll av agentfärdigheter i detalj
För att underhålla agentverktyg och agentfärdigheter över tid måste utvecklingsteam införa automatiserade utvärderingsramverk, som fungerar som enhetstester för AI-agentfärdigheter. Utvärderingsmetodiken följer ett utförandemönster i fyra steg:

1. **Generering av bedömningsmatris:** En samordningsagent upprättar en uttrycklig bedömningsmatris som definierar förväntade verktygsbeteenden och kvantitativa poängkriterier.
2. **Utförande i isolerade miljöer:** Underagenter utför uppgifter i isolerade tillfälliga kataloger som tilldelats slumpmässiga, fördunklade namn. Fördunkling av katalognamn är ett strikt krav eftersom LLM kan upptäcka när de befinner sig i ett utvärderingsramverk och ändra sitt utförandebeteende, vilket introducerar allvarlig utvärderingsbias.
3. **Matrisutvärdering med flera modeller:** För att eliminera poängsättningsbias från en enskild modell utvärderar bedömningsagenter som körs över en matris av olika grundmodeller underagenternas prestationer mot samordningsagentens bedömningsmatris.
4. **Optimeringsloopar med stegvis förbättring:** Automatiserade optimeringsloopar (som att köra `/loop` i Cursor) förfinar kontinuerligt färdighetsinstruktioner och verktygsparametrar tills de eftersträvade utvärderingspoängen (t.ex. 10 av 10) uppnås över hela modellmatrisen.

Tan betonade att underhåll av agentfärdigheter kräver kontinuerlig mänsklig observation och ingenjörsmässigt omdöme. Utvecklare måste agera som aktiva medförare och granska loggar över verktygsanrop och agenternas resonemangsblock under färdighetsutvecklingen för att identifiera subtila felmönster och formalisera korrigerande instruktioner i beständiga färdigheter.

---

## Hårda arkitektoniska skyddsräcken: Från mjuka instruktioner till CI-kontroll

### 1. Jämför mjuka regler med hårda deterministiska begränsningar
Att uteslutande förlita sig på mjuka instruktionsbegränsningar – exempelvis stilguider i markdown, instruktionsregler eller instruktionsfiler som `AGENTS.md` – leder oundvikligen till att kodbasen försämras. När obegränsade agenter väljer minsta motståndets väg för att slutföra lokala uppgifter skapar de ”organisk arkitektur” som kännetecknas av ogiltiga abstraktioner, duplicerad logik och ackumulerad teknisk skuld.

För att upprätthålla långsiktig strukturell integritet måste programvaruarkitekturer implementera Lauren Tans centrala designparadigm: eftersom agenter naturligt tar strukturella genvägar måste kodbasens arkitektur utformas så att **den kortaste vägen strukturellt är den bästa och korrekta vägen**. Utvecklingsteam måste upprätthålla detta paradigm genom ett skiktat ramverk av skyddsräcken som flyttar tyngdpunkten från mjuka riktlinjer till hårda CI-kontroller.

| Skikt | Kontrollnivå | Mekanism / Verktyg | Egenskaper |
| :--- | :--- | :--- | :--- |
| **1. Kodbasarkitektur och inkapsling** | Hård (deterministisk) | Samlokalisering av funktioner, strikta kataloggränser, anpassade importregler | Förhindrar arkitektoniska antimönster strukturellt genom att göra den kortaste vägen till den korrekta vägen |
| **2. Statisk analys och kompilatordiagnostik** | Hård (deterministisk) | Strikta kompilatorer (t.ex. Rusts lånekontroll), anpassade kodkontrollverktyg, CI-kontroller | Underkänner byggen deterministiskt vid invariantbrott före mänsklig granskning |
| **3. Automatiserad kodgranskning** | Mjuk / semideterministisk | AI-kodgranskare (t.ex. Bugbot), automatiserad PR-analys | Upptäcker kontextberoende fel under PR-validering |
| **4. Agentfärdigheter och stilguider** | Mjuk (icke-deterministisk) | Markdown-regler, instruktioner till modellen, stilguider | Ignoreras lätt eller tillämpas inkonsekvent av modeller |

Medan mjuka riktlinjer i skikt 3 och 4 ger användbar kontext är hård statisk analys och arkitektonisk inkapsling i skikt 1 och 2 obligatoriska för att garantera att autonoma agenter inte kan slå samman ogiltig kod.

### 2. Analysera fallstudien om ”Dune”-arkitekturen
Den praktiska implementeringen av deterministiska skyddsräcken demonstreras i omstruktureringen av skrivbordsapplikationen Grokbot. Grokbot byggdes med ”Dune”, ett specialiserat internt ramverk som beskrivs som Next.js för Electron-applikationer och uttryckligen utformats för agentdriven programvaruleverans.

För att skydda applikationens körprestanda och eliminera återkommande felmönster hos agenter upprätthåller Dune-arkitekturen strikta deterministiska regler i CI-pipelines:

* **Förbud mot React-krokar:** Reacts `useEffect`-krok är helt förbjuden i hela kodbasen för att förhindra fel i tillståndssynkronisering och oavsiktliga omrenderingar. CI-byggen underkänns omedelbart om `useEffect` upptäcks.
* **Förbud mot kommentarer direkt i koden:** Kommentarer i applikationskoden är strikt förbjudna. Tan observerade att agenter ofta genererar historiska kommentarer eller misstolkar tillfälliga granskningskommentarer i ändringsförslag – exempelvis genom att omvandla en enskild granskningsanmärkning som `"Lauren sade att man aldrig ska göra detta"` till en statisk kodkommentar – vilket hallucinerar permanenta globala begränsningar och förorenar modellernas kontextfönster. Ett förbud mot kodkommentarer tvingar fram självdokumenterande kod och förhindrar försämrad kontext.
* **Obligatorisk isolering vid processgränser:** Electron-applikationer kräver strikt separation mellan huvudprocessen i Node och renderarens UI-tråd. För att skydda körbudgeten på 16 millisekunder per bildruta som krävs för att upprätthålla jämn prestanda vid 60 bildrutor per sekund [FPS] är beräkningstunga operationer och in-/utmatningsuppgifter [IO] förbjudna på renderartråden. Dune upprätthåller detta genom att isolera logik i katalogerna `electron_main` och `electron_renderer` och använda automatiserade kontroller av beroendegrafer i CI för att blockera importer mellan katalogerna.

---

## Automatisering med molnagenter och produktkonsekvenser för hela branschen
### 1. Autonom felreproduktion och molnbaserade arbetsflöden
Införandet av lokala verifieringsverktyg och strikta CI-skyddsräcken gör det möjligt för programvaruleveranser att övergå från lokal promptning till molnbaserade autonoma agentflottor. Denna förändring exemplifieras av interna molnautomatiseringsagenter som ”Benny” hos 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 hämtar automatiskt obearbetad användaråterkoppling och felrapporter från Slack-kanaler. När en rapport tas emot startar Benny en isolerad skrivbordsinstans av Cursor i molnet, kör applikationens exekveringsmiljö och använder lagrade verifieringsfärdigheter för att programmatiskt återskapa det rapporterade felet.

Genom att arbeta i en isolerad miljö utrustad med fullständiga verifieringsfunktioner kan Benny självständigt avgöra om ett problem kvarstår eller redan har lösts i huvudgrenen. Denna automatisering undanröjer behovet av att mänskliga utvecklare lägger manuellt arbete på att försöka återskapa användarrapporter av låg kvalitet.

### 2. Demokratisering av utveckling bland roller utanför utvecklingsfunktionen
Deterministiska CI-skyddsräcken förändrar i grunden den operativa dynamiken i produktutvecklingsorganisationer. När arkitekturinvarianter, minnesgränser och prestandabudgetar upprätthålls deterministiskt av kompilatorer och CI-skript kan personal utanför utvecklingsfunktionen – däribland produktchefer [PMs], användarupplevelsedesigners [UX] och personal inom marknadsintroduktion [GTM] – tryggt skapa funktioner och lämna in ändringsförfrågningar för produktion.

Eftersom infrastrukturen automatiskt avvisar implementationer som inte uppfyller kraven kan icke-tekniska medarbetare bygga funktionella förbättringar genom naturliga språkgränssnitt som Grokbot utan att äventyra kodbasens stabilitet eller prestandabudgetar.

Denna operativa modell innebär specifika ekonomiska avvägningar och avvägningar kring avkastning på investeringar [ROI]:

* **Initiala kapitalutgifter för token:** Att bygga omfattande verifieringssviter, köra utvärderingsmatriser med flera agenter och genomföra strukturell omstrukturering kräver betydande initial tokenförbrukning. Omstruktureringen av Grokbot-applikationen till Dune-arkitekturen krävde över 600 enskilda ändringsförfrågningar.
* **Effektivitetsvinster i arbetsinsatsen:** Höga initiala tokenutgifter uppvägs av drastiska minskningar av mänskliga utvecklares kringarbete. Exekveringskedjor för agenter med hög kapacitet gör det möjligt för organisationer att arbeta med små team och undvika de organisatoriska omkostnaderna för stora utvecklingsavdelningar. Den ekonomiska genomförbarheten för kontinuerliga bedömningsloopar och agentutvärderingsmatriser förbättras ytterligare av ledande modeller som Grok 4.6, som behåller tokenprissättningen från version 4.5 samtidigt som den levererar högre prestanda i jämförelsetester.

---

## Arkitektoniska begränsningar och öppna utvecklingsfrågor

### 1. Dokumentera centrala begränsningar och gränsfall
Trots de hastighetsförbättringar som uppnås genom agentflottor med hög autonomi medför nuvarande arkitekturmönster tydliga utvecklingstekniska begränsningar och avvägningar:

* **Initial tokenkostnad:** Att bygga kontinuerliga verifieringskedjor och genomföra omstruktureringar som omfattar flera hundra ändringsförfrågningar förbrukar enorma tokenvolymer. För team med begränsade tokenbudgetar kan det kapital som krävs för att bygga verifieringsverktyg utgöra ett betydande hinder innan avkastning på investeringen uppnås.
* **Risker vid prototypframtagning från grunden:** Snabb prototypframtagning av applikationer utan strukturella skyddsräcken (”känslostyrd kodning”) skapar allvarlig arkitektonisk teknisk skuld. Utan uttryckliga inkapslingsgränser och statiska begränsningar väljer agenter bekväma genvägar som gör att kodbaser snabbt blir okontrollerbara och till slut kräver omfattande omstruktureringar med flera hundra ändringsförfrågningar för att rättas till.
* **Kringarbete för underhåll och omdöme:** Automatiserade verifieringssystem undanröjer inte behovet av seniora utvecklares omdöme. Att skapa utvärderingar, uppdatera funktionskartor och fastställa CI-begränsningar kräver djup domänexpertis och aktiv övervakning med löpande styrning.

---

## Nyckeltal

* **1,000 ändringsförfrågningar:** Antal ändringsförfrågningar som Lauren Tan fick införda under föregående månad med hjälp av autonoma agenter hos Cursor.
* **Nästan 800 ändringsförfrågningar:** Antal ändringsförfrågningar som Lauren Tan fick införda under innevarande månad (per månadens 12:e dag).
* **20 ändringsförfrågningar:** Antal agentgenererade ändringsförfrågningar som automatiskt slogs samman över natten och verifierades i huvudgrenen under en enda dag.
* **600+ ändringsförfrågningar:** Antal ändringsförfrågningar som genomfördes för att slutföra den fullständiga arkitekturomstruktureringen av Grokbot-kodbasen.
* **16 millisekunder:** Maximalt exekveringsfönster per bildruta som krävs på Electrons renderingstråd för att upprätthålla jämn gränssnittsprestanda på 60 bilder per sekund [FPS].
* **För 5 månader sedan:** Tidpunkt då Lauren Tan började hos Cursor och inledningsvis upplevde låg produktivitet medan hon byggde upp förtroendet för agenterna och de första verifieringsfärdigheterna.
* **Grok 4.6:** Nyligen tillkännagiven modellversion som behåller tokenkostnaden för modellversion 4.5 samtidigt som prestandan i jämförelsetester förbättras.

---

## Vad som skulle förändra denna bild

1. **Övergång till kompilatorinbyggda skyddsräcken för agenter:** Bred användning av strikt kompilerade språk med strikt minnesägande och strikta typsystem (som Rust) i stället för dynamiska programvaruramverk, vilket flyttar upprätthållandet av strukturella krav från anpassade CI-skript direkt till kompilatordiagnostik.
2. **Standardisering av programmatiska verifieringsprotokoll:** Bred branschanvändning av enhetliga, plattformsoberoende verifieringsstandarder mellan agenter och användargränssnitt utöver Chrome DevTools Protocol, för att göra skrivbords-, mobil- och webbgränssnitt direkt tillgängliga för AI-agenter.
3. **Utbredd autonom sammanslagning via CI:** Övergång bland etablerade kommersiella programvaruteam från manuella kodgranskningskedjor till helt automatiserade CI-sammanslagningsköer som drivs av syntetiska utvärderingspoäng och kontinuerliga integrationstester.
4. **Minskade tokenkostnader vid utvärderingar med flera agenter:** Betydande strukturella minskningar av inferenskostnaderna för grundmodeller, vilket gör det ekonomiskt möjligt för utvecklingsteam utanför storföretagen att kontinuerligt köra bedömningsmatriser med flera agenter och optimeringsloopar med stegvis förbättring.

För att lära dig mer om att implementera avancerade ramverk för AI-utveckling och autonoma exekveringskedjor kan du utforska forskningen med öppen källkod på DeepValues Researchs webbplats eller prova DeepValues-appen i dag.

---
## Källförteckning

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

## From DeepValues

- DeepValues app: intrinsic value, stances and the latest reports for 300+ stocks. [iPhone](https://apps.apple.com/us/app/deepvalues/id6775568608?utm_source=research&utm_medium=web&utm_campaign=markdown) · [Android](https://play.google.com/store/apps/details?id=app.deepvalues.android&referrer=utm_source%3Dresearch%26utm_medium%3Dweb%26utm_campaign%3Dmarkdown) · [Web](https://app.deepvalues.ai/?utm_source=research&utm_medium=web&utm_campaign=markdown)
- [Deep Value Intelligence](https://deepvalues.ai/?utm_source=research&utm_medium=web&utm_campaign=markdown): the multi-agent AI analyst behind these reports, for any listed company
- [Margin of Safety Weekly](https://app.deepvalues.ai/letter?utm_source=research&utm_medium=web&utm_campaign=markdown): free weekly email, every Saturday
- YouTube: videos on investing and on AI. [@TheDeepValues](https://www.youtube.com/@TheDeepValues?utm_source=research&utm_medium=web&utm_campaign=markdown) (investing) · [@deep-values](https://www.youtube.com/@deep-values?utm_source=research&utm_medium=web&utm_campaign=markdown) (AI)
- Podcasts: 6 shows in English and Chinese (Deep Values, 深度价值, Deep Values Frontier, 深度價值前沿, Deep Value Intelligence, 深度价值情报站). [all shows on Apple Podcasts](https://podcasts.apple.com/us/channel/deepvalues/id6826606342)
- Buffett Indicator: market-valuation gauge. [iPhone](https://apps.apple.com/us/app/buffett-indicator/id6747404614?utm_source=research&utm_medium=web&utm_campaign=markdown) · [Android (Buffett Indicator & Shiller PE)](https://play.google.com/store/apps/details?id=com.luluventures.bubblewatch.android&utm_source=research&utm_medium=web&utm_campaign=markdown)
