1016 | Agents at Work: Launch Week Roundup

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

Milo: And I'm Milo. Today we've got a big stack of launches to get through, and honestly, the thread that connects almost all of them is agents — AI that's supposed to actually do work, not just chat. Agents doing back office work, agents running code, agents asking permission before they do something risky, and then all the infrastructure that has to exist for any of that to be real.

Mia: Yeah, and we're going to be careful today. A lot of what founders say about their own products is a claim, not a verified result, so we'll flag where things are unproven. But there are some genuinely interesting patterns here — especially around trust, approvals, and where agents are actually allowed to run. Let's start with the most direct version of the pitch: AI coworkers.

Milo: So the flagship here is a product called Backdrop. The idea is AI colleagues for basically any workflow. You don't program them line by line — there's a skills library you can pull from, and if the skill you need doesn't exist, you can teach the agent a workflow by recording yourself doing it. Then it repeats it. They claim over 1500 integrations, so it can plug into the tools you already use.

Mia: And crucially — approvals and audit. The agent does the work, but a human signs off, and everything it did is logged. That's the part I care about most, because "AI coworker" is a lovely phrase until you ask who checks its homework.

Milo: Right. Who is this actually for? It's broad by design — teams with repetitive but multi-step workflows across several tools. What it changes versus existing automation: traditional tools like Zapier-style flows require you to define every step up front. Recording a workflow and saying "like this" lowers the barrier a lot. But the open question is the big one: how reliable is a recorded workflow when the real world doesn't match the recording? Nobody's published real-world accuracy numbers yet.

Mia: And that unknown applies to the whole category, honestly. Take Lleverage — much more focused than Backdrop. They go after back office specifically: orders, invoices, purchase orders, inside ERP systems. Their headline case is a customer called Topa, where they claim four full-time employees' worth of that work became over 90 percent automated.

Milo: Which sounds incredible — and it's a maker claim. We should say that plainly. If it holds up, going from a four-person team handling invoices and POs to 90-plus percent automation is a massive change for a mid-sized company. ERPs are notoriously rigid, so doing this inside the ERP rather than around it is the differentiator. But we don't know how that 90 percent was measured, what the error rate was, or how much human review was still happening.

Mia: Exactly. And then there's a third flavor: Afterparty, which starts from something you already produce naturally — meeting transcripts. The agents turn transcripts into draft emails, Slack messages, CRM updates. Nothing goes out without your approval. Free tier is five meetings a month.

Milo: I like that Afterparty picked one choke point. Backdrop says "any workflow," Lleverage says "back office," Afterparty says "everything that happens after a meeting." Narrower, easier to evaluate. And all three of them landed on the same trust mechanism: a human approves before anything ships. That's not a coincidence — it's basically the minimum viable trust story for agentic automation right now.

Mia: And it's telling that the approval layer is becoming its own product category. Which is actually our next thread — the protocols underneath this.

Milo: So there's a project called withHuman, and it's an open approval layer — they call the protocol AAP. The idea: any agent making tool calls goes through this layer. Rule-based decisions handle the safe stuff automatically, and anything risky escalates to a human.

Mia: That's exactly the gap. Every product we just talked about builds approvals in-house, per vendor. withHuman is saying: this should be shared infrastructure, a standard, so you don't reinvent permissioning for every agent.

Milo: And alongside it, another open protocol showing up in a very different place: Chatway, a support platform, built on MCP — Model Context Protocol. Their pitch is "bring your own AI": you plug in ChatGPT, Claude, whatever, through MCP, and it powers your support. MCP is available on their free tier, and official connectors are coming.

Mia: Same pattern, right? Instead of Chatway locking you into their model or their AI vendor, the protocol is the interface. Your choice of brain becomes swappable.

Milo: And there's a research-flavored entry in this space too: SuperLocalMemory v2, a local-first memory checkpoint for multi-agent setups. It categorizes what an agent knows as "supported," "related," or "no answer" — which is a nice honesty mechanism, because agents pretending to know things is half the problem. It's AGPL-3.0 licensed and, unusually, backed by four arXiv papers, so there's actual research behind it rather than just a landing page.

Mia: The open question for all of this, though, is adoption. A protocol is only worth something if lots of vendors implement it. MCP seems to be genuinely gaining traction; AAP is new, and whether it goes beyond withHuman is unknown.

Milo: Right. And the same open-infrastructure pattern shows up in developer tooling too — which is where agents have arguably been deployed fastest, so the stakes are higher.

Mia: Which brings us to hardware, actually — the far end of "agents doing real work." Dreamscale Labs, a YC F26 company, does cloud inference for robotics AI. Their pitch is latency: under 100 milliseconds for robotics inference. Their own model, DreamZero 14B, runs in 320 milliseconds, and they claim 8 or more robots per H100 GPU.

