Domesticating AI

AI agents can consume more information than ever. That doesn't mean they understand your data.

For the Season 1 finale of Domesticating AI, we're joined by Joe Reis, co-author of Fundamentals of Data Engineering, for a conversation that went somewhere completely different than we planned.

We start with Joe's practical take on local AI. If subscriptions to frontier models are cheaper than buying hardware, when does self-hosting actually make sense? Privacy, IP, fine-tuning, and inference costs at scale all change that calculation.

Then we get into data modeling.

Humans are remarkably good at working around bad schemas, missing documentation, tribal knowledge, and ambiguous business definitions. Agents aren't. If machines are going to operate on our data, the structure, relationships, provenance, and meaning of that data become much harder to ignore.

From there, things get weird. We talk about corporate knowledge bases, ontologies, the post-literate engineer, AI-generated summaries, whether engineers still need to read the research, and the increasingly shaky state of reproducible AI benchmarks.

Topics include:

• Local models vs. cloud AI economics
• Bonsai 27B and 1-bit models on phones
• Data modeling for AI agents
• Knowledge bases and organizational knowledge
• Ontologies and semantic modeling
• The post-literate engineer
• AI summaries vs. actually reading research
• Reproducibility and AI benchmarks
• Why agent security doesn't require Skynet to be dangerous

Links mentioned:

Joe Reis — The Post-Literate Engineer
https://joereis.substack.com/p/the-post-literate-engineer

Joe Reis — Practical Data Modeling / Mixed Model Arts
https://practicaldatamodeling.substack.com/

The Mixed Model Arts Manifesto
https://practicaldatamodeling.substack.com/p/the-mixed-model-arts-manifesto

Fundamentals of Data Engineering — Joe Reis & Matt Housley
https://www.oreilly.com/library/view/fundamentals-of-data/9781098108298/

PrismML — Bonsai 27B
https://prismml.com/news/bonsai-27b

DeepSeek V4 Flash
https://api-docs.deepseek.com/updates/

William Kent — Data and Reality
https://bkent.net/Doc/darxrp.htm

Find Domesticating AI:

YouTube
https://www.youtube.com/@DomesticatingAI

Apple Podcasts
https://podcasts.apple.com/us/podcast/domesticating-ai/id1873338950

Spotify
https://open.spotify.com/show/2WsAR4fvcXzp3vVZGVlkE2

Patreon
https://patreon.com/DomesticatingAIPodcast

That's a wrap on Season 1. Subscribe so you're here when Season 2 drops.

Keep your AI on a leash.

Your side project starts on the free tier. Then it gets interesting.

This week, Tod from Catalyst Community joins us to talk about why the homelab is one of the best places to build open-source software, experiment with AI, and learn the infrastructure underneath the tools we use every day.

We get into why Kubernetes does not need to turn you into a Kubernetes administrator, how Foundry is making it easier to stand up K3s on your own hardware, and why tools like Helm make adding databases, monitoring, storage, and other services much less painful once the foundation exists.

Tod walks us through his own homelab: Proxmox, Debian, a three-node Kubernetes cluster, separate storage and GPU machines, and the open-source tooling he uses to build on top of it. We also get into Tailscale, KServe, Ray, CloudNativePG, Prometheus, Grafana, Loki, Whisper, and running GPUs both inside and outside Kubernetes.

But the bigger conversation is about building.

Matt talks about the GPU machine he originally bought to train a StarCraft bot and how that experimentation turned into skills he could use professionally. Miriah talks about replacing a Supabase free-tier database with Postgres on her homelab. Tod talks about replacing GitHub-hosted CI/CD infrastructure with his own open-source system.

The common thread: doing the foundational work once gives you a platform where the next idea is much cheaper to try.

And with modern hardware, open-source software, and LLM-assisted development, the barrier to building something useful at home has never been lower.

So our question for you:

What are you building for yourself, for fun, or for open source?

Projects mentioned in the episode include Foundry, K3s, Kubernetes, Helm, Proxmox, Tailscale, KServe, Ray, CloudNativePG, Prometheus, Grafana, Loki, MLflow, Whisper, Render, Supabase, and Anthropic Claude.

