In this episode, we sit down with the full founding team of Wild Moose — CEO Yasmin Dunsky, CTO Roei, and VP R&D Tom Tytunovich — to explore how they’re transforming production debugging from an art into a science using AI.

The trio shares their unconventional founding story — from meeting across three different cities to living together for three months in a California Airbnb to stress-test both their idea and their relationship. They discuss how they identified production debugging as a massive unsolved problem before ChatGPT even launched, recognizing that while code generation is fundamentally a text problem, debugging is a search problem that demands a completely different approach.

We dive deep into Wild Moose’s “microagents” architecture — fast, highly optimized AI agents that replicate the muscle memory of senior engineers to automatically investigate production incidents in under a minute. The team explains why accuracy trumps everything in their space (wrong answers are worse than no answers when you’re debugging at 3 AM), how they navigate the speed-cost-quality triangle, and why they built a test-driven approach to validate agents against past incidents.

We also get into the multi-agent vs. single-agent debate, handling multimodal observability data (logs, metrics, traces, dashboards, code), and how the rapidly evolving LLM landscape creates both opportunities and challenges for production AI systems. Plus, the team shares their favorite outage war stories — including a “WatchCat” hack and a three-month hunt for a single rogue bit.

Topics covered:

• The Wild Moose origin story and the California Airbnb experiment
• Why production debugging is a search problem, not a text generation problem
• Microagents: fast, specialized AI agents for incident investigation
• Building institutional knowledge into AI — capturing engineering muscle memory
• The speed-cost-quality triangle in real-time AI systems
• Multi-agent vs. single-agent architectures: when to use what
• Handling multimodal observability data with LLMs
• The future of AI SRE and self-healing production environments
• Favorite outage war stories from the trenches

Chapters

00:00 Introduction to the Wild Moose Team
04:12 The Spark Behind Wild Moose
08:41 Understanding the Debugging Landscape
12:45 The Role of AI in Debugging
17:31 Building Investigative Agents
21:55 Optimizing Workflows and Feedback Loops
29:12 Navigating Complexity in Software Systems
33:42 Adapting to Rapid Changes in AI Technology
40:02 Microagents: The Future of AI Architecture
44:46 Outage Stories: Lessons from the Trenches
50:49 Vision for the Future of AI in Production

In this episode, Hussain shares the story behind xorq: a “lockfile for ML pipelines” that makes notebook work easier to reproduce, debug, and ship. We talk about why the research→production path is still so manual, how schemas (and Arrow) become the contract between systems, and what it takes to run the same pipeline across engines like Snowflake and Databricks. We also dig into escape hatches for imperative code, why feature stores didn’t become the default, and how xorq fits alongside other technologies like Iceberg.

Chapters

00:00 Hussain's Journey in Data Science

06:00 The Need for xorq: Bridging Research and Production

10:38 Challenges in Machine Learning Deployment

17:40 The Role of Lock Files in Data Pipelines

29:51 Understanding Schema Management in Data Systems

34:40 Navigating Declarative and Imperative Transformations

36:39 The Developer's Journey with xorq

38:34 Feature Stores vs. xorq: A Comparative Analysis

43:43 The Future of Feature Stores and Machine Learning

51:41 Reproducibility in Data Pipelines: xorq vs. Git-like Operations

55:47 The Future of xorq and the Data Ecosystem

Summary

In this episode of Tech on the Rocks, Kostas and Nitay sit down with Wes McKinney the creator of pandas and co-creator of Apache Arrow and Ibis, and long-time leader in the Python data ecosystem. Wes walks us through his journey from building pandas in 2008 to rethinking how we represent and move columnar data with Arrow, and why Arrow is fundamentally different from file formats like Parquet and ORC.

We get into the future of data file formats, DataFusion and the new generation of query engines, the rise of open data lakes (Iceberg, Delta, Hudi), and why “big metadata” is becoming just as important as big data. Wes also shares candid thoughts on open source sustainability, how companies and infrastructure projects really survive, and how AI coding agents like Claude Code are changing the day-to-day work of software engineers, especially for complex systems work.

If you care about the foundations of modern data infrastructure, or you’ve ever called import pandas as pd, this is an episode you won’t want to miss.

Chapters

00:00 Intro — Wes McKinney & his journey in the Python data ecosystem

02:15 How pandas evolved & why UX first mattered for data science

06:14 Open source sustainability, funding & the Posit model

07:31 From pandas to Datapad, Cloudera & the origins of Apache Arrow and Ibis

13:38 What is Apache Arrow? In‑memory columnar data, batches & schemas

22:23 Inside Arrow IPC — zero‑copy, Flatbuffers & cross‑language interop

24:34 Arrow vs Parquet — columnar memory format vs columnar storage format

29:28 The next generation of columnar file formats & GPU‑friendly encodings

36:03 Big metadata, table formats & the rise of Iceberg/Delta/Hudi

43:05 Rethinking data systems: from big data to DuckDB, Rust & “no JVM” stacks

54:11 DataFusion as a modular Rust query engine for modern startups

57:58 Open source, the composable data stack & why infra is “AI‑resistant”

01:00:07 Vibe‑coding with AI agents — using Claude Code in real projects

01:09:49 AI, open source maintainers & the risks of AI‑generated contributions

01:18:57 Bridging LLMs and data: ADBC, data context & the future of infra + AI