1018 | Agents Get Context, Apps Go Local

Mia: Welcome back to the show, everyone. I'm Mia.

Milo: And I'm Milo. Today we've got a whole shelf of new tools, and there's a thread running through almost all of them: software that sits closer to you — either physically, like on your device or even in your MacBook notch, or in terms of control, like owning your data and your compute.

Mia: Right. So we'll start with the big picture — the AI agent stack — then the tooling around it, then local-first notes, wellness apps, some very niche mapping tools, the notch apps, a grab bag of creator tools, and we'll close with watching what crawls your website. Let's get into it.

Milo: So the agent stack. If you've been following AI tools, you know the pattern: agents are great at talking about doing work, but they need context, they need a runtime, and they need a model. And this week, we saw something for each of those three layers.

Mia: Let's start with the context layer, because that's the one that's been weakest. Notion released version 3.8, and the framing is that your workspace becomes a shared context layer for AI agents. Concretely, that's three things: a Skills API, more than 150 MCP connections, and column-level permissions.

Milo: That last one is the interesting one for anyone doing this seriously. Column permissions mean you can decide what an agent can see at a fine-grained level — not just "can it access the workspace," but which fields within a database. If you're going to let agents read your company's actual working data, that's the kind of control you need. Otherwise you're either locking agents out entirely or giving them everything.

Mia: And MCP — Model Context Protocol — is becoming the standard way agents plug into tools, so 150-plus connections is Notion saying "we'll meet agents wherever they are." The Skills API is the newer idea: packaging know-how so agents can use it, not just raw data.

Milo: Now, one thing to be clear about: this is Notion describing what their update does. Whether it actually makes agents meaningfully better at real work — that's the open question, and Notion's own framing doesn't answer it for you.

Mia: Okay, context layer done. Runtime — that's Craft Agents. It's an open-source desktop app for running AI agents locally. It connects APIs, MCP, and the browser, and it works with any model, including local models.

Milo: The "any model, including local" part is worth pausing on. Most agent tools are built around a specific hosted model, which means your agent's actions flow through someone else's servers. Craft Agents is saying: the orchestration layer can be open source, on your desktop, and model-agnostic. If you want a local model for privacy or cost reasons, you can. If you want a frontier hosted model, also fine.

Mia: And because it's open source, you can inspect what it's actually doing — which, for software that takes actions on your behalf, is not a trivial feature.

Milo: Then the third layer: the model itself. There's a new open release called Step 5 Preview. It's a 600-billion-parameter mixture-of-experts model, with 27 billion parameters active per token. It has a 1-million-token context window, and — this is the headline detail — it was trained specifically for long-lived agents.

Mia: "Long-lived" is doing a lot of work there. Most models are evaluated on single-turn tasks. An agent that runs for hours or days, keeps state, recovers from mistakes — that's a different training target. The fact that a model is being explicitly built for that suggests the field is treating agents as a first-class workload now, not a demo.

Milo: It ships with vLLM and SGLang support, which are the standard open-source serving stacks — so if you run your own inference, you can actually deploy it. That matters for the Craft Agents story, by the way: open runtime plus open model is a complete local stack.

Mia: But let's be honest about the unknown here. A 600B MoE with 27B active sounds great on paper. How does it actually perform in day-to-day agent work — the messy, multi-step, error-recovery stuff? That's not something we can verify from a release. "Trained for long-lived agents" is the maker's claim. Real-world performance in daily agent use is still the big open question.

Milo: Exactly. And before we move on, one more notch-adjacent piece that fits here: there's a tool called CrewTower, a Claude Code mod that puts Claude session controls in your MacBook notch. You can send prompts, stop runs, and see a context overview from the notch. It's $9.99 one-time.

Milo: We'll come back to it properly later with the other notch apps, but it's a nice illustration of where this is heading — people are building cockpit controls for agent sessions, because agent sessions are becoming something you monitor rather than something you babysit in a terminal.

Mia: So that's the stack: Notion 3.8 for context, Craft Agents for runtime, Step 5 Preview for an open model. What comes next, logically, is the tooling that builds and polishes the code these agents write.

Milo: Two tools there. First, NitroStack — a platform for building, testing, and deploying MCP servers. That's the infrastructure side of the MCP story. It has an SDK in TypeScript and Python, it includes a Studio for testing, and deployment to cloud is built in, with chat included too.

Mia: Which fills a real gap. Everyone's connecting agents via MCP, but if you want to expose your own service over MCP, you've had to assemble that yourself — write the server, figure out testing, handle deployment. NitroStack is packaging that whole workflow.

Milo: The second one is my favorite of the two, honestly, because of the framing: Ultracite v8. It's a zero-config linter and formatter specifically for agentic code. It works across Oxlint, Biome, and ESLint, and it checks edits in about 330 milliseconds.

Mia: Why does speed matter so much here? Because when a human writes code, you lint occasionally. When an agent writes code, it's making edits constantly, and each edit needs a quality check fast enough that it doesn't slow the agent's loop down. 330 milliseconds means the check can sit inside the edit loop. That's a genuinely different design constraint than traditional linting.

