1027 | The Tools of the Week: Agents, Apps, and Open Source

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

Milo: And I'm Milo. Today's thread is really one story told in pieces: AI agents are graduating from chat to doing actual work — writing code, applying to jobs, running cloud cleanup — and a whole layer of tooling is growing up around them to make that safe, affordable, and private.

Mia: So let's start with the biggest piece of it: running many coding agents at once, without losing control. Because the honest answer right now is that parallel agents work, but review and provenance are the missing pieces.

Milo: Exactly. Start with AVP. It's an open-source protocol for versioning what code agents do. Every change an agent makes has to be proven on the exact head of main, and it all happens through ordinary Git commits. That last part matters more than it sounds — this isn't some parallel versioning system bolted on the side. Your existing Git history just becomes the proof.

Mia: Right, and the "exact head of main" bit is the real guarantee. The claim is that an agent's change is anchored to the precise state of the branch it was built against. So you know what the agent actually saw when it made its edit. If something breaks later, you can trace it back.

Milo: And that's the provenance problem in a nutshell. When five agents are committing to a shared repo, the question "what did this change assume?" gets really hard to answer. AVP's bet is that the answer should live in Git itself, not in some tool's internal log.

Mia: But a protocol alone doesn't run your day. Around it there's a whole workspace layer, and the first example is ManyAgents — a Mac app that orchestrates a team of Claude Code or Codex agents, each one in its own git worktree.

Milo: The worktree detail is doing a lot of work there. If every agent gets its own worktree, they're physically isolated — two agents can't stomp on each other's files mid-edit. And ManyAgents adds a reviewer that's read-only. So one agent can look at what the others produced without being able to change it. That separation — the reviewer can't author, the authors get reviewed — is a structural answer to the trust problem.

Mia: Then there's VibeiDE, which attacks the same issue from a different angle. It's a desktop with parallel task queues for Codex, Claude Code and OpenCode. Each task gets a fresh session, and every result waits for human review before it's accepted.

Milo: Two things worth pausing on. Fresh session per task means no context bleed — an agent doesn't drag assumptions from an old job into a new one. And the human-review gate is deliberate: nothing lands until a person has seen it. That's the trade — you get parallelism, but you also get a queue of things to actually review. If you don't keep up, the review pile becomes the bottleneck.

Mia: A third take on the same problem is AI Bridge — a Mac app that runs Claude Code, Codex, Grok and OpenCode as real terminals, not a custom UI pretending to be one. Agents are grouped by responsibility, and alongside them you get Kubernetes, databases and Slack in the same place.

Milo: Grouping by responsibility is interesting. Instead of "I have seven identical agents," it's "this one owns the backend, that one owns infra." And putting databases and Kubernetes next to the agents suggests the same person is supervising both the agents and the systems they touch, which is honest about how this work actually happens.

Mia: And then the visibility layer: tabsh. It's an MIT-licensed Rust daemon that shows all your code-agent sessions on a Kanban board inside one browser tab. Statuses come in via hooks, and it's 100 percent local.

Milo: That's the piece you don't notice you need until you've run three agents and lost track of which one finished and which one's stuck. A local Kanban of session states means the oversight doesn't depend on anyone's cloud. So you can stack these: a protocol like AVP for provenance, ManyAgents or VibeiDE for structure, AI Bridge for the terminals, tabsh to see it all.

Mia: The open question, though, is which orchestration pattern actually wins. Team-of-agents-in-worktrees, task queues with fresh sessions, responsibility groups — those are different philosophies, and nobody has settled it. What we can say is they all converge on the same two answers: isolation and human review.

Milo: Which is a nice segue, actually — because once agents are doing real work beyond code, they need plumbing. Take AllModels: a single endpoint that routes to abliterated models, with automatic fallback between providers, and selection based on modality and price comparison.

Mia: The fallback part is the quiet hero. If your provider is down or rate-limited, the router just moves you. And being able to pick by modality and price means you're not manually shopping every time the requirements change.

