If you've used Perplexity AI and wondered whether you could get the same thing without handing your queries to someone else's servers, this episode is the answer. It covers SearXNG and Vane (formerly Perplexica) — two open-source tools that, stacked together, give you a fully private, self-hosted AI search setup where your questions never leave your control.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Self-Hosted AI Search (SearXNG + Perplexica/Vane) (Podcast) - 2026-06-17 (Dr. Priya Nair).

- SearXNG is a metasearch engine you run yourself — it queries Google, Bing, and dozens of other engines on your behalf, strips the tracking, and returns combined results without any engine ever seeing your identity

- Vane (the project publicly renamed from Perplexica in March 2026) is an open-source Perplexity clone — you ask a question in plain English, it searches via SearXNG, feeds the results to a language model, and returns a cited, written answer

- Run them together and you get the whole point: a private "Perplexity" where queries stay on your infrastructure and, if you use a local model via Ollama, nothing leaves your machine at all

- You choose which language model does the writing — a cloud model or a fully local one — giving you cost and privacy control that hosted AI search tools don't offer

- SearXNG is the actively maintained 2021 fork of the older Searx project; Vane (formerly Perplexica, created by ItzCrazyKns) is MIT-licensed and has tens of thousands of GitHub stars

- The rename from Perplexica to Vane is a confirmed upstream rebrand, not a fork — but the reason behind it isn't officially documented

Tailscale is one of those tools that's genuinely hard to describe in one sentence — and that difficulty is the point. This episode unpacks what Tailscale actually is, how it works under the hood, and why it's quietly replacing the corporate VPN that everyone hates.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Tailscale (Podcast) - 2026-06-17 (Dr. Priya Nair). Primary external sources include Tailscale's engineering blog and documentation, WireGuard's kernel history, and Jason Donenfeld's zx2c4 repositories.

- Tailscale creates a "tailnet" — a private, encrypted mesh network connecting all your devices as if they're on the same local network, no matter where they are

- It's built on WireGuard (created by Jason Donenfeld, not Tailscale), and Tailscale's value is everything it layers on top: automatic NAT traversal, identity-provider login, and MagicDNS

- A coordination server handles key exchange and access policy but never sees your actual traffic — end-to-end encryption is real, but you are trusting Tailscale's control plane

- Self-hosted alternative Headscale and Tailscale's own Tailscale Lock exist specifically to address that trust question

- The killer personal use cases: accessing your home lab, NAS, or local Ollama instance from anywhere without port-forwarding, and a free tier that covers most individual users

- Competitors ZeroTier and Nebula take different architectural bets; Tailscale's Funnel and Serve features extend the model in a different direction entirely

The terminal and the code editor aren't just developer tools anymore — this episode makes the case for why iTerm2 and VSCode have become the most powerful productivity surface for AI-era knowledge work, and why that matters for researchers, writers, and operators who've never left Notion.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - iTerm2 + VSCode as Productivity Interface (Podcast) - 2026-06-17 (Dr. Priya Nair).

- iTerm2 is a free, open-source Mac terminal replacement (created by George Nachman, 2010) that turns a plain command window into a configurable workspace — split panes, saved layouts, and automation built in

- VSCode is Microsoft's free, open-source code editor (launched 2015) that won the editor wars and became the default host for AI assistant tooling — Copilot, Continue, and Cursor among them

- The core argument: "everything is a file or a command" — the terminal-plus-editor pairing is a more composable productivity surface than any single GUI app

- The rise of local AI tooling (Ollama, Claude Code, shell agents) has made terminal and editor literacy more valuable, not less — and puts serious AI-augmented workflows within reach of non-developers

- This episode is framed as the interface layer argument, not a how-to — the "why these tools" case for knowledge workers who live in Notion or Obsidian but haven't crossed into the terminal

- The learning curve is real and shouldn't be minimized — but the payoff is a workflow where your AI tools, files, and commands all live in one composable surface

