1021 | Agents That Ship: This Week in AI Tools

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

Milo: And I'm Milo. Today we're doing a briefing that pulls together a single day of launches — everything from agent infrastructure to a humanoid robot to a wellness app you text with — and we're going to try to make sense of the patterns rather than just rattle off a catalog.

Mia: Right, because the interesting thing about a pile of launches like this is that they answer each other. One launch says agents should improve their own tooling, another says here's the hardware to run them, another says here's how agents pay for tools — and you start to see the shape of an argument.

Milo: Let's start with the one that's probably the most conceptually strange. Google Research has an open-source framework called Harness², and the pitch is that agents auto-evolve their own harness. The reported result is up to 11.5 points of improvement on benchmarks.

Mia: And it's worth slowing down here, because "harness" is one of those words that gets thrown around without being explained. The harness is everything around the model — the scaffolding, the loops, the tools it gets, the way results get checked. Most people think of that as fixed infrastructure. Harness² says: no, let the agent itself iterate on that infrastructure.

Milo: So the agent isn't just solving the task, it's rebuilding the machinery it uses to solve tasks, and the benchmark scores move. Up to eleven and a half points is a real number if it holds across contexts — though that's exactly the caveat we should keep. These are the makers' claims. We don't have independent verification, and benchmark gains don't always translate to your specific workload.

Mia: What we can say concretely: it's open-source, it comes out of Google Research, and the reported ceiling is +11.5 points. Those are the facts. Everything beyond that — whether it works well outside benchmarks, what the compute cost of self-evolution looks like — is an open question.

Milo: And the reason it's interesting in context is that a whole ecosystem is forming around the assumption that agents are getting more capable. RunInfra, for example, is selling flat ten-dollar-a-month coding plans — fast open models like GLM 5.3 and DeepSeek, usable inside Claude Code, with 99.5% cache hits.

Mia: Flat pricing on coding agents is a statement. If your infrastructure is cheap and predictable, you can afford to run agents a lot — lots of iterations, lots of retries. The 99.5% cache hit figure matters too, because caching is how you make flat-rate economics survive heavy use.

Milo: Same caveat applies, though. The 99.5% figure is what RunInfra says about itself. If your workload has low cache affinity, flat ten dollars might not be the deal it looks like. But the direction is clear: coding agent access is becoming a commodity subscription, like hosting.

Mia: And then the third piece: Composio Instant. This one gives agents a shared wallet to pay for tools on demand — they claim 1,500-plus tools, no signups, no API keys, two dollars of free credit, zero percent markup.

Milo: That's the missing plumbing, isn't it? If you take the three together, you get a coherent stack: Harness² makes the agent's scaffolding self-improving, RunInfra makes the compute a flat subscription, Composio makes tool access something an agent can just buy in the moment.

Mia: The shared-wallet idea deserves a beat. Normally, connecting a tool to an agent means someone — a human — signs up, gets an API key, pastes it somewhere. Composio Instant collapses that into a payment. The agent needs a tool, the wallet pays, done.

Milo: The obvious question is governance. A shared wallet for agents means deciding how much an agent is allowed to spend before a human checks in. That's not answered in what we have. Two dollars free credit and zero markup tell you about the business model, not about the safeguards.

Mia: Which is fair to note across all three of these: they're claims from the makers, and the interesting open question isn't whether the demos work, it's what happens when real teams adopt them. Who audits what the self-evolving harness changed? Who watches the wallet?

Milo: And there's a natural next question once you've built self-improving agents on flat-rate compute with on-demand tool budgets: what hardware does all this actually run on?

Mia: Intel's answer is the GPU D270, and it's a deliberately unusual bet. It's an inference GPU with up to 480 gigabytes of LPDDR5X — and the "no HBM" part is the story.

Milo: Explain that for listeners who don't follow memory markets. HBM, high bandwidth memory, is the expensive stacked memory that most AI accelerators use. LPDDR5X is the stuff in your laptop or phone — much cheaper, much slower.

Mia: Right. The D270 pairs that big, cheaper memory pool with 1.5 terabytes per second of bandwidth, 1.3 petaflops of FP8, and — notably — 350 watts, air-cooled. So it's not a datacenter-only part.

Milo: The logic: inference, especially for big models, is often memory-bound. If you need the weights in memory, 480 gigabytes at LPDDR5X prices gets you a lot of model per dollar — at the cost of bandwidth versus HBM.

Mia: Whether that trade wins depends entirely on the workload. For batch inference where throughput matters more than latency? Maybe. For latency-sensitive serving? That's where HBM systems have historically won. Intel is betting a segment of inference doesn't need HBM, and 350 watts air-cooled is the tell that they're aiming somewhere other than the biggest clusters.