Milo: Latency matters enormously in robotics — a robot arm that thinks in seconds is a toy. So if those numbers hold, that's the actual product: low-latency inference at a price point where fleets make sense. Eight robots per GPU is the economics claim. All maker claims, of course, and robotics benchmarks are notoriously hard to compare.

Mia: Then there's siliXcon — spelled s-i-l-i-X-c-o-n — which is wild: natural language in, fully routed PCB out. You describe the board, and an agent called Rocky picks real, in-stock components and routes it. It's in beta, supports 2 and 4 layers, digital-first designs, and the files belong to the user.

Milo: "Files belong to the user" — that phrasing tells you the industry has a trust problem around AI-generated design artifacts. The differentiation versus existing EDA tooling: instead of weeks of component selection and routing, you have a conversation. The limitation is right there in the beta status and the layer count — complex analog or high-layer-count boards are not the market yet.

Mia: And staying on the engineering side but going back to software: Kerno 1.0 is an AI backend QA engineer. It tests your running app locally before the pull request even happens — user flows, security checks, background jobs, it understands MCP and AWS Serverless.

Milo: The positioning is the interesting part: quality gates before the PR, not after. Most AI code review happens on the diff; Kerno claims to exercise the running system. That's a stronger claim — running apps have state, side effects, environments. Whether it catches things humans miss, or just automates what's already automatable, is the open question.

Mia: And one support item that fits here — Polylane Impact Analysis. It checks a pull request against your live infrastructure and telemetry before merge, can block the merge if something looks dangerous, and will even point out missing instrumentation.

Milo: So both Kerno and Polylane are saying the same thing from different angles: pre-merge is where AI quality control should live. That's a real shift from "AI writes code, humans pray."

Mia: Okay — but if AI is writing and testing all this code, where does it actually run? That's the next thread, and it's becoming a product category of its own.

Milo: Buddy Sandboxes is the clearest example. Persistent Linux VMs for AI coding agents: 70 millisecond startup, 50 gigabytes of disk, snapshots, accessible via MCP, CLI, or API, and you pay by the minute.

Mia: Pay-per-minute Linux boxes purpose-built for agents — that's infrastructure that literally didn't exist as a category two years ago. Agents need environments they can thrash in without a human babysitting a dev server. Snapshots matter because agents break things constantly.

Milo: Then there's OpenMuse — the consumer-side version. It's an open-source personal agent, MIT licensed, self-hosted, with a persistent browser, terminal, and file system. It's AG-UI compatible and runs on iOS, Android, and the web.

Mia: So the pattern is the same at both scales: agents need persistent state — memory, files, an environment — and both Buddy and OpenMuse are products whose entire job is providing that. And OpenMuse being self-hosted and MIT means you can run your personal agent on your own hardware.

Milo: And then the ultimate host for agents: the operating system itself. Ubuntu 26.10, codename "Stonking Stingray" — great name — ships GNOME 51, coreutils rewritten in Rust, a unified App Center, and an optional preview of local speech-to-text called Myna.

Mia: Local speech-to-text in the OS is the notable one for our theme. Voice input processed on-device instead of in someone's cloud is exactly the privacy-first direction, and it's showing up in the default desktop of one of the biggest Linux distros.

Milo: From there it's a short step to the consumer apps built on the same principle — local-first, no accounts, no tracking. That's honestly one of the strongest patterns in this whole batch.

Mia: Yeah, let's dig into the personal tools. First, Fwrd: it forwards iPhone SMS to Slack, Discord, or Telegram using Shortcuts. No account required, 15 free forwards a month, and a Pro tier removes the limit.

Milo: That's a tiny, precise tool with a very real problem — wanting your texts visible where your team actually is. And "no account" is doing real work there; it means your messages aren't passing through someone's server farm.

Mia: Then Daddy Issues — great name — a weekly AI briefing for dads. It connects your kids' stuff, your calendar, and tasks, and it claims to catch things needing advance planning, like realizing a birthday is coming before the week of. It's currently free.

Milo: The "catches advance planning" bit is the differentiated feature, because calendar apps show you what's on the date; they don't tell you on Tuesday that you need to act by Friday. Whether the AI reliably catches those is the claim to test. And "currently free" — the monetization question hangs over almost every tool in this group.

Mia: And the third main one: Nostalgia, an iOS app that links your song history with photos, places, and workouts into a timeline. Entirely local, no account, no tracking, with Spotify import.

Milo: So it's essentially an emotional memory layer over your music history. Versus Spotify's own wrapped-style features, Nostalgia keeps it on your device and combines it with your life context. The limitation is inherent to local-first: no sync across devices, no cloud backup, and a real question of whether on-device users will pay enough to sustain it.