Milo: Then there's the workflow side. N8N Chat UI is a no-code builder for customizable AI chat widgets on top of n8n workflows, with a JavaScript API, streaming, and plugins. So if you've already built automations in n8n, you get a frontend for them without writing one.

Mia: And the "agents doing your chores" category — Jobmate AI is a Chrome and Firefox extension with an agent that auto-applies to jobs, pre-fills forms, and tracks your applications.

Milo: That's the boldest leap in this group, and it's worth treating carefully. What we know from the source is what it claims to do: auto-apply, pre-fill, track. Whether the applications are actually good is an open question — nobody has verified that. It's the same pattern as the coding tools: automation is easy, quality control is the hard part.

Mia: On the visual side, SurgePix does AI-generated visuals but with layer-based editing, editable text, and brand kits — plus open-source agent skills for Claude Code and Cursor.

Milo: The layer editing is what separates it from one-shot image generators. You get a generated image, but you can go in and change the text, adjust layers, keep it on-brand. And shipping agent skills means your coding assistant can produce branded visuals as part of its workflow.

Mia: Now, all of this doing-things-at-scale has a downstream consequence: cloud bills. Which brings us to CloudKnife, a FinOps platform for Azure that handles cost optimization end to end.

Milo: The architecture is what's interesting. It has a deterministic core that enforces hard rules — so the boring, must-happen stuff like "don't exceed this budget" is handled mechanically, not by an AI's judgment. And then it's approve-then-auto-execute: a human approves an optimization, and the platform executes it automatically after that.

Mia: Notice the echo from our first topic. VibeiDE makes every agent result wait for human review; CloudKnife makes every optimization wait for approval. Same pattern — human gate, then machine execution. As agent usage grows, someone has to keep the bills sane, and this is one answer for Azure specifically. The limitation, of course, is that it's Azure-only, and we don't have independent evidence of how well its optimizations perform — that's a maker claim.

Milo: From big cloud money down to small tools that just work. And I mean small in the best sense — each of these has exactly one job. Helio is an open-source, MIT-licensed solar dashboard. It reads your inverter data via ShineMonitor, it's self-hostable on Vercel, and it needs no database.

Mia: No database is a real design decision, not a shortcut. It means there's almost nothing to maintain — if you have a ShineMonitor-compatible inverter, you get your own solar dashboard instead of whatever app the vendor gives you, and you host it yourself.

Milo: Then a genuinely useful freebie: PDF Accessibility Checker by WebYes. It's free, no sign-up, and it checks PDFs against WCAG 2.1 AA and PDF/UA. Problems get ranked by severity and highlighted right on the page.

Mia: The on-page highlighting is the part that makes it usable. Accessibility reports usually hand you a list of cryptic errors; this one shows you where on the page the problem is, sorted by how bad it is. For anyone who has to make documents compliant, that's the difference between a report and a to-do list.

Milo: And something completely different: 2G, a free sampler for Windows and macOS that imitates an early-2000s phone. You describe a sound and it synthesizes it — neural synthesis — but everything runs at 16 kHz mono through a simulated speaker, with four voices.

Mia: That spec is the whole charm. It's not trying to sound good by modern standards; it's trying to sound like texting your friend on a Nokia. Constraints as a creative feature, and free on top.

Milo: Which brings us to the privacy and local-first corner, and these three fit together nicely. First, omerta — an MIT-licensed CLI and pre-commit hook that detects real values from .env files in git. Even encoded ones. It works offline, and it never prints what it finds.

Mia: Every piece of that matters. The pre-commit hook means the secret gets caught before it enters history at all — the cheapest possible moment to fix it. Detecting encoded values means you can't hide a key behind base64 and call it safe. Never printing them means the scanner doesn't leak the very secret it's catching. And offline means the content never leaves your machine to be scanned.

Milo: Then desigma — a free Figma alternative written in Rust. It's native on macOS, Windows and Linux, works offline, imports .fig files, and does live collaboration over encrypted P2P. It's in early alpha.