Milo: So that's hardware. But there's a completely different corner of this same day worth visiting — search. Because agents that work autonomously do a lot of searching, and Exa 3.0 is claiming the top of search API rankings.

Mia: The two features that stand out: Dynamic Highlights, which they say cuts tokens by 95 percent, and a cheap tier called Exa Lite at four dollars per thousand requests. Plus billions of newly indexed documents.

Milo: The 95 percent token cut connects directly to what we were just saying about flat-rate compute. If your agent's context is full of raw search results, you're paying to process junk. Highlights that return only the relevant passages make every downstream call cheaper. It's the same economics argument at a different layer.

Mia: And "top-ranked" — again, that's Exa's claim about rankings. We should treat it as their characterization. What's concrete is the pricing, the token reduction mechanism, and the index size.

Milo: Then there's the odd one out in this cluster, and honestly it's delightful: Menlo's Asimov 1. An open-source humanoid robot, 1.2 meters tall, 25 joints, sold as a twenty-thousand-dollar kit, already shipped to over 20 countries.

Mia: Twenty thousand dollars for an open-source humanoid kit is a number worth sitting with. The Robot Vacuum was two hundred. Boston Dynamics' machines were six figures. Twenty K as a kit — meaning you assemble it — puts it in a genuinely new range.

Milo: "Shipped to 20-plus countries" is maker-reported, but it's a distribution claim, not a capability claim — it tells you demand exists, not what the robot can do. Twenty-five joints and 1.2 meters tell you about the physical spec, not the autonomy. The open questions here are enormous: durability, what software runs on it, what people actually use it for.

Mia: But the through-line holds. Harness² is agents evolving their software bodies; Asimov 1 is an open, hackable physical body. The impulse is the same — make the platform open and let the builders loose.

Milo: And honestly, the most human story of the day fits that theme too: /dev/null. A social network for developers, built live in 48 hours by four people — Nuno Maduro, Brent Roose, Matthieu Napoli, and Pauline Vos. GitHub sign-in, open source, and pull requests merged on stream.

Mia: Forty-eight hours for a social network sounds like marketing until you notice the method. Open source from minute one, PRs merged on stream — the build process was the marketing. It's the same self-building ethos: don't hide the scaffolding, show it.

Milo: It's also a reminder that a lot of "agent infrastructure" is still just... people building things together fast, in public. Okay — so we've covered agents improving themselves, hardware and search underneath them, and a robot plus a weekend-built social network as the open-platform edge. The next thread is more grounded: local tools, where people are building their own knowledge and code on their own machines.

Mia: First up: yggy. It's a self-building AI knowledge graph from documents and systems. Facts keep their sources, merges are reversible, it's EU-hosted, and there's an API and MCP support.

Milo: Every word of that description is a design decision worth unpacking. "Facts keep their sources" — in most knowledge management tools, extraction loses provenance. You get a summary and the original is gone. Here, the graph node points back to where the claim came from.

Mia: And "merges are reversible" is the quiet hero. Automated graph building will make mistakes — it'll merge two entities that shouldn't be merged. If merges are irreversible, users learn to distrust the system. Reversible merges mean the system can be aggressive and you can undo.

Milo: EU-hosted matters for a specific audience — anyone with data residency concerns. And MCP support means coding agents can read and write the graph, which connects back to everything we opened with. The knowledge graph becomes another tool in the agent's belt.

Mia: Second: snygy — or as the product is named, snyvi. A free, open-source, MIT-licensed desktop app that gives each project a desk with up to four coding agents side by side, all local.

Milo: Compare that to the cloud-coded world we discussed with RunInfra. This is the opposite philosophy: your agents run on your machine, your code never leaves, and it's MIT so you can fork it.

Mia: Up to four agents side by side is an interesting workflow claim, too. It assumes you're running parallel agents on the same project — which is only sane if you're reviewing their output. The tool doesn't promise the agents are good; it gives you the layout to manage them.

Milo: And third in this cluster, Paul Ford's Tiny Little Office. Ten apps where documents live entirely in the URL hash. No accounts, no servers, open source.

Mia: That's almost a provocation. The URL hash — the part after the # — never gets sent to any server. So your document is stored in the address bar itself. Share the URL, and you've shared the document. No database, no login, nothing.

Milo: It's Paul Ford, so there's a point being made. Three tools — yggy with EU hosting and reversible merges, snyvi fully local, Tiny Little Office with no server at all — all answer the same question differently: how much of your tooling do you actually own?

Mia: yggy says: hosted, but with provenance and reversibility so you can audit it. snyvi says: never leave my machine. Tiny Little Office says: the web itself is enough, if you're clever about it. They're not competing products; they're three positions on a spectrum.

Milo: So the question that follows naturally: once you've got your local setup — your agents, your knowledge graph, your serverless documents — how does the actual work loop run? How do you get feedback and keep things moving?

