Weaviate Podcast

Ghita Houir Alami, Co-Founder of ZeroEntropy and now leading Model Research at Notion, joins the Weaviate Podcast to discuss training rerankers, calibrated relevance, and where search models fit in the age of agents. The conversation opens with the ZeroEntropy story: starting from an end-to-end search API, realizing the models powering it mattered most, and shipping a reranker first because swapping in a stateless last-stage API call is far easier for customers than re-embedding a whole corpus. A partnership powering Notion's enterprise search, plus fast query-rewriting models for parallel searches, led to the acquisition.From there, the discussion dives into small, task-specific decision models and turning cross-encoders into classifiers. Most rerankers trained with triplet loss cluster their scores between 0.4 and 0.6, but a calibrated score unlocks a dynamic K, returning three results or twenty depending on actual relevance, a natural partner to Weaviate's autocut. Ghita then explains zELO, the method behind zerank-1 and zerank-2: hard negative mining eventually surfaces unlabeled positives, so ZeroEntropy instead trained on pairwise comparisons, fit Elo scores through a Thurstone model with sparse sampling of pairwise battles, and distilled a pairwise reranker into an efficient pointwise one that nearly matches its accuracy.The conversation moves into infrastructure, from quantization-aware training and reranker-specific batching across US GPUs to blending reserved capacity with Modal for bursty traffic. Ghita makes the case for multi-stage retrieval, since embeddings alone hit dimensionality limits, with a small listwise stage on top only when needed. On agentic search, she argues a lightweight reranking step saves expensive LLM tokens, citing Cursor's finding that semantic search made Composer use fewer tokens with fewer undos, while Notion's harness shows that models that search more answer better. Instruction-following rerankers redefine relevance itself: for a memory system, "I'm highly allergic to nuts" is the most relevant answer to "What should I cook for dinner tonight?" Metadata like price is often better handled by a separate model such as XGBoost or Weaviate's Boost API.The episode closes on the excitement of post-training open-weight models for repeatable tasks inside companies, RSI and using AI to train AI!

Shangyin Tan, a Ph.D. student at U.C. Berkeley joins the Weaviate Podcast to discuss Scaling Discovery Requires Forgetting. This paper explores why long-running AI optimizers stall and how to get them climbing again. The conversation opens by defining discovery through the lens of GEPA, the prompt optimizer that uses an LLM as the proposer, and its successor, Optimize Anything, which extends the idea to code, GPU kernels, and agent harnesses. Shangyin separates three kinds of problems: generalization (prompts and harnesses that must work on unseen inputs), single-problem optimization (one kernel where the score you see is the score you get), and multi-problem optimization in between.From there, the discussion dives into forgetting. Running GEPA, Karpathy-style autoresearch, and Meta Harness behind one front end, every backend hit the same plateau after a couple of hours, and handing the best candidate to a fresh optimizer with no other context unblocked it every time. The evidence is striking: as sessions grow, agents use fewer thinking tokens per turn, edit fewer lines, and drift toward tweaking numbers instead of trying new algorithms, with one model repeatedly declaring it had "reached the practical limit" right before finding another improvement. And the best candidate isn't a loss of history, since it already encodes the ideas from every iteration that built it.The conversation then moves into multi-agent teams, where agents communicate only by reading each other's Git diffs rather than full files, so a weaker agent borrows an idea without collapsing into a copy. Teams climb faster and forgetting prevents plateaus, together making a strong autoresearch harness. Shangyin and Connor also cover GEPA's Pareto frontier as a tool for diversity, routing inputs to specialized harnesses, the Fork and Flush paper's idea basins, just-in-time databases, and why expensive or undefinable evaluations are the biggest gap between autoresearch and production.The episode closes with the mismanaged genius hypothesis: frontier models are already incredibly smart, and the real work is building harnesses that stop getting in their way!