Keep your AI on a leash.

Everyone has a list of open-source AI projects they want to try. But installing repos is not the same as building a stack.

Ryan Russon joins Miriah, Matt, and Chris to talk through the projects that actually teach you how AI homelabs work: Unsloth for training, Ollama and llama.cpp for local inference, Open WebUI for a usable front door, K3s for hosting, Longhorn and SeaweedFS for storage, and Prometheus/Grafana for observability.

We also get into build-vs-buy decisions, speech models like Whisper.cpp, Parakeet, and Granite, why state is where homelabs stop being cute, and why the best open-source projects are the ones that teach you what breaks next.

Links mentioned:
https://github.com/unslothai/unsloth
https://ollama.com/
https://github.com/ggml-org/llama.cpp
https://github.com/open-webui/open-webui
https://k3s.io/
https://longhorn.io/
https://github.com/seaweedfs/seaweedfs
https://prometheus.io/
https://grafana.com/
https://github.com/Arize-ai/phoenix
https://github.com/langfuse/langfuse

Support the show:
https://patreon.com/DomesticatingAIPodcast

Keep your AI on a leash.

What happens when the cost of running AI is no longer hidden behind a cloud bill—but something you can physically feel?

In this episode of Domesticating AI, Kat Tomanek and Alex Kauffman of Squeez Labs introduce CrankGPT, a fully offline voice assistant that runs on a Raspberry Pi and is powered by a hand crank. As the language model performs inference and generates speech, the crank becomes harder to turn, converting an abstract computational cost into physical exertion.

CrankGPT began as an experiment: could Squeez Labs build a responsive, completely self-contained voice AI system without a cloud connection, wall outlet, or battery? Answering that question required much more than placing a small language model on a Raspberry Pi. Kat and Alex had to engineer the complete system, including speech recognition, voice activity detection, language-model inference, text-to-speech, boot time, memory usage, power delivery, and conversational latency.

The result is a modular voice stack that uses specialized components rather than one enormous multimodal model. That architecture allowed the team to select each model according to the actual requirements of the device. The voice only needs to be understandable. The language model needs to respond quickly enough for conversation. The speech recognizer needs to run efficiently on a CPU. Anything beyond those requirements consumes resources without necessarily improving the experience.

We discuss why local AI is not simply about buying an expensive GPU, why developers should begin with the machines they already own, and how constraints reveal the hardware characteristics that actually matter. In CrankGPT’s case, memory bandwidth and cold-start behavior created more significant limitations than several of the specifications the team initially expected to matter.

The conversation also examines a larger problem in the AI industry: developers frequently select the largest available model before defining the problem they need to solve. Cloud services conceal the energy, infrastructure, privacy, and financial costs of those decisions. CrankGPT makes those costs visible—and makes a strong case for engineering systems around specific requirements instead of throwing more compute at every problem.

We also cover Pinokio as an accessible entry point for experimenting with local AI, Whisper and whisper.cpp for speech recognition, modular voice-agent architecture, Raspberry Pi optimization, and why some supposedly ideal AI use cases are still better solved with a book, calculator, or conventional software.

CrankGPT and build documentation:https://squeezlabs.github.io/handcrank/

CrankGPT:https://crankgpt.com/

Squeez Labs:https://squeezlabs.com/

Edge Voice Agent:https://github.com/ktomanek/edge_voice_agent

Pinokio:https://pinokio.co/

whisper.cpp:https://github.com/ggml-org/whisper.cpp

OpenAI Whisper:https://github.com/openai/whisper

llama.cpp:https://github.com/ggml-org/llama.cpp

Liquid AI:https://www.liquid.ai/

Gemma:https://deepmind.google/models/gemma/

DietPi:https://dietpi.com/

Raspberry Pi:https://www.raspberrypi.com/

Domesticating AI is a biweekly podcast about practical AI for developers. We help you brave the feral open-source AI landscape so you can tame it instead of getting dragged along by it.

Keep your AI on a leash.

Resources