Mia: Start with Inflight. It's a feedback layer for prototypes. You pin comments and video to the live app, and coding agents pull next steps via MCP.

Milo: The video part matters more than people might think. A screenshot doesn't show a scroll jank or an animation glitch. Pinning a video recording to the exact spot in the live app is much richer feedback than a text comment.

Mia: And the MCP piece closes the loop we keep circling: the feedback doesn't go to a human's ticket queue, it goes where coding agents can pull it directly. The bug report becomes the agent's next task. Again — that assumes someone reviews what the agent does with it, but the plumbing is the point.

Milo: Then there's a prototype that's literally hardware. ESP-Mosaico is a modular dev board built around the ESP32-S31, and its pitch is that AI coding agents can build, deploy, and iterate on real hardware.

Mia: That's a bigger deal than it sounds. Software agents iterate fast because compiling code is cheap. Hardware iteration meant flashing a board, watching it fail, maybe bricking it. A board designed so agents can build, deploy, and iterate in a loop brings the software development loop to physical devices.

Milo: The modularity is the enabler — a modular board means the agent can swap or reconfigure components rather than being stuck with one fixed rig. It's early, and what "iterate on real hardware" concretely covers isn't spelled out, but the direction is clear.

Mia: Then the terminal. xtty is a native macOS terminal built specifically for SSH work: batch connect, password autofill through Keychain, sz and rz file transfer, tabs, and agent status.

Milo: "Agent status" in a terminal is quietly significant. Terminals have been the same for decades. Adding a status indicator for what an agent is doing implies people now run agents inside SSH sessions and need to see them at a glance.

Mia: And batch connect plus Keychain autofill is a quality-of-life bundle for anyone managing more than a couple of servers. It's the kind of tool that gets adopted because it removes ten small frictions, not because of a headline feature.

Milo: And the last piece of the loop: Portlivo. A Mac menu bar app, $8.99 one-time, that lists all your local dev servers and ports, with one-click open, kill, restart, and logs.

Mia: The one-time price is worth noting in a world of subscriptions — it sits alongside RunInfra's flat ten bucks as a pricing philosophy: predictable, small, done. And functionally it's the missing dashboard for the local world we discussed earlier — if snyvi gives you four agents on a desk, Portlivo gives you visibility into the servers they started.

Milo: So the loop is closed: prototype with feedback pinned to it, hardware that agents can iterate on, a terminal that shows agent status, and a menu bar that shows your servers. Each tool assumes agents are in the workflow, and each adds visibility. What comes after building? Shipping.

Mia: Hoistbay is a free, open-source, MIT desktop app for S3 and CloudFront. Auto header rules, folder downloads, one-click cache invalidation.

Milo: Cache invalidation being one click is the feature anyone who's fought CloudFront will feel. AWS's invalidation flow is famously clunky, and if you ship static sites, you invalidate constantly. Auto header rules — cache headers applied by rule rather than by hand — removes another recurring chore.

Mia: MIT-licensed and desktop-based, again matching the local-ownership pattern. Then there's Jotform App Builder, which goes a different direction: build no-code apps — portals, stores, catalogs — inside ChatGPT and Claude, from your Jotform forms.

Milo: The interesting move is the distribution. The app doesn't live on a website you maintain; it lives inside the chat platforms people already use. If your forms and data are already in Jotform, this turns them into an app without a separate build-and-host cycle.

Mia: It's a very different bet from Hoistbay's. Hoistbay is for people who own their stack. Jotform App Builder is for people who'd rather live inside someone else's platform if it means shipping today. Both are "shipping," but for different appetites for ownership — the same spectrum from our local-tools discussion.

Milo: And the third piece of shipping is the part that usually rots: documentation. Mintlify Autopilot is an agent that watches your repos and Slack, drafts documentation updates as pull requests, and learns style from your merged and closed PRs.

Mia: Docs-as-PRs is the right shape, because it puts docs through the same review gate as code. The learning-from-merged-and-closed-PRs detail is clever — closed PRs are negative examples. Most systems only learn from what got accepted. Learning what your team rejected is how you match their taste.

Milo: The open question, as with all these agents: an agent drafting doc PRs that mostly get closed is noise, not help. The tool's value depends entirely on how good its drafts are, and we don't have evidence either way. But structurally, it's the same loop as Inflight — the agent produces a draft, a human reviews the diff.

Mia: So the whole chain — build locally, get feedback, ship to the web, keep docs alive — now has an agent somewhere in it. Which raises the last big question: when the users themselves show up, do they also get an agent in the chat?

Milo: First: reception. Native iOS in-app support chat with AI trained on your docs. Reviews and offers shown in chat, a Telegram inbox on the backend, and twenty-five dollars a month flat.