Jacob X. Li , a Ph.D. student at MIT joins the Weaviate Podcast to explain Machine Studying, a new framing for how AI agents can prepare themselves for a domain defined only by a corpus of documents, whether that's a code base, a pile of drug discovery papers, or a system's logs. Just like a student studying for an exam they haven't seen, the agent studies the corpus without knowing the downstream tasks, and still has full access to the corpus at test time. Rather than leaning entirely on inference-time compute the way Codex or Claude Code explore a repository from scratch, can an agent develop arbitrarily deep understanding ahead of time?The conversation dives into how the paper defines expertise: an expert is an agent that efficiently turns inference-time search into accurate work, measured as the weighted area under the performance versus compute curve, with the search budget of a ReAct-style agent loop as the knob instead of reasoning effort. Stacking that one level higher gives studying intelligence, expertise as a function of study-time budget, with retraining from scratch as the baseline. From there, Jacob and Connor discuss learning to search, including a literature review experiment where an outdated model with BM25 finds roughly the same papers as a newer model but is far worse at deciding which ones matter, and why studying is more than retrieval.Jacob then separates Machine Studying from continual learning, which is framed around sequences of benchmarks and often collapses into long-context processing, and lays out the three bets every studying method makes: self-supervised objectives or synthetic data, updating weights through LoRA, KV-cache cartridges or a trained retriever, and amortized context management like notes and cheat sheets. Cheat sheets helped on DSPy but less on the larger, newer OpenClaw code base, and weights versus context, along with where prompt optimization like GEPA fits, is left deliberately open.The episode closes with how human study habits like self-quizzing and annotating inspire these algorithms, agents that study you before teaching you, and why evaluation as a science matters when recursive self-improvement happens in domains with no benchmark at all!

Shu Liu, Alexander Krentsel, Mert Cemri, and Shubham Agarwal, PhD students at U.C. Berkeley's Sky Computing Lab, join the Weaviate Podcast to discuss SkyDiscover and what it means for AI to build entire systems, not just code! AI coding went from Copilot-style line completion to function- and file-level generation with Claude Code. The next step is to optimize or synthesize systems that used to take PhD-level expertise, such as databases, inference engines, and key-value stores. With coding agents, "just-in-time systems" become possible: software tailored to one workload, free of the "generality tax" of general-purpose systems.The conversation centers on synthesizing a key-value store, where workloads vary in read/write ratio, hot keys, consistency, reliability, and latency versus throughput goals. Running on curated and production traces from Tencent and Twitter, the agents designed new caching and hierarchical memory schemes that reached up to 4x better performance than specialized systems from Microsoft. The hard part is trust. On YCSB traces, early builds showed 30–40x throughput because Claude was reward hacking: it worked out values from the keys. SkySynth acts as a "vaccine" against this. It asks the user questions to build the spec, then takes either a test-driven route or a formal verification route. In the test-driven route, a test only counts if it can tell a correct reference implementation from an incorrect one.From there, the discussion covers how the spec decides the programming language (Rust for memory safety, C for raw performance, Lean, Rocq, CompCert, and Verus for proofs). A surprising result: building on top of Microsoft FASTER gave lower throughput than synthesizing from scratch. The panel's advice is to "skate to where the puck is going" and let capable models design without constraints. The panel also imagines hosted systems resynthesized daily on recent traffic, and PRDs as the spec for consumer products.The episode closes on optimization. Unlike text optimization with GEPA, 80–90% of system optimization time goes to evaluation, and vLLM alone has more than 25,000 tests. That makes finding the right problem, building proxy evaluators, and generating adversarial workloads a meta-problem in its own right.Chapters0:00 Welcome Shu, Shubham, Alexander, and Mert!2:22 An Overview of SkyDiscover7:55 Specialized Database Systems12:33 DSPy for Systems23:23 Formal Verification of AI-Generated Systems26:34 Programming Languages and Vibe Coding32:48 Building Systems from Scratch40:26 Software for Everyone!45:26 GEPA for Vibe Coding