Milo: And it's "zero-config," which matters when the writer of the code is a machine that didn't read your team's ESLint wiki. The whole point is: agents will produce code, so the quality gates have to be fast, automatic, and require no setup.

Mia: The unknown with both of these is the same: real-world adoption versus what people already use. NitroStack competes with DIY setups and whatever else emerges; Ultracite competes with established lint setups that teams already have configured. Being purpose-built for agents is a good story, but whether it wins in practice — open question.

Milo: And notice the shift in tone as we leave this section: the agent stack is about software doing work for you, but the next group of tools is about software doing quiet, personal work on your own machine. That local-first mindset shows up everywhere now.

Mia: Let's talk notes and meetings. Two tools. Earnote does local Whisper transcription — so speech-to-text running entirely on your machine — and it turns what you record into structured notes: tasks, flashcards, even PDFs. No account, no cloud, and it's MIT licensed.

Milo: The flashcards detail is nice — it's not just transcribing, it's deciding the material is study material and restructuring it. And "no account, no cloud" is a statement: you're not trading your recordings for convenience. MIT license means anyone can fork it, which is the strongest form of "this stays yours."

Mia: Then Parrot, on the Mac side. It's a free, open-source meeting recorder with no bot joining your calls. It transcribes locally, and it gives live answers with sources drawn from your own documents.

Milo: That last capability is the differentiator. Most meeting recorders give you a transcript after the fact. Parrot is saying: during the meeting, when someone asks a question, it can answer with citations from your own document set — locally. No bot in the call is also a real point; a lot of people hate having a "recording participant" show up in their meetings.

Mia: Together, these two show the same trade being made in both cases: giving up cloud convenience — sync, sharing, fancy hosted AI — for privacy and ownership. Whether that trade is worth it depends on your threat model and how much you value those cloud features.

Milo: The honest unknown here is audio quality. Local Whisper transcription is impressive, but in a noisy room, with overlapping speakers, on a laptop mic — how does it hold up? That's exactly the condition real meetings happen in, and it's the thing nobody can verify from a feature list.

Mia: And the local-first idea doesn't stop at notes. Let's go somewhere more personal: health and feelings. There's Train with Pasta, an AI personal trainer driven by voice, built on Apple Intelligence. Fully local, no account, and it creates workouts and weekly plans.

Milo: So you talk to it — "I want to train three times this week, I have dumbbells at home" — and it builds the plan. Running on Apple Intelligence means the processing stays on device. For health data, that's a meaningful difference from fitness apps that upload everything.

Mia: And Emochi takes it further into feelings. It's a voice diary where your entries transform into a character called a "Mochi" that changes over time, and it shows you your emotion patterns. It's based on affect research.

Milo: That's an interesting design choice — making emotional patterns visible through a character that changes, rather than a dashboard of graphs. The character becomes a mirror. And "based on affect research" is the grounding claim; whether that research translates into genuinely useful pattern recognition for an individual user, we can't say.

Mia: What unites these two is the sensitivity of the data. Workout habits, health goals, your emotional state read aloud into a microphone — this is exactly the data people are least comfortable sending to a cloud. Running it locally means sensitive personal data stays private while AI still helps.

Milo: The shared unknown: how accurate is local wellness advice, really? Both apps are making claims — workout plans, emotion patterns — without a clinician or researcher in the loop. Treat those as claims, not verified results. Useful companion? Plausibly. Medical or psychological guidance? No.

Mia: From there, let's go to tools that know where things are — very literally, in a couple of cases. LooGo is a toilet finder for Android and Wear OS with over a million locations, sourced from OpenStreetMap. It includes codes, prices, and accessibility info, and there are no ads.

Milo: Over a million locations from OpenStreetMap — that's the power of open geographic data. And the details are what make it useful: knowing there's a toilet nearby is one thing; knowing it needs a code, or costs money, or is accessible — that's what actually determines whether it works for you. And the accessibility info especially makes this more than a convenience app.

Mia: Next, Spiralens — an Android camera app built around the golden ratio. An arrow shows you where to move your phone, and a green ring appears when you've got the composition — and it works fully offline.

Milo: That's essentially composition training built into the camera. The arrow-and-ring feedback loop is a nice touch — it teaches while you shoot. Offline matters because camera apps are exactly where you don't want to wait on a network.

Mia: And then something completely different in subject but similar in method: Unfenced. It checks roughly 700,000 US real estate listings every week against official maps, and it finds about 13,600 properties that directly border public land.

Milo: So the insight is: listing descriptions say things like "near national forest," but by comparing listing locations against official boundary maps, you can find the properties that actually touch public land — meaning you could literally walk out your door onto it. That's a data-mapping insight that a standard property search can't give you.

Mia: Three tools, three completely different problems — finding a restroom, framing a photo, finding land next to a forest — but the same engine underneath: structured geographic or spatial data, applied precisely. The shared unknown is also the same: how fresh does that data stay? OpenStreetMap entries, listing databases — maps and listings change. Whether these stay current over time is the thing to watch.