You don’t need a DGX Spark to start running local AI.

In this episode, Miriah, Matt, and Chris talk about realistic AI homelab hardware: old gaming PCs, refurbished desktops, Raspberry Pis, MacBooks, RTX cards, Mac Studio, DGX Spark, AMD Strix Halo machines, and cloud GPU rentals.

The argument is simple: start with the hardware you already have, learn the constraints, then decide what to buy.

We cover inference, small-model training, coding agents, local harnesses, OpenCode, Forge, LM Studio, Ollama, Docker, Podman AI Lab, vLLM, Lemonade, Unsloth, RunPod, Modal, and why hardware decisions should follow the workload instead of YouTube FOMO.

We also get into the real reason local AI matters: data control, IP protection, regulated workflows, reproducibility, and understanding the engineering trade-offs instead of treating the model like magic.

Comment question:
What are you running local AI on right now, and what do you want to buy next?

Links mentioned:
LLMs in Production: https://www.manning.com/books/llms-in-production
Andrew Ng Machine Learning Specialization: https://www.coursera.org/specializations/machine-learning-introduction
fast.ai Practical Deep Learning for Coders: https://course.fast.ai/
NVIDIA DGX Spark: https://marketplace.nvidia.com/en-us/enterprise/personal-ai-supercomputers/dgx-spark/
NVIDIA Jetson Orin Nano: https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-orin/nano-super-developer-kit/
Framework Desktop: https://frame.work/desktop
Beelink GTR9 Pro: https://www.bee-link.com/products/beelink-gtr9-pro-amd-ryzen-ai-max-395
RunPod: https://www.runpod.io/
Modal: https://modal.com/
OpenRouter free models: https://openrouter.ai/collections/free-models
OpenCode: https://opencode.ai/
OpenCode Zen: https://opencode.ai/docs/zen/
Forge: https://github.com/antoinezambelli/forge
LM Studio: https://lmstudio.ai/
Ollama: https://ollama.com/
Docker Model Runner: https://www.docker.com/products/model-runner/
Podman AI Lab: https://podman-desktop.io/docs/ai-lab
vLLM: https://docs.vllm.ai/
AMD Lemonade Server: https://lemonade-server.ai/
Unsloth: https://unsloth.ai/docs

Follow Domesticating AI:
YouTube: https://www.youtube.com/@DomesticatingAI
Apple Podcasts: https://podcasts.apple.com/us/podcast/domesticating-ai/id1873338950
Spotify: https://open.spotify.com/show/2WsAR4fvcXzp3vVZGVlkE2
Amazon Music: https://music.amazon.com/podcasts/193658ea-5d7e-40c5-b78c-dbc1f6ada65a/domesticating-ai
Patreon: https://patreon.com/DomesticatingAIPodcast

Keep your AI on a leash.

Everyone seems to be hiring AI engineers—but what does that actually mean?

Using Claude Code, Cursor, or ChatGPT doesn't automatically make someone an AI engineer. So where's the line between software engineering with AI and engineering AI systems?

This week we're joined by Byron McKay, Director of Learning at Gauntlet AI, to discuss how they train engineers for AI roles, what companies are actually looking for, and why the most important AI engineering skills have surprisingly little to do with prompting.

We explore why system design has become essential, why RAG is far from dead, whether you need to self-host or fine-tune models, and why communication and engineering fundamentals are still the biggest predictors of success.

If you're wondering what skills to invest in next—or trying to break into AI engineering—this episode is for you.

• What actually defines an AI engineer?
• Why system design matters more than ever
• Is RAG still relevant in 2026?
• The difference between AI users and AI engineers
• Why engineering fundamentals still matter
• Communication as a technical skill
• Why experimentation is part of the job
• Do you need to fine-tune or self-host models?
• How Gauntlet AI prepares engineers for AI careers
• Advice for learning AI without chasing every new framework

• Gauntlet AI — https://gauntletai.com
• LLMs in Production — https://www.manning.com/books/llms-in-production
• Claude Code — https://www.anthropic.com/claude-code
• Ray — https://www.ray.io/
• Qwen — https://qwen.ai/blog?id=qwen3.5
• UV Package Manager — https://docs.astral.sh/uv/