Siddharth Gollapudi, a researcher at UC Berkeley, joins the Weaviate Podcast to discuss in-context retrieval and his paper "Can Language Models Actually Retrieve In-Context? Drowning in Documents at Million Token Scale." The idea is simple and radical: instead of encoding documents into embeddings and building a nearest neighbor index, put the entire corpus into an LLM's context window and use attention itself as the retriever. The conversation opens by separating this from generative retrieval, which memorizes documents into model parameters and needs gradient updates every time the corpus changes, and from listwise re-ranking, which Siddharth frames as an easier subset of first-stage retrieval. Lost in the middle, he argues, turned out to be much less of a problem with today's long-context models.The discussion then dives into BlockSearch, a 0.6B parameter in-context retriever trained on MS MARCO (cleaned with RLHN) plus a mix of BEIR datasets. Reaching 500 documents was relatively easy; scaling to 2,500, 5,000, and 10,000 documents, or roughly a million tokens, is where things break. Siddharth explains why random document codes beat positional codes (they force the model to actually read the documents), and how an on-policy loss that corrects the model's own rollouts keeps it disciplined when hard negatives pull it off course midway through generating a code.From there, the conversation moves to attention dilution: as the corpus grows, the softmax denominator swamps the relevant document's score. Two fixes help, length-dependent temperature scaling and sparse attention that drops irrelevant documents before attention runs, bringing BlockSearch roughly level with dense retrieval at a million tokens. This opens a big question for vector databases: is there a sublinear, ANN-style version of attention that can be trained end to end, in the spirit of ReFrag and ColBERT's late interaction?The episode closes on timelines for LLM-based re-rankers, the latency trade-offs of high-latency search, "No More Free Lunch" and whether long-context LLMs can eat the database, recursive language models, and Siddharth's excitement for unsupervised notions of relevance that could help models make genuinely new discoveries, such as proving open theorems.Chapters0:00 Welcome Siddharth!1:21 In-Context Retrieval8:16 Drowning in Documents and Reranker Scaling13:05 BlockSearch, 0.6B In-Context Retriever28:21 Vector Databases for LLM Inference40:46 Timelines for In-Context Retrievers46:54 Will LLMs eat Databases?51:38 Exciting Directions for AI

Alexis, Manya, and Niloofar from humans& join the Weaviate Podcast to introduce Persimmon, a user model built to simulate how humans actually behave in multi-turn, multi-party conversations. Persimmon is explicitly not an assistant, a companion, or a Character AI-style stand-in, it is a research preview aimed at faithfully capturing the distribution of human behavior. This includes the natural friction of frustration, excitement, and group dynamics that assistant chatbots trained to be helpful never exhibit. Alexis, Manya, and Niloofar bring a striking mix of backgrounds to the problem: AI tutoring and student modeling, programming languages for high-performance computing, and privacy and information-flow research at Carnegie Mellon. The conversation opens with whether the Turing test is solved. Humans& runs a distributionally grounded, multi-turn version where the judge sees many examples of human and AI behavior. Frontier models fool it less than 5% of the time, while Persimmon reaches roughly 20% against a 50% ceiling. From there, the discussion dives into training for non-verifiable tasks: why rubrics-as-rewards approaches invite reward hacking, why the team refuses to impose its own theory of human behavior, and how distribution matching, with the multi-turn Turing test as a North Star metric operating in an implicit feature space, rather than Earth mover's distance over hand-picked features anchors both training and evaluation. They walk through evaluating on real human interaction data like the TIDES meeting transcripts and the TutorMoments tutoring dataset, and why role-played or scripted dialogue doesn't count.The discussion then moves into theory of mind and world models as twin goals, with Persimmon enabling multi-agent environments where assistants get realistic human feedback at training time. The podcast further covers the choice of NVIDIA's Nemotron 3 Ultra and why starting from a base model matters: post-training causes mode collapse, you can't prompt-optimize your way out of it, and injected randomness drifts away over long rollouts. The conversation lands on what excites each guest next: personalized tutors, models that balance overlapping human goals, and training paradigms with long-term social pressures.Chapters0:00 Welcome Niloofar, Manya, and Alexis!2:22 An Overview of Persimmon6:08 Solving the Turing Test13:36 User Models and AGI16:00 RL with Non-Verifiable Rewards20:35 Distribution Matching28:00 Collecting Human Data32:32 Theory of Mind in AI37:40 NVIDIA Nemotron 3 Ultra43:49 Prompt Optimization46:00 Exciting Directions for AI