Mia: The Telegram inbox detail is more interesting than it looks. It means the maker answers support from a messaging app they already have open — support stops being "log into the dashboard." And the AI handling first-line questions from your docs means the human only sees what the AI can't resolve.

Milo: Flat twenty-five a month is also a statement — no per-seat or per-conversation pricing, which for support tooling is unusual and predicts predictable costs. And "reviews and offers in chat" suggests they see support as a sales surface, not just a cost center. Though how well AI-from-docs actually resolves things depends entirely on how good your docs are — which loops right back to Mintlify Autopilot.

Mia: Second: bonds. A messaging app where each friends' chat gets an AI companion called bondi, which generates apps and games inside the chat.

Milo: That's a genuinely weird product and I mean that as a compliment. The AI isn't a chatbot you talk to — it's a companion that builds playable things in the conversation. The group chat becomes a place where software gets created on the fly.

Mia: It's consumer-facing agent building — the same capability theme as Jotform App Builder, but social instead of commercial. Instead of building a store from your forms, bondi builds a game for your friend group. Whether that's a novelty that fades in a week or a new social habit, we genuinely don't know. There's no evidence in what we have either way.

Milo: Third: ToDo.is. An AI agent that executes to-dos — research, files, websites — around the clock, on web, WhatsApp, and Telegram, and it asks before risky actions.

Mia: The "asks before risky actions" is the governance question from Composio Instant, answered at the consumer level. An agent running 24/7 that can touch files and websites is only acceptable if there's a checkpoint before anything destructive. That single design decision might matter more than the rest of the feature list.

Milo: And note the channels — WhatsApp and Telegram, same as reception's inbox and close to bonds's territory. The pattern is unmistakable: agents aren't getting new apps, they're moving into the messaging apps people already live in.

Mia: So: support, social play, and personal tasks — three very different user relationships, all mediated by an agent sitting in the chat.

Milo: Which brings us to the last cluster, and it's the most human one: wellness and media. Stella is an emotional wellness AI — voice on iOS or text over iMessage. $9.99 a month or $59.99 a year. And it explicitly says it is not therapy.

Mia: That disclaimer is doing important work, and it should be taken seriously, not brushed past. An emotional wellness companion that's always available, in your pocket, reachable by iMessage — the accessibility is the product. But "not therapy" means no clinical accountability, no licensed provider, no diagnostic framework.

Milo: The iMessage channel fits the pattern we just traced — meeting people where they already are. But that's also what makes the wellness case delicate. A tool that feels like a friend, available at 2 a.m., with no clinical oversight, is exactly the kind of product where the benefit and the risk live in the same place.

Mia: We can't say how well it works — that's a claim we have no evidence for. What we can say: the pricing is accessible, the channels are familiar, and the maker has drawn a line they're explicit about. Where products like this land — regulation, app store policies, user trust — is genuinely unresolved.

Milo: And the counterpoint in the same cluster: Kling 4.0. AI video generation with up to 10 keyframes, 15 references, 30-second clips, lip sync in over 10 languages, MCP and CLI support — plus a cheaper 720p tier called Flash.

Mia: Read those specs as controls, not features. Ten keyframes means you can direct the arc of a clip, not just prompt and hope. Fifteen references means you can anchor the look to specific images. Thirty seconds is long enough for a real scene.

Milo: And lip sync in ten-plus languages is a distribution feature masquerading as a generation feature — it means one clip can be localized. MCP and CLI support is the theme of the entire day showing up one more time: video generation becomes something agents can call.

Mia: And Flash, the cheaper 720p tier, is the same pricing logic as RunInfra and Exa Lite — a low-cost entry point so the volume use case is affordable. One tool cares for people, the other creates media at scale, and both reach users through channels they already use.

Milo: So let's pull the threads together, because the day does form an argument. Agents are getting infrastructure that improves itself — Harness², Composio's wallet, RunInfra's flat compute.

Mia: Underneath that, hardware and search being rethought for agent-scale work — Intel's memory-heavy D270, Exa's token-slimming search. Alongside that, an open physical platform in Asimov 1 and a social network built in public in 48 hours.

Milo: Then the grounded layer: local ownership via yggy, snyvi, and Tiny Little Office; the dev loop via Inflight, ESP-Mosaico, xtty, and Portlivo; shipping via Hoistbay, Jotform, and Mintlify's doc agent.

Mia: And at the edges, where it touches actual people: reception, bonds, and ToDo.is putting agents in the chat; Stella and Kling at the wellness and media frontiers.

Milo: What's still unknown across almost all of it? Whether the claims hold outside demos. Who governs the agent wallets and the self-evolving harnesses. Whether wellness AI finds a stable, trusted role. Those are the questions to carry into tomorrow.

Mia: That's the briefing. Thanks for listening — we'll be back with the next one.

Milo: Take care, everyone.