Domesticating AI is a bi-weekly podcast for software engineers building practical AI systems. We cover self-hosted AI, agents, infrastructure, context engineering, security, and the engineering practices that make AI reliable in production.

Subscribe wherever you get your podcasts, and if you're enjoying the show, leave a rating and review—it helps more engineers discover the show.

Keep your AI on a leash.

At a recent meetup, a room of about 55 people was asked: do you know every line of code you shipped to production?

One person raised their hand: Chris.

That moment became the center of this episode. Not because AI-assisted coding is bad, but because it exposes the real risk: developers are starting to trust AI-generated output without fully owning it.

In this episode, Miriah, Chris, and Matt talk about AI psychosis: the slow offloading of judgment, skepticism, and responsibility to systems that sound confident by design. We dig into AI slop, sycophantic models, no-slop.ai, Mitchell Hashimoto’s warning about companies operating under AI psychosis, and why “Claude wrote it” is not a defense when production breaks.

This is not an anti-AI episode. We use AI constantly. The point is to stop treating AI like an oracle and start treating it like a tool that needs constraints, review, and ownership.

Topics:

• The 1-of-55 meetup story
• What AI psychosis means for developers
• Who owns AI-generated code?
• Why confident output is not the same as correct output
• no-slop.ai and the rule: don’t send AI output you haven’t read
• Mitchell Hashimoto on AI psychosis in companies
• Why arguing with AI usually wastes time
• How sycophantic models pull users into the spiral
• Practical ways to keep AI honest
• Why smaller or self-hosted models can make AI feel less magical

Links:

• no-slop.ai: https://no-slop.ai
• Mitchell Hashimoto post: https://x.com/mitchellh/status/2055380239711457578
• Timnit Gebru post on AI psychosis: https://www.linkedin.com/posts/timnit-gebru-7b3b407_surviving-ai-psychosis-activity-7454588079467593729-X1eT
• HBR trendslop article: https://hbr.org/2026/03/researchers-asked-llms-for-strategic-advice-they-got-trendslop-in-return
• Patreon: https://patreon.com/DomesticatingAIPodcast
• YouTube: https://www.youtube.com/@DomesticatingAI
• Apple Podcasts: https://podcasts.apple.com/us/podcast/domesticating-ai/id1873338950
• Spotify: https://open.spotify.com/show/2WsAR4fvcXzp3vVZGVlkE2

Keep your AI on a leash.

Everyone is building AI agents.

OpenAI SDKs, Claude Code, Deep Agent systems, custom workflows, and orchestration frameworks all promise more autonomous AI. But as these systems become more capable, they start running into familiar engineering problems:

• retries
• state management
• orchestration
• context control
• durable execution

This week we're joined by Hamza Tahir, CTO and co-founder of ZenML and creator of Kitaru, to discuss what happens when agents stop being simple chat interfaces and start behaving like long-running distributed systems.

We explore:

• what an agent harness actually is
• durable execution and why it matters
• orchestration vs business logic
• state management for long-running agents
• retries, checkpoints, and human-in-the-loop workflows
• context management and token costs
• open vs closed agent frameworks
• why everyone seems to be rebuilding the same layer of infrastructure

One of the biggest questions we kept coming back to:

What is a meta harness?

If you have an answer, let us know in the comments.

Kitaru
https://github.com/zenml-io/kitaru

ZenML
https://www.zenml.io

Hamza Tahir
https://www.linkedin.com/in/hamzatahir/

Pedro Agentware
https://github.com/Soypete/pedro-agentware

OpenAI Agents SDK
https://platform.openai.com/docs/guides/agents

Temporal
https://temporal.io

DBOS
https://www.dbos.dev

Apache Airflow
https://airflow.apache.org

Prefect
https://www.prefect.io

Domesticating AI is a bi-weekly podcast about practical AI for developers.

We help you brace the feral open-source AI landscape — so you can tame it instead of getting dragged by it.