Milo: Now let's go back to hardware, sort of — the MacBook notch. We mentioned CrewTower earlier; let's give it its due alongside its neighbor. CrewTower, $9.99 one-time, puts Claude Code session control in the notch: send a prompt, stop a run, see a context overview — without switching windows.

Mia: The context overview is the genuinely useful part for anyone running long agent sessions. When your agent has been working for twenty minutes, you want to glance at how much context it has left without alt-tabbing and interrupting your own focus. The notch is a glanceable surface by design.

Milo: And Korinotch is the general-purpose version of the same idea. It's a macOS notch app with a media HUD, notifications, a file tray, clipboard access, and a keyboard lock. Fourteen days free, then $11.50 — also lifetime, one-time.

Mia: Two apps, both betting on the notch as a control surface, and both betting on one-time pricing rather than subscriptions. That pricing alignment is interesting — small utility developers are increasingly trying the "pay once, own it" model against the subscription tide.

Milo: And notice how CrewTower connects back to our first topic — it's agent control hardware, basically. The notch becoming a workstation for AI workflows, and Korinotch showing the same surface works for everyday shortcuts too. The open question for both: will developers actually keep using the notch daily, or is it a novelty that lives in the menu bar graveyard after two weeks? Glanceable is good, but habits are hard.

Mia: Alright, last stretch before we close — three tools covering the whole creator journey, from personal knowledge to business planning to raw compute costs. First, Caldera: it turns an Obsidian vault into a self-updating profile and linked digital gardens. It's private, open source, and self-hostable.

Milo: So your notes don't just stay in your vault — they become a living public-or-private web presence that updates itself, connected to other digital gardens. The self-hostable and open-source part keeps it in the same control-your-own-data family as everything else we've discussed today.

Mia: Then Draper, at $9 a month. It's an AI app that evaluates business ideas with sourced verdicts, and then walks you step by step toward a plan, a brand, a landing page, and your first customers.

Milo: The "sourced verdicts" is the part to hold onto — it's not just saying "good idea!" with enthusiasm; it claims to back judgments with sources. And the step-by-step structure addresses the actual failure mode of idea evaluation: everyone gets feedback, few people execute. Draper is trying to bridge that.

Mia: But — same rule as always — that's the maker's claim. How reliable Draper's verdicts actually are is unknown, and at $9 a month, you're paying for guided execution as much as for judgment.

Milo: And the third piece: GPU Terminal. It compares GPU rental prices across 61 providers — H100s starting at $0.12 an hour — with price history and links to the sources. Open source.

Mia: This is the plumbing of the whole episode, honestly. If you listened to the first segment and thought "I'd like to run Step 5 Preview myself" — the next question is what an H100 costs this week. And GPU rental prices shift constantly, which is exactly why a price-history tool with sources exists. Whether prices shift too fast for any comparison to stay useful is the fair question — but the history view helps with that.

Milo: So that trio — Caldera for your knowledge, Draper for your venture, GPU Terminal for your compute bill — covers the creator journey with transparent, self-controlled tools at each step. Which leaves one last thing, and it's a fitting close for an episode about agents roaming the web: who's watching the watchers?

Mia: Salience. It takes your server and CDN logs and turns them into a live view of every request hitting your site — from search engines, from AI crawlers, and from human users. And it spots errors, plus something sneakier: bot impersonation.

Milo: Bot impersonation is the detail worth explaining. A crawler that claims to be Googlebot but isn't — that's a real thing that happens, because pretending to be a search engine gets you past blocks. If your logs are just a firehose, you'd never catch it. Salience is saying: here's who is actually at the door, and whether they are who they claim to be.

Mia: And why now? Because AI crawlers have intensified dramatically — every AI company is scraping the web for training and for live retrieval. Site owners have mostly been flying blind about it. Tools like this make the invisible visible.

Milo: The unknown, as with any log-analysis tool: how well does it scale on very high-traffic sites? Live views of everything are expensive to compute at serious volume.

Mia: So let's pull it together. Today we saw the agent stack assembling in real time — context in Notion 3.8, runtime in Craft Agents, open models like Step 5 Preview — and the supporting tooling maturing around it, from NitroStack's MCP servers to Ultracite's 330-millisecond code checks.

Milo: Then the local-first wave: Earnote and Parrot keeping your words on your device, Train with Pasta and Emochi keeping your health and feelings there too. Niche mapping tools — LooGo, Spiralens, Unfenced — solving surprisingly different problems with the same data-driven approach.

Mia: The notch turning into a workstation with CrewTower and Korinotch. The creator toolkit — Caldera, Draper, GPU Terminal. And Salience closing the loop by showing you exactly who's crawling your site.

Milo: The common thread in all of it: control. Your context, your model, your notes, your health data, your land search, your logs. The tools are getting more capable and more yours at the same time.

Mia: And the recurring caveat, because it matters: almost everything today arrived as maker claims. The interesting verification — how Step 5 handles real agent work, how local transcription handles a noisy room, how Draper's verdicts hold up — that happens in the weeks after launch, not in the announcement.

Milo: Thanks for listening, everyone. We'll be back with more soon.

Mia: See you next time.