Alex Ledbetter is the founder of Delegance Brokerage, an AI-native commercial insurance brokerage he built entirely on his own. The conversation opens with his origin story: an internship on a political risk, credit, and bond underwriting team in New York, where he watched a three-trillion-dollar portfolio run off the back of Excel and realized commercial insurance brokers earning 15–35% annual commissions could be disintermediated the way Robinhood disintermediated retail stock brokers. After raising $200K and securing 190 state licenses in 45 days, he spent seven months teaching himself to build with AI coding tools. Alex compares this process to hammering sheet metal, walking through his own product flow 700 times before showing it to a client.From there, the discussion dives into the architecture. Clients drop in insurance binders approaching a thousand pages, and a document processing pipeline classifies up to 50 commercial insurance document types, vectorizes everything into Weaviate, builds a table of contents per document for multi-hop traversal search, and runs trailing async extractors that pull structured fields into Postgres, processing 80 pages per minute per concurrent upload by converting PDFs into images for vision APIs rather than relying on flat OCR. Three million carrier appetite rules then route each client to the right insurer. Since only 7 of his 27 carrier partners have APIs, browser agents log into carrier portals, handle one-time passwords, and fill out underwriting questionnaires by querying Weaviate and Supabase in real time and monthly compliance agents renew licenses across 50 states.The conversation moves into agent harnesses: multi-model developer pipelines using Codex, Claude, and BugBot that have opened over 900 PRs a month, an email operating system with a chief of staff over iMessage, and how Weaviate unifies memory across web, iOS, Slack, email, and phone. It lands on what's next: a fresh fundraise, SOC 2, and running lean with embedded partnerships instead of brokers.Chapters:0:00 Welcome Alex!0:38 Founding Story of Delegance Brokerage6:38 Insurance Brokers and AI12:15 A Knowledge Base for Insurance24:20 Vibe Coding28:50 Browser Agents34:14 Email Agents37:30 What is an Agent Harness?49:00 Weaviate and Postgres Database Design55:15 The Future of Delegance Brokerage

Sam O'Nuallain joins the Weaviate Podcast to discuss AutoIndex, research from UMass Amherst and Databricks on learning representation programs for retrieval. Instead of tuning the retriever or re-ranker, AutoIndex asks how the data itself should be represented: a two-agent system, an analysis agent and a code agent, writes and refines Python programs that chunk, enrich, and reorganize a corpus to optimize downstream metrics like Recall and nDCG.The conversation opens with why indexing is such a natural target for code optimization. Frontier LLMs are exceptional at writing code, a representation program applies cheaply across an entire corpus without passing every document through an LLM, and code is verifiable. Every hypothesis the code agent proposes is gated against a validation set before it is accepted. From there, the discussion dives into the optimization signal. The analysis agent uses tools to read documents, query the retriever, and inspect where gold documents rank, turning a bare score like "recall went up" into rich natural language feedback about why a representation is failing, echoing ideas like GEPA's reflective metrics and the value of small-margin positives for training re-rankers.That leads into why BM25 pairs so well with agents: its lexical transparency makes failures easy to diagnose, illustrated by case studies from the CRUMB benchmark. This includes LaTeX formatting errors sinking Stack Overflow retrieval and Tip-of-the-Tongue movie search, where AutoIndex learned to repeat plots to up-weight terms and expand documents with synonym dictionaries. The conversation moves through connections to document enrichment methods like Anthropic's contextual retrieval, doc2query, and EnrichIndex, generalizing representation programs to text-to-SQL schemas and data lakehouses. The podcast concludes by discussing Sam's lessons transitioning from research to production AI engineering: loop engineering, QA, and evals. It lands on the directions that excite Sam most: harness design, continual learning, and memory as a retrieval problem, squeezing more out of the models we already have without touching the weights.Chapters0:24 An Overview of AutoIndex4:04 Retrieval Indexing as Code Optimization8:47 Optimizing Chunking and Database Schemas15:57 Feedback for Search Optimization23:57 Future Directions for AutoIndex27:34 Document Enrichment for RAG36:32 Web Search vs. Databases40:40 AI Engineering49:30 Exciting Directions for AI