Subscribe on YouTube, follow on Spotify or Apple Podcasts, and support the show on Patreon.

Keep your AI on a leash.

Links

AI is easy to use — but hard to scale.

In this episode of Domesticating AI, we’re joined by Daniel Dowler (Red Hat) to break down what actually happens when you move from calling APIs to running AI systems yourself.

Recorded on April 21st

Most developers interact with AI through APIs — fast, simple, and pay-per-token. But behind the scenes, those systems rely on GPU scheduling, batching, and infrastructure that doesn’t behave like traditional software.

We cover:

• Why GPU scaling is fundamentally different from CPU scaling
• Why tools like vLLM are becoming the default for high-performance inference
• How Ray and Kubernetes fit into real-world AI systems
• What parallelism (tensor, data, expert) actually means in practice
• When self-hosting AI makes sense
• When APIs are still the better choice

• Claude Opus 4.7
  https://www.anthropic.com/news/claude-opus-4-7
• Qwen 3.6 (Alibaba)
  https://qwen.ai/research
• Kimi K2.6 (community discussion)
  https://www.reddit.com/r/LocalLLaMA/s/kvRWb7uJgM

• vLLM → https://github.com/vllm-project/vllm
• Ray → https://github.com/ray-project/ray
• Kubernetes → https://kubernetes.io
• Kueue → https://kueue.sigs.k8s.io
• LiteLLM → https://github.com/BerriAI/litellm
• KServe → https://kserve.github.io

Daniel Dowler
Platform engineer at Red Hat focused on Kubernetes and AI infrastructure. Daniel works on how modern systems support real workloads, including GPU scheduling, distributed inference, and scaling AI in production environments. He recently spoke at Machine Learning Utah on AI infrastructure and clustering.

You don’t scale AI with replicas.

You scale it by managing scarce compute.

Subscribe on Spotify or Apple, and follow us on YouTube.

👉 Keep your AI on a leash.

🧠 News🔗 Tools & Tech Mentioned👤 Guest🎯 Key Takeaway

Recorded: April 14, 2026

Most people using AI today are still users.

They open ChatGPT, call an API, and get an answer.

And honestly… it works.

But that’s not the same as building with AI.

In this episode of Domesticating AI, we break down the difference between AI users and AI practitioners—and why that shift matters if you want reliable systems.

We’re joined by Alexandra “Lexi” Pasi, PhD, CEO of Lucidity Sciences, to talk about what it actually means to own the system around AI:

• why calling an API is still user behavior
• what changes when you build the harness
• how agent systems actually fail (loops, cost, drift)
• why switching models isn’t a reliability strategy
• how to add layers—constraints, validation, and control flow
• why engineering discipline matters more with AI, not less

If you’ve built your first AI agent, workflow, or coding loop—this is the “now what?” episode.

Alexandra Pasi is the CEO of Lucidity Sciences, where she works at the intersection of mathematics, machine learning, and real-world system design.

She holds a PhD in Mathematics from Baylor University and specializes in building analytical and algorithmic systems that bring structure to complex, uncertain environments.

🔗 LinkedIn: https://www.linkedin.com/in/alexandrapasi/
🔗 Lucidity Sciences: https://luciditysciences.com

• Google TurboQuant (LLM compression research)
  https://research.google/blog/turboquant-redefining-ai-efficiency-with-extreme-compression/
• Anthropic Claude Mythos Preview (security-focused model)
  https://red.anthropic.com/2026/mythos-preview/
• Project Glasswing (Anthropic security initiative)
  https://www.anthropic.com/glasswing
• Karpathy Autoresearch (self-improving training loop)
  https://github.com/karpathy/autoresearch
• Kitaru (durable agent execution framework)
  https://github.com/zenml-io/kitaru

• Subscribe on YouTube
• Follow on Spotify & Apple Podcasts
• Support the show on Patreon:
  👉 https://patreon.com/DomesticatingAIPodcast

Keep your AI on a leash.

🧾 Episode Summary👤 Guest: Alexandra “Lexi” Pasi, PhD🔗 Topics & Links Mentioned🔔 Follow & Support