---
title: "Escalando agentes autônomos de código: como ciclos de verificação e regras rígidas de integração contínua permitem a entrega de software em alta velocidade"
author: "DeepValues Research"
publisher: "DeepValues Research (DeepValues / LuLu Ventures LLC)"
type: "Research article"
date: "2026-11-02"
language: "pt-BR"
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-pt/"
markdown_url: "https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-pt/index.md"
license: "CC BY 4.0"
license_url: "https://creativecommons.org/licenses/by/4.0/"
cite_as: "DeepValues Research, Escalando agentes autônomos de código: como ciclos de verificação e regras rígidas de integração contínua permitem a entrega de software em alta velocidade, https://research.deepvalues.ai/insights/2026-11-02-scaling-engineering-velocity-with-ai-agents-pt/"
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"
---
# Escalando Agentes Autônomos de Código: Como Ciclos de Verificação e Barreiras Rígidas de Integração Contínua Viabilizam a Entrega de Software em Alta Velocidade

As organizações modernas de engenharia de software estão realizando uma mudança fundamental de paradigma, passando da programação em pares com Inteligência Artificial micromanejada para frotas de agentes autônomos capazes de integrar centenas a milhares de solicitações de integração por mês. Como explicou Lauren Tan, engenheira da SpaceXAI, escalar a geração de código por inteligência artificial é sobretudo um problema de gestão de engenharia, e não um simples exercício de elaboração de instruções. Quando as equipes de engenharia dependem de supervisão manual, inspeções de código linha por linha e diretrizes flexíveis de instrução, o desenvolvedor humano se torna um gargalo síncrono que restringe a escalabilidade dos agentes. A transição para uma execução com alta autonomia exige substituir a supervisão humana por ciclos de verificação programática, mapeamento estruturado de funcionalidades e barreiras determinísticas de Integração Contínua. Ao codificar invariantes arquiteturais diretamente em ferramentas de análise estática e estruturas de verificação em tempo de execução, as equipes de engenharia podem delegar a execução a agentes paralelos na nuvem, evitando sistematicamente a degradação da base de código.

---

## O Gargalo da Confiança: Por Que Escalar Agentes de Código É um Problema de Gestão de Engenharia

### 1. Sintetizar o Problema Central
O principal ponto de atrito na entrega de software assistida por inteligência artificial é a ausência de confiança dos desenvolvedores nos resultados dos agentes. Agentes de software frequentemente alucinam abstrações, diagnosticam incorretamente as causas fundamentais e propõem correções inválidas com confiança. Como Lauren Tan observou durante uma entrevista no canal Vision Sabbat do YouTube, os agentes muitas vezes "afirmam com confiança que encontraram a prova definitiva pela centésima vez", enquanto o problema subjacente continua completamente sem solução.

Quando as equipes de engenharia tentam escalar o uso de agentes por meio da programação em pares tradicional com participação humana no ciclo, o fluxo de trabalho rapidamente atinge um limite rígido. Se um engenheiro precisa inspecionar cada linha de código gerada, testar manualmente compilações locais e verificar diferenças de código, o desenvolvedor humano se torna um ponto único de serialização. Esse gargalo síncrono restringe a expansão para além de um ou dois agentes locais, impedindo a verdadeira paralelização dos fluxos de trabalho de engenharia.

### 2. Estabelecer a Analogia com a Gestão
Para analisar essa dinâmica operacional, Lauren Tan traçou um paralelo direto entre gerenciar agentes de código de inteligência artificial e gerenciar engenheiros de software humanos. Na gestão tradicional de engenharia, um gestor que não confia em seus subordinados diretos inevitavelmente recorre ao microgerenciamento — acompanhando de perto os desenvolvedores, auditando continuamente solicitações de integração e inspecionando cada linha de código para evitar interrupções em produção.

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

Escalar a autonomia dos agentes exige subir o que Tan define como a "curva de confiança". Na fase inicial da adoção de agentes, os desenvolvedores operam de forma síncrona dentro do ciclo de execução, instruindo manualmente agentes individuais e inspecionando cada diferença de código. Subir a curva de confiança exige sistemas de engenharia que forneçam verificação objetiva e automatizada dos resultados dos agentes. Estabelecer um alto nível de confiança muda o paradigma organizacional do microgerenciamento síncrono para a delegação assíncrona, permitindo que frotas autônomas de agentes na nuvem compilem, testem e integrem código de forma independente.