Mia: There are two more in the privacy/local family worth mentioning here. Talanoa is an email client that presents your inbox as a chat view, with todos and calendar built in, and on-device AI. It supports Gmail, Outlook, and IMAP, works locally without cloud sync, on macOS, Windows, and Linux.

Milo: Email-as-chat is a genuinely different interaction model — treating messages like conversations rather than a list to triage. And again: on-device AI, no cloud. Same ethos.

Mia: And Apple's HomeView — a 7-inch smart display with Siri AI, Liquid Retina screen, a 12-megapixel camera, that recognizes up to six people by face and voice. Available November 13th.

Milo: It's notable because even Apple's smart home entry leans on local person recognition — though we shouldn't overclaim what Apple processes where; the source just says it recognizes up to six people by face and voice.

Mia: Okay, one more cluster before we close: creative and media tools. And there's a nice undercurrent here — open licenses and one-time pricing as a quiet pushback against the subscription economy.

Milo: Reelbit first: an open-source Mac screen recorder, MIT licensed. The standout details: the moment you stop recording, you get a share link. Auto-zoom and smoothing are applied after the fact, so you can fix framing in post instead of getting it right live. And you can point it at your own S3 or R2 bucket.

Mia: That last one is the privacy story again — recordings go to your storage, not theirs. And "edit after recording" is a real workflow improvement over record-perfectly-or-rerecord. Open source plus your own bucket is a coherent product philosophy.

Milo: Then CinemaLit, for the video people: it measures the color grading of any reference frame in your browser and generates LUTs — Cube files and Lightroom versions — for Log and Rec.709 footage. There are 60 built-in looks, and your first match is free.

Mia: What's clever here is turning taste into measurement. Instead of eyeballing "how do I get that teal-and-orange feel," it samples the reference and gives you a usable LUT. In-browser means no render farm, no install. The limitation is that a LUT gets you close, not identical — grading is more than a lookup table.

Milo: And the last one is just delightful: Shrine. It's a notch app — it lives in your MacBook's notch — that shows your Claude Code, Codex, and OpenCode agent sessions at a glance. And there's a pixel-art room that grows as your agents make progress.

Mia: A Tamagotchi for your coding agents, basically. It's free, and Pro is a 2.49 dollar one-time payment. One-time pricing — not a subscription — for a little monitoring toy. That's the counterweight we mentioned: small, polished, open or cheap-forever tools existing alongside the enterprise agent platforms.

Milo: Which brings us to the final thread, and it's a good closing question: models and money. Two launches that are really about specialization and cost.

Mia: First, GLM-Legal from Z.ai, built on their GLM-5.3 Flash model. Benchmarks: 19.2 percent on Harvey LAB, up from a base of 6.67 percent, and 86.23 percent on LegalBench. API access is by application only.

Milo: Those are big benchmark jumps, but let's be careful: Harvey LAB is a legal benchmark associated with a legal AI company, so improvements on it measure fit to that evaluation, not necessarily performance in a real firm. LegalBench at 86 is strong. The application-only API also tells you they're controlling access — this is early.

Mia: The bigger question you flagged is whether domain-specialized models actually beat generalists on real legal work, or whether a frontier general model with good prompting closes the gap. The benchmarks suggest specialization helps; real workflows are the test.

Milo: And the cost side is Navige, with a concept they call "Sufficiency Intelligence." Instead of always routing queries to the biggest model, it routes to smaller ones when sufficient, adds caching, and protects against agent loops — agents burning tokens going in circles. Watchtower, their monitoring piece, is free, and the paid tier takes four-fifths of the savings they generate.

Mia: That pricing model is interesting — they only get paid out of savings they demonstrably create. That's an alignment mechanism, not just a pricing page. And it directly targets the biggest unspoken problem with agents: they're expensive, especially the loopy ones.

Milo: So if we zoom out on the whole episode: agents are becoming coworkers — in offices, back offices, meetings, hardware labs, and codebases.

Mia: And the two things that keep recurring are trust and cost. Trust through approval layers, audit trails, and open protocols like AAP and MCP. Cost through smaller models, caching, and routing.

Milo: And underneath all of it, the infrastructure question — where agents run, what they remember, and who owns the files and the data they touch. From self-hosted personal agents to local-first consumer apps, ownership keeps coming up.

Mia: The honest unknowns: real-world accuracy at scale for the coworkers, adoption for the protocols, whether domain models beat generalists, and monetization for all the free tiers.

Milo: That's the batch. Thanks for listening — we'll see you next time.

Mia: Bye everyone.