Mia: Two things to weigh there. The .fig import is the on-ramp — you don't have to abandon your existing design files to try it. And encrypted P2P collaboration means your design work doesn't route through someone's server. But early alpha is the honest caveat: it exists, it's free, and it's not finished. Treat the capabilities as direction, not promise.

Milo: Third in that group: Standfast, a free macOS menu-bar app for people running self-hosted GitHub Actions runners. It checks both launchd and the GitHub API, and reveals runners that have become disconnected.

Mia: The dual check is the whole insight. launchd can tell you the process is running on your machine — but the runner can be alive locally and dead to GitHub, not picking up jobs. Checking both sides catches that mismatch, which is exactly the failure you can't see from either side alone. Free, sits in the menu bar, does one job.

Milo: Last group: everyday apps — health, voice, assistants, and a bit of retro fun. Start with the one aimed at exactly the people listening to a podcast about agents: WhoIsCooking. It's a five-dollar Mac app that shows you which AI agent is heating up your Apple Silicon.

Mia: And it doesn't just show you — it moves the work to the efficiency cores, with a claimed reduction of around 14 degrees Celsius, and it does it without killing any processes.

Milo: That last clause is the differentiator. The obvious fix for a hot machine is "quit the app." WhoIsCooking's claim is that you reschedule the work instead of destroying it — your agent keeps running, just cooler. Worth noting: 14 degrees is the maker's number, not something we've verified.

Mia: On the voice side, Loqui does dictation on Mac and Windows that lands as clean text in whatever app you're using — no copy-paste dance. It adapts tone to context, transcribes meetings, supports over 90 languages, and the audio is discarded after transcription.

Milo: That last point is the privacy story, and it's stated plainly: the audio is thrown away once it's transcribed. For meeting transcription especially, that's the question everyone should be asking — where does the recording go? Here, the claim is: nowhere.

Mia: Then something purely fun: Flipcorder, 4.99 on iPhone, turns your phone into a 1991 camcorder. You shoot 20-second "flips," you get one dated cassette per day, and there's no editing and no subscription.

Milo: The one-cassette-per-day rule is the design. It's a constraint that could actually become a habit — one little clip a day, dated, done — instead of an endless camera roll you never revisit.

Mia: From retro to proactive: Kiwi is an AI assistant that sends you an SMS at the right moment — a delayed flight, a package update, a free Saturday — and then acts after you say yes, over iMessage or WhatsApp. It's free while in pilot.

Milo: Notice the gate again — it acts after your yes. It doesn't rebook your flight on its own; it asks, then does. Same human-approval pattern we saw in the agent tools, just wearing a messaging app. And "free in pilot" tells you the model may change later, so it's worth knowing that's the current state, not a permanent price.

Mia: Then a health-adjacent one: Mozy is an app blocker for Android and iPhone where walking earns you screen time — 34 steps buys one minute. No GPS, no account, and apps you've locked unlock at midnight.

Milo: No GPS is the detail to highlight — it's counting steps, not tracking where you went. And the midnight reset is what gives it teeth: any minutes you didn't spend are gone, so the lock actually bites.

Mia: And the last one ties back to where we started: Strawberry 1.0 is an AI browser with "Companions" that are shared across a team, automating research, meetings and follow-ups inside accounts you're already connected to.

Milo: Two things there: they work in accounts that are already authenticated, so they're delegating within your existing tools rather than asking you to reconnect everything. And they're team-shared, so it's automation as a group resource, not a personal toy. Whether that delegation is reliable enough to trust — same open question as every agent in this episode.

Mia: So if you zoom out: agents are doing more real work, and everything we covered — provenance protocols, isolation patterns, approval gates, cost control, local-first utilities — is the scaffolding being built to make that trustworthy.

Milo: The honest summary is that the pieces are strong but the patterns aren't settled. Nobody knows yet whether worktree teams, task queues, or responsibility groups win, and most of the numbers we quoted are maker claims. But the direction is unmistakable: human review, provenance, and keeping things local are becoming the default expectations, not the extras.

Mia: That's the show. Thanks for listening — we'll catch you next time.