---

## Verificação Programática e Mapeamento de Funcionalidades: Fechando o Ciclo do Agente

### 1. Explicar o Mecanismo de Verificação Passo a Passo
Nas arquiteturas de engenharia com agentes, a verificação programática é definida como o fornecimento aos agentes de ferramentas explícitas de execução para interagir diretamente com os ambientes de execução das aplicações-alvo. Em vez de pedir a um modelo de linguagem de grande porte que adivinhe se seu código funciona corretamente, um ciclo de verificação programática permite que o agente execute compilações, inspecione ambientes de execução, capture rastreamentos de desempenho da unidade central de processamento, analise instantâneos da memória dinâmica e opere simuladores móveis ou de navegador. Para aplicações de navegador e de computador, os agentes utilizam habilidades construídas sobre protocolos como o Chrome DevTools Protocol para controlar programaticamente a interface do usuário.

Lauren Tan ilustrou esse mecanismo com uma analogia culinária: depender de um agente sem verificação programática equivale a um gerente de restaurante ler receitas em papel para adivinhar se um prato está gostoso, enquanto a verificação programática equipa o chefe de cozinha com estações de trabalho para provar, medir e ajustar continuamente os alimentos durante o preparo. Conceder ferramentas de execução aos agentes fecha automaticamente o ciclo de retroalimentação. Embora a verificação não garanta elegância arquitetural, ela valida de forma determinística a correção comportamental antes da revisão humana do código.

### 2. Detalhar a Arquitetura do Mapa de Funcionalidades
Um componente essencial da verificação programática introduzido no complemento de código aberto PStack (Potato Stack) de Tan — uma ferramenta de habilidades para desenvolvedores cujo nome é um trocadilho com o GStack de Gary Tan — é o "mapa de funcionalidades". O mapa de funcionalidades resolve o desafio de navegação pela base de código que os agentes encontram ao tentar corrigir falhas ou implementar funcionalidades em sistemas complexos.

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

Quando os usuários enviam relatos de falhas ambíguos e de baixa qualidade — como uma captura de tela do Slack anotada apenas com "???" —, um agente sem contexto estrutural tem dificuldade para localizar os componentes afetados. Um mapa de funcionalidades preenche explicitamente essa lacuna ao mapear elementos da interface do usuário diretamente para caminhos de arquivos da base de código, atributos do modelo de objetos do documento, identificadores de teste, atalhos de teclado e seletores de execução do Chrome DevTools Protocol.

Por meio de habilidades como `create_verification_skill` e `maintain_verification_skill` no PStack, os agentes analisam sistematicamente as bases de código para construir registros estruturados de funcionalidades. A ingestão de um relato ambíguo de falha permite que o agente consulte o mapa de funcionalidades, navegue diretamente até os elementos-alvo da interface do usuário, execute fluxos de interação pelo Chrome DevTools Protocol, capture métricas de desempenho e verifique a resolução do defeito.

### 3. Detalhar a Avaliação e a Manutenção das Habilidades dos Agentes
Para manter as ferramentas e habilidades dos agentes ao longo do tempo, as equipes de desenvolvimento devem implantar estruturas automatizadas de avaliação, que funcionam como testes unitários para habilidades de agentes de inteligência artificial. O roteiro de avaliação segue um padrão de execução em quatro etapas:

1. **Geração da Rubrica:** Um agente coordenador estabelece uma rubrica explícita de avaliação que define os comportamentos esperados das ferramentas e os critérios quantitativos de pontuação.
2. **Execução em Ambiente Isolado:** Subagentes executam tarefas em diretórios temporários isolados, aos quais são atribuídos nomes aleatórios e ofuscados. A ofuscação dos diretórios é estritamente necessária porque modelos de linguagem de grande porte podem detectar quando estão dentro de uma estrutura de avaliação e alterar seu comportamento de execução, introduzindo um viés grave na avaliação.
3. **Avaliação Matricial com Múltiplos Modelos:** Para eliminar o viés de pontuação de um único modelo, agentes avaliadores executados em uma matriz de diferentes modelos fundacionais avaliam o desempenho dos subagentes com base na rubrica do coordenador.
4. **Ciclos de Otimização por Busca de Melhoria Local:** Ciclos automatizados de otimização (como executar `/loop` no Cursor) refinam continuamente as instruções das habilidades e os parâmetros das ferramentas até que as pontuações-alvo de avaliação (por exemplo, 10 de 10) sejam alcançadas em toda a matriz de modelos.

Tan enfatizou que a manutenção das habilidades dos agentes exige observação humana contínua e discernimento de engenharia. Os desenvolvedores devem atuar como supervisores ativos, inspecionando registros de chamadas de ferramentas e blocos de raciocínio dos agentes durante o desenvolvimento das habilidades para identificar modos sutis de falha e formalizar instruções corretivas em habilidades persistentes.

---

## Barreiras Arquiteturais Rígidas: Das Instruções Flexíveis à Imposição pela Integração Contínua

### 1. Contrastar Regras Flexíveis com Restrições Determinísticas Rígidas
Depender exclusivamente de restrições flexíveis nas instruções — como guias de estilo em markdown, regras de instrução ou arquivos de instruções `AGENTS.md` — inevitavelmente leva à degradação da base de código. Quando agentes sem restrições seguem o caminho de menor resistência para concluir tarefas localizadas, eles geram uma "arquitetura orgânica" caracterizada por abstrações inválidas, lógica duplicada e dívida técnica acumulada.

Para manter a integridade estrutural de longo prazo, as arquiteturas de software devem implementar o paradigma central de projeto de Lauren Tan: como os agentes naturalmente tomam atalhos estruturais, a arquitetura da base de código deve ser projetada de modo que **o caminho mais curto seja estruturalmente o melhor e o correto**. As equipes de engenharia devem impor esse paradigma por meio de uma estrutura de barreiras em camadas que transfira a dependência de diretrizes flexíveis para verificações rígidas de integração contínua.

| Camada | Nível de Imposição | Mecanismo / Ferramentas | Características |
| :--- | :--- | :--- | :--- |
| **1. Arquitetura e Encapsulamento da Base de Código** | Rígido (Determinístico) | Colocalização de funcionalidades, limites estritos entre diretórios, regras personalizadas de importação | Impede estruturalmente antipadrões arquiteturais ao tornar o caminho mais curto o caminho correto |
| **2. Análise Estática e Diagnósticos do Compilador** | Rígido (Determinístico) | Compiladores rigorosos (por exemplo, verificador de empréstimos do Rust), analisadores personalizados de código, verificações de integração contínua | Faz as compilações falharem de forma determinística em caso de violações de invariantes antes da revisão humana |
| **3. Revisão Automatizada de Código** | Flexível / Semideterminístico | Revisores de código de inteligência artificial (por exemplo, Bugbot), análise automatizada de solicitações de integração | Detecta defeitos contextuais durante a validação das solicitações de integração |
| **4. Habilidades dos Agentes e Guias de Estilo** | Flexível (Não Determinístico) | Regras em markdown, instruções aos agentes, guias de estilo | Facilmente ignoradas ou aplicadas de forma inconsistente pelos modelos |

Embora as diretrizes flexíveis nas Camadas 3 e 4 ofereçam contexto útil, a análise estática rígida e o encapsulamento arquitetural nas Camadas 1 e 2 são obrigatórios para garantir que agentes autônomos não possam integrar código inválido.

### 2. Analisar o Estudo de Caso da Arquitetura "Dune"
A implementação prática de barreiras determinísticas é demonstrada na refatoração da aplicação de computador Grokbot. O Grokbot foi construído usando "Dune", uma estrutura interna especializada descrita como o Next.js para aplicações Electron, projetada explicitamente para a entrega de software conduzida por agentes.

Para proteger o desempenho da aplicação em tempo de execução e eliminar modos recorrentes de falha dos agentes, a arquitetura Dune impõe regras determinísticas estritas nos fluxos de integração contínua:

* **Proibição de Ganchos do React:** O gancho `useEffect` do React é completamente proibido em toda a base de código para evitar falhas de sincronização de estado e novas renderizações não intencionais. As compilações de integração contínua falham imediatamente se `useEffect` for detectado.
* **Proibição de Comentários no Código:** Comentários no código da aplicação são estritamente proibidos. Tan observou que os agentes frequentemente geram comentários históricos ou interpretam incorretamente comentários transitórios de revisão de solicitações de integração — como transformar uma única observação de revisão, como `"Lauren disse para nunca fazer isso"`, em um comentário estático no código —, o que alucina restrições globais permanentes e polui as janelas de contexto dos modelos. Proibir comentários força a criação de código autodocumentado e evita a degradação do contexto.
* **Isolamento Obrigatório dos Limites entre Processos:** As aplicações Electron exigem separação estrita entre o processo principal do Node e a linha de execução da interface do renderizador. Para proteger o orçamento de execução de 16 milissegundos por quadro necessário para manter um desempenho fluido de 60 quadros por segundo, operações computacionalmente pesadas e tarefas de entrada/saída são proibidas na linha de execução do renderizador. O Dune impõe isso isolando a lógica nos diretórios `electron_main` e `electron_renderer`, usando verificações automatizadas do grafo de dependências na integração contínua para bloquear importações entre diretórios.

---

## Automação de Agentes na Nuvem e Implicações para Produtos em Todo o Setor
### 1. Reprodução Autônoma de Erros e Fluxos de Trabalho na Nuvem
O estabelecimento de ferramentas de verificação local e mecanismos rígidos de proteção de integração contínua permite que a entrega de software passe de comandos locais para frotas de agentes autônomos hospedados na nuvem. Essa mudança é exemplificada por agentes internos de automação na nuvem, como o "Benny" da 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
```

O Benny ingere automaticamente comentários brutos de usuários e relatos de defeitos dos canais do Slack. Ao receber um relato, o Benny inicia uma instância isolada do Cursor para computador na nuvem, executa o ambiente de execução da aplicação e utiliza habilidades de verificação armazenadas para reproduzir programaticamente o defeito relatado.

Operar em um ambiente isolado equipado com recursos completos de verificação permite que o Benny determine de forma independente se um problema persiste ou já foi resolvido na ramificação principal. Essa automação elimina a necessidade de engenheiros humanos dedicarem esforço manual à tentativa de reproduzir relatos de usuários de baixa qualidade.

### 2. Democratização do Desenvolvimento entre Funções Não Ligadas à Engenharia
Os mecanismos determinísticos de proteção de integração contínua alteram fundamentalmente a dinâmica operacional das organizações de desenvolvimento de produtos. Quando invariantes arquiteturais, limites de memória e orçamentos de desempenho são impostos de maneira determinística por compiladores e scripts de integração contínua, profissionais não ligados à engenharia — incluindo gerentes de produto, designers de experiência do usuário e equipes de entrada no mercado — podem desenvolver funcionalidades com segurança e enviar solicitações de incorporação de código para produção.

Como a infraestrutura rejeita automaticamente implementações não conformes, colaboradores não técnicos podem criar melhorias funcionais por meio de interfaces de linguagem natural, como o Grokbot, sem colocar em risco a estabilidade da base de código ou os orçamentos de desempenho.

Esse modelo operacional apresenta compensações econômicas e de retorno sobre o investimento específicas:

* **Despesas de Capital Iniciais com Tokens:** Construir conjuntos abrangentes de verificação, executar matrizes de avaliação com múltiplos agentes e realizar refatorações estruturais exige um gasto inicial substancial com tokens. A refatoração da aplicação Grokbot para a arquitetura Dune exigiu mais de 600 solicitações individuais de incorporação de código.
* **Ganhos de Eficiência da Mão de Obra:** O elevado gasto inicial com tokens é compensado por reduções drásticas nos custos indiretos de engenharia humana. Fluxos de execução de agentes de alta capacidade permitem que as organizações operem com equipes enxutas, evitando os custos organizacionais indiretos de grandes departamentos de engenharia. A viabilidade econômica de ciclos contínuos de julgamento e matrizes de avaliação de agentes é ainda mais ampliada por modelos de fronteira como o Grok 4.6, que mantém o preço dos tokens da versão 4.5 enquanto oferece desempenho superior em testes comparativos.

---

## Limitações Arquiteturais e Questões de Engenharia em Aberto

### 1. Documentar as Principais Limitações e os Casos Limítrofes
Apesar das melhorias de velocidade alcançadas por meio de frotas de agentes com alta autonomia, os padrões arquiteturais atuais introduzem limitações e compensações explícitas de engenharia:

* **Gasto Inicial com Tokens:** Construir fluxos contínuos de verificação e executar esforços de refatoração com muitas centenas de solicitações de incorporação de código consome volumes enormes de tokens. Para equipes que operam com orçamentos restritos de tokens, o capital necessário para construir ferramentas de verificação pode representar uma barreira significativa antes da obtenção de retorno sobre o investimento.
* **Riscos da Prototipagem do Zero:** Prototipar rapidamente aplicações sem mecanismos estruturais de proteção ("programação por intuição") gera dívida técnica arquitetural grave. Na ausência de limites explícitos de encapsulamento e restrições estáticas, os agentes escolhem atalhos convenientes que fazem as bases de código rapidamente saírem de controle, exigindo, por fim, grandes operações de refatoração com muitas centenas de solicitações de incorporação de código para corrigir a situação.
* **Sobrecarga de Manutenção e Discernimento:** Os sistemas automatizados de verificação não eliminam a necessidade de discernimento de engenheiros seniores. Construir avaliações, atualizar mapas de funcionalidades e estabelecer restrições de integração contínua exige profundo conhecimento do domínio e supervisão ativa que oriente a execução.

---

## Números principais

* **1,000 solicitações de incorporação de código:** Número de solicitações de incorporação de código integradas por Lauren Tan no mês anterior usando agentes autônomos na Cursor.
* **Quase 800 solicitações de incorporação de código:** Número de solicitações de incorporação de código integradas por Lauren Tan no mês atual (até o dia 12 do mês).
* **20 solicitações de incorporação de código:** Número de solicitações de incorporação de código geradas por agentes, incorporadas automaticamente durante a noite e verificadas na ramificação principal em um único dia.
* **600+ solicitações de incorporação de código:** Número de solicitações de incorporação de código executadas para concluir a refatoração completa da arquitetura da base de código do Grokbot.
* **16 milissegundos:** Janela máxima de execução por quadro exigida na linha de execução do renderizador do Electron para manter o desempenho fluido da interface do usuário a 60 quadros por segundo.
* **Há 5 meses:** Período em que Lauren Tan ingressou na Cursor, inicialmente enfrentando baixa produtividade enquanto desenvolvia a confiança inicial nos agentes e as habilidades de verificação.
* **Grok 4.6:** Lançamento de modelo recém-anunciado que mantém o custo dos tokens da versão 4.5 do modelo enquanto aumenta o desempenho em testes comparativos.

---

## O que mudaria esse cenário

1. **Mudança para Mecanismos de Proteção de Agentes Nativos do Compilador:** Adoção generalizada de linguagens estritamente compiladas com sistemas rigorosos de propriedade de memória e de tipos (como Rust) em substituição a estruturas de software dinâmicas, transferindo a imposição de regras estruturais de scripts personalizados de integração contínua diretamente para os diagnósticos do compilador.
2. **Padronização dos Protocolos de Verificação Programática:** Ampla adoção pela indústria de padrões unificados de verificação entre agentes e interfaces do usuário, independentes de plataforma e que vão além do Chrome DevTools Protocol, para expor interfaces de computador, dispositivos móveis e web de forma nativa aos agentes de inteligência artificial.
3. **Incorporação Autônoma Generalizada por Integração Contínua:** Transição das equipes convencionais de software comercial de fluxos manuais de revisão de código para filas de incorporação de código por integração contínua totalmente automatizadas, orientadas por pontuações de avaliação sintética e testes contínuos de integração.
4. **Redução do Custo dos Tokens em Avaliações com Múltiplos Agentes:** Reduções estruturais significativas nos custos de inferência de modelos de base, permitindo que equipes de desenvolvimento fora do segmento corporativo executem continuamente matrizes de julgamento com múltiplos agentes e ciclos de otimização por subida de encosta de forma econômica.

Para saber mais sobre a implementação de estruturas avançadas de engenharia de inteligência artificial e fluxos de execução autônoma, explore a pesquisa de código aberto disponível no site da DeepValues Research ou experimente o aplicativo DeepValues hoje.

---
## Fontes citadas

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)