Alex Zhang, a PhD student at MIT, joins the Weaviate Podcast to discuss Recursive Language Models (RLMs), a new abstraction for designing agent harnesses. Instead of the standard ReAct-style loop that stuffs every tool observation into an ever-growing prompt, an RLM treats the prompt as a variable in a program. The model writes code that manipulates its own context and spawns recursive LLM calls over pieces of it. The published headline was long-context performance, but the deeper intention, inspired by how DSPy programmers decompose tasks, is letting the model do that decomposition itself, relieving context pressure so each call only sees a small, local, in-distribution problem. Stacking tool outputs into one giant sequence is terribly out of distribution for how models were trained. Frontier labs spend enormous resources making those long trajectories in-distribution, but RLMs aim to get more from the model without that.From there the conversation turns to PrimeAgent, Prime Intellect's production harness centered on an RLM, where the only tool is a persistent IPython REPL: search, compaction, sub-agents, and skills are all callable inside code, yielding strong results on ARC-AGI-3 and long-horizon benchmarks with big token savings. Alex shares why they moved from prompt tuning to RL on the weights of Qwen3, and why Claude Code's dynamic workflows are RLM-like but constrained by legacy tool-calling defaults.Alex then previews an unreleased library for speculative programmatic tool calling. Borrowing from speculative decoding and CPU speculative execution, a shadow executor queues up sub-agent calls while the main model is still generating code, delivering roughly 2x speedups and better GPU utilization for locally served agents. The discussion moves into running RLMs in the cloud with sandbox providers like Modal and Daytona, security concerns around code execution and prompt injection, and why serving engines should be redesigned around agents. It closes with RLMs and search, combining ColBERT-style retrievers as callable tools for problems like agent log analysis, and a theory that everything "long" is naturally decomposable. The podcast concludes with exciting ideas about where AI goes next from principled harness design to whether the transformer itself gets replaced with a newer neural architecture design.

Mathew Jacob, lead author of "Drowning in Documents: Consequences of Scaling Reranker Inference" and now a PhD student in ML systems at the University of Washington, joins the Weaviate Podcast to unpack one of the most surprising results in modern search: cross-encoder rerankers get worse as you give them more documents. The paper began during his Databricks internship, where scaling reranking past roughly 100 documents sent recall@10 plummeting, a result so counterintuitive he assumed it was a bug.The conversation digs into why this happens, reframing rerankers through the lens of boosting, rather than being strictly stronger than first-stage retrievers. Cross-encoders are very good at correcting retriever errors within the distribution they were trained on. Full-scoring experiments over 10,000 randomly sampled documents drive the point home, with BM25 beating state-of-the-art cross-encoders. From there, the discussion moves into phantom hits, cases where wildly irrelevant documents scored highly. For example, a dishwasher document surfacing for a query about disease in Gabonese children. We also discuss whether ensembling rerankers can patch these false positives.The second half explores what comes next for reranking: prompt-based listwise reranking with sliding windows, which proved far more robust than pointwise scoring; RankZephyr-style fine-tuning versus encoding learning signal in prompts with GEPA and DSPy, reasoning rerankers like Rank1 and their latency trade-offs, hard negative mining behind ZeroEntropy's zELO, and pairwise and setwise designs that sit between cross-encoders and full listwise ranking. Adaptive retrieval comes into focus through Natural Language Query to Configuration for Retrieval Agents, predicting per query whether to run simple retrieval, multi-hop, or full agentic search to push the cost-quality frontier.The conversation lands on TraceLab, from Mathew's lab at UW: 40,000 real traces harvested from Claude Code and Codex usage, revealing how coding agents actually behave, prefix cache patterns, long-tailed tool calls, and how understanding these workloads unlocks the next generation of serving optimizations.