Claude Code is Anthropic's agentic coding tool — it lives in your terminal, reads your codebase, edits files, and runs commands. This episode covers how it can run on local models through Ollama, why that works, and what you give up when you take Anthropic out of the loop.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Claude Code with Local Models (Ollama) (Podcast) - 2026-06-17 (Dr. Priya Nair). Primary external sources: Anthropic's official Claude Code documentation and Ollama's own blog and docs.

- Claude Code is an agent, not a chat window — it reads your codebase, edits files, runs shell commands, and loops until the task is done

- As of Ollama v0.14, Ollama natively speaks Anthropic's Messages API, which is what Claude Code sends — no translation proxy needed

- Ollama v0.15+ added `ollama launch claude`, which wires the integration up automatically with no config files or environment variables

- Anthropic does not officially support local models for Claude Code — this works because Ollama did the work, not because Anthropic blessed it

- Smaller local models handle routine tasks (completions, refactors, debugging) but degrade on long multi-step agentic work where tool-use precision matters

- Aider, Continue, and OpenCode were designed local-first from day one; Claude Code is cloud-first that can go local

AI hallucination isn't a glitch waiting to be patched — it's a structural consequence of how language models work. This episode builds the mental model operators actually need: what's causing it, what makes it worse, and what verification moves hold up.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Why AI Hallucinates (AI Foundations) - 2026-06-14 (Dr. Priya Nair). Primary external sources include the OpenAI 2025 paper "Why Language Models Hallucinate," the companion result "Calibrated Language Models Must Hallucinate," canonical hallucination surveys by Ji et al. and Huang et al., DeepMind's self-correction paper, an Anthropic calibration paper, and the Stanford RegLab legal-tools study.

- A language model produces the most plausible-sounding next text — "plausible" and "true" overlap most of the time, but they are different properties, and the model has no truth-meter for when they come apart

- Two mechanisms compound: rare long-tail facts are statistically likely to be fabricated, and training benchmarks reward confident guessing over honest "I don't know"

- The dangerous hallucinations aren't the absurd ones — they're the plausible ones: a real-sounding citation that doesn't exist, a confident wrong number that looks right

- Reasoning models don't solve this; on some measures they hallucinate more

- Asking a model to check its own output doesn't work; verification has to be external — grounding, retrieval, or a human accountable for load-bearing output

- Operator rule of thumb: use AI for fluency and structure, gate it on anything where a confident wrong answer is expensive

Prompting isn't magic words or politeness tricks — it's you reshaping the probability distribution the model is working from. This episode gives operators a clear mechanical picture of why prompting works, what a well-built prompt looks like, and where prompting hits a hard wall.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - How Prompting Actually Works (AI Foundations, Ep. 4) (Dr. Priya Nair). Primary external sources include Anthropic's prompt-engineering reference, OpenAI's prompt-engineering guide, Wei et al. 2022 and Kojima et al. 2022 (chain-of-thought), and two peer-reviewed studies on prompting politeness.

- Prompting works because your words reshape the model's probability distribution over what comes next — systematic, not magical

- A well-built prompt has six components: role, context, task, format, constraints, and examples

- Specificity beats vagueness because narrowing the prompt narrows the range of likely outputs

- Chain-of-thought ("let's think step by step") was a genuine breakthrough on older models — but today's reasoning models do it automatically, so adding it manually is often redundant or counterproductive

- System prompts and user prompts serve different functions and the distinction matters for how you build with AI

- Prompting cannot fix a knowledge cutoff, cannot eliminate hallucination, and cannot add a capability the model doesn't have — those need a different solution

Washington forced Anthropic to shut down its two most capable models — Claude Fable 5 and Mythos 5 — on national-security grounds, making this the first time the US government has ordered a leading AI lab's flagship product offline. That's the centerpiece of a week that also brought a dense open-weight release cycle and new signals on where AI regulation is heading.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Weekly AI Signal Episode 37 - 2026-06-20 (Dr. Priya Nair). Primary external sources include Wall Street Journal reporting via PBS NewsHour.

- The US Commerce Department issued a binding directive forcing Anthropic to disable Fable 5 and Mythos 5 globally — the first time Washington has ordered a frontier model switched off

- The trigger was an Amazon report to White House officials that Fable 5's guardrails could be circumvented, raising fears around cyberattack and bioweapon assistance

- Dozens of researchers signed an open letter arguing the shutdown handed an advantage to less-restricted competitors without meaningfully reducing risk

- The move signals a visible end to the era of frontier AI being governed primarily by the labs themselves

- Open-weight models kept closing the capability gap, with DeepSeek V4-Pro and V4-Flash among the week's notable releases

- The EU AI Act content-labeling playbook landed ahead of its August deadline, adding another regulatory layer to an already crowded week

Docker quietly became one of the most important pieces of software infrastructure in the world — but most people who've heard the name couldn't explain what it actually does or why it matters. This episode covers how containers work, the wild story of Docker the company nearly collapsing while Docker the technology won everywhere, and why it's now the reason self-hosting an AI stack takes minutes instead of days.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Docker (Podcast) - 2026-06-17 (Dr. Priya Nair). Primary sources include InfoWorld's "How Docker broke in half," Contrary Research, and live data retrieval via Vane.

- Containers vs. VMs: why sharing the host kernel instead of booting a full OS is the architectural choice that changed everything

- The "works on my machine" problem — what it was, why it was maddening, and how Docker killed it

- Origin story: how a failing PaaS called dotCloud became Docker after a five-minute PyCon demo in 2013

- The company paradox: Docker the technology reached 92% adoption while Docker the company sold off its enterprise business and sparked a licensing backlash

- The current landscape: how containerd, Podman, and Kubernetes relate to Docker — and where Docker lost the name but won the ideas

- The AI self-hosting angle: why tools like Ollama and Open WebUI ship as Docker images, and what that means for running your own AI stack

Ollama turned running an AI model on your own machine from a weekend project into a one-line command — and it did it by borrowing the exact playbook that made Docker work. This episode covers what Ollama is, how it works under the hood, why it became an ecosystem hub, and who actually cares about running AI locally.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Ollama (Podcast) - 2026-06-17 (Dr. Priya Nair). Primary sources include the official Ollama GitHub README and Ollama's official blog.

- The "Docker for models" framing is lineage, not metaphor — Ollama's co-founder Jeffrey Morgan previously built Kitematic, the GUI that became Docker Desktop

- Ollama runs GGUF-quantized models locally with a single command and exposes them through a local REST server with an OpenAI-compatible endpoint

- That OpenAI-compatible API is the real reason Ollama became an ecosystem hub — it's what other tools (Open WebUI, Continue, LangChain) plug into

- A 2025–26 pivot shifted Ollama from standalone local runner toward a universal local backend, with native desktop apps and `ollama launch` wiring local models into Claude Code, Codex, and Copilot

- The most important misconception to clear up: Ollama is not a model — it's the runtime; the models (Llama, Qwen, Gemma, DeepSeek) are separate and swappable

- Local models trade frontier capability for privacy, cost, control, and offline use — and quality still scales with your hardware

Most businesses assume fine-tuning is the professional upgrade from prompting — it isn't. This episode runs the real comparison: what each tool actually changes, where the spectrum between them sits, and the one diagnostic question that determines which you need.

AI-generated (NotebookLM) audio overview. Source: HexLocal in-house research — Research - Fine-Tuning vs. Prompting (AI Foundations, Ep. 5) - 2026-06-14 (Dr. Priya Nair). Primary external sources include OpenAI's model optimization documentation, Ovadia et al. "Fine-Tuning or Retrieval?" (peer-reviewed), and AWS Bedrock documentation on Claude fine-tuning.

- Prompting edits the input; fine-tuning edits the model's weights — they solve different problems, not different levels of the same one

- The vendors who sell fine-tuning tell you to try prompting first and say it "may be all you need"

- The honest split: fine-tuning is for how the model behaves (style, tone, task structure); RAG is for what the model knows (facts, current data, proprietary content)

- The spectrum between them — system prompts, few-shot examples, RAG, fine-tuning — and where each sits

- The real cost isn't the GPU run; it's the data, the re-tuning cycle, and a frozen model on a deprecation clock

- On Claude specifically, the only fine-tunable model is being retired in September 2026 — which tells you exactly where fine-tuning sits in the toolkit