1026 | Agents at Work, Humans in Sync

Mia: Welcome back to the show — I'm Mia. Milo, today we're doing something a bit different. We went through a day's worth of product launches and the actual conversations happening around them, and we picked out a handful that we think are worth your time. Not a list of everything — the ones with a real problem behind them.

Milo: And I'm Milo. The throughline today, if there is one, is infrastructure and truth. A bunch of these launches are about building the layer that AI agents run on — a browser built from scratch for agents, a local server on Windows, a shared workspace for humans and machines. And then another whole cluster is about companies knowing what's actually true — what shipped, what revenue is real, what's actually in the data room, whether the site is actually down.

Mia: And then it gets smaller and more fun from there — a Telegram podcast bot, a lyric-video ad machine for musicians, and yes, an app that turns your iPhone into a name badge. But let's start with the agents, because that's where the day's most interesting engineering was.

Milo: So, first one: Moli, by a company called Lexmount. And the pitch is bold — it's a browser engine built completely from scratch, not a wrapper around Chrome, and it's designed specifically for AI agents rather than people.

Mia: Right, and the claims are specific. The makers say it cold-starts around five times faster than Chrome while using roughly a seventh of the memory, based on their own benchmarks. And they're upfront that it's their benchmarking, so treat it as a claim, not a verified result — but if it's even close, it matters, because if you've run agent workflows at scale, spinning up headless browsers is quietly one of the most expensive parts.

Mia: One of their own team made that point in the launch discussion: run thousands of headless Chromes and the resource costs just keep climbing.

Milo: How do you actually use it? There are two paths. One is local — Moli is open source, so you can run the engine yourself. The other is Lexmount's cloud platform, where they handle the infrastructure: isolated browser sessions, proxy support, that kind of thing. There's an SDK that works with Playwright, CDP, extensions, downloads, session replay. And pricing they quoted is 100 browser hours and 25 concurrent sessions for twelve dollars a month, plus a launch offer for Product Hunt users.

Mia: What I found genuinely interesting in the discussion was the security angle. One of their engineers, Donough Liu, wrote a long comment about how being lightweight and headless shouldn't come at the expense of browser security — same-origin restrictions, iframe sandboxing, CSP, CORS, subresource integrity, all of it. And his framing was good: those protections matter just as much when an agent is browsing as when a person is.

Mia: That's a real point, because agent browsers could easily become the thing that skips all the guardrails.

Milo: There's also something they call the Cloud Browser Agent, with a protocol they call CAE — content, action, effect. The idea is it connects what's on the page, what operations are available, and what the browser actually observed happening, with incremental updates so it can reuse stable page context. They claim that grounds decisions in browser feedback and reduces token overhead, and gives you an execution trace you can inspect. Again — their description, not independently verified.

Mia: Now, community comments — and I want to be careful here, there were a lot of "congrats on launch" messages, which tell us nothing. But there were substantive questions. One person asked how Moli handles dynamic web content. Someone else asked how the five-times-faster cold start was achieved.

Mia: And a really practical one: a user who said their agents drive a real browser all day, and the slow part is always waiting on pages and uploads, not the model — and they asked whether Moli keeps logged-in sessions between runs or starts from a clean profile every time.

Milo: That session question is the one I'd want answered before anything else, honestly. Persistent state is the difference between a demo and a workflow. Another person asked whether you can use it without setting up your own servers, and one commenter compared notes, saying they'd built something similar called the Dendrite SDK before their current product — so there are people in this space who recognize the problem.

Mia: Okay, staying in the agent infrastructure layer — next is Llama. And this one is notable because of who made it: the llama.cpp team together with Hugging Face. It's a Windows 11 app — a system tray app — that runs open-source language models locally.

Milo: The key design idea is that it's one shared server. You install models from Hugging Face in one click, you press Alt plus Space to chat with a local model from anywhere, and — this is the part I like — your other apps point at localhost on port 9931, at an OpenAI-compatible API. So a coding agent, an editor, a script, a chat app — they all talk to the same local server.

Mia: And the reason that matters is the model cache. Normally, if you have three apps that each bundle their own local model, you've got three copies of gigabytes on disk. Their own comparison on the site says it plainly: without Llama, three apps times a nineteen-gigabyte model is fifty-seven gigabytes. With Llama, the model lives once in the Hugging Face cache and everything shares it — nineteen gigabytes total.

Milo: It also handles the configuration problem, which is the part of local AI that keeps normal people away. The site says Llama checks your machine and picks settings — quantization, context size, whether image input is on — automatically, based on how llama.cpp actually works. It recommends models that fit your memory: Gemma for everyday stuff on sixteen gigs, an OpenAI reasoning model at twenty-four, a bigger Qwen for code and long documents at thirty-two.

Milo: And it claims nothing sits loaded when idle — models load on demand and unload after five minutes.

Mia: Community response here was pretty focused. One commenter said they loved that one shared server means every app reuses the same cache instead of each bundling its own twenty-gigabyte download. Another talked about privacy-first, no token limits, full control, good for sensitive data or offline work — that's attributed opinion, not something we've tested.

Mia: But the design logic is hard to argue with: it's basically "OpenAI has ChatGPT and an API; you get both, on your own machine, free and open source."

Milo: Free, open source, works offline, tiny download — the Mac version is apparently a one-megabyte download. And no cloud inference at all. That's a meaningful contrast with the previous story, actually — Moli is pushing agent browsing into the cloud as a managed service; Llama is pushing the model layer entirely onto your own machine. Different bets on where agent infrastructure should live.

Mia: Right, and there's a third piece of this layer: where agents and humans actually work together on the same files. That's AgentGrid.io, from a team called Anima. The co-founder Avishay described it as a shared drive where humans and AI agents collaborate on documents, websites, apps, and designs. His line: it feels like Google Drive for humans and Git for agents.

Milo: The mechanics: humans get Google-Docs-style multiplayer editing; agents get a Markdown and Git interface. So Claude, ChatGPT, Codex, Cursor, whatever agent you use — they connect through MCP, CLI, or APIs, and everyone works on the same live artifact instead of passing copies around. Their example scenario is a report that Claude drafts, ChatGPT improves, another agent generates visuals for, and a human edits manually — all on one document.

Mia: And the governance layer is what makes it more than a gimmick. Permissions are granular — read, write, modify, publish — set per agent, per folder. Every revision has history, every approval has an owner, agents authenticate as agents. You can give scoped, revocable permissions. So if you ask an agent to make a website, it doesn't just hand you a file in a chat that gets buried — it gets a persistent link and structured storage.

Milo: The community comment that stood out was someone saying this solves the "which AI version did we actually use?" problem, and that version history plus permissions are crucial for real teams — they specifically wanted to try it with Claude plus Cursor workflows. That's one person's take, but it names the actual pain: agents produce work, the work lands in chat threads, and nobody can tell what the current version is or who changed what.

Mia: And there's a fourth piece that ties directly to that — versioning, but for code. git-flow-next, version 2.1, from the team behind the Tower Git client. This is the successor to the original git-flow branching model from 2010, rebuilt from scratch in Go, fully compatible with existing setups, free and open source, and — they say — endorsed by Vincent Driessen, who created git-flow originally.

Milo: The 2.1 feature is worktrees, and the reason it's in an agents discussion is exactly what you'd guess. You can start a feature with a worktree flag so it lives in its own directory — no stashing and switching. And you can make worktrees the default, so that Claude Code, Codex, or any other agent that starts a feature gets its own directory and works in parallel without stepping on each other. When you finish a feature, the worktree gets cleaned up.

Mia: Their argument is that running several agents side by side is quickly becoming the norm, and worktrees are what make that safe. And honestly, that connects everything we've talked about so far. Moli gives agents a browser. Llama gives them a local model server. AgentGrid gives them a shared file workspace with permissions. git-flow-next gives them isolated directories in a repo. Everyone is building the plumbing so that agents don't collide — with each other or with us.

Milo: And there was even a supporting example from a different launch that shows how this governance question is showing up everywhere. Papermark — we'll get to them properly later — launched agent-run data rooms, and a commenter immediately asked: if someone asks the agent to give an outside advisor access to everything, does it go through, or does it wait for a human to approve? That is the open question of this whole layer right now. Who signs off on what an agent is allowed to do?

Mia: Exactly. So that's the infrastructure story: real engineering, real design debates, but a lot of claims from makers and a lot of unresolved questions — dynamic content handling, session persistence, permission approval. Nobody's claiming these are solved.

Milo: Okay, shift. Same theme — knowing what's true — but now for whole companies instead of agents. And the first one here might have been the most relatable launch of the day: Specsight.

Mia: The founder, Ola, tells the story well. At every startup she worked at, she was the engineer everyone came to with the same three questions: How does this work? What changed? Is this supposed to happen? The answer was always in the code, in a language most of the company couldn't read. She spent years being the translation layer and thought it was absurd.

Mia: And now, with everyone building fast with AI, products change every day and nobody can keep up — but you still need to understand the product you're selling and supporting.

Milo: What Specsight does: you connect GitHub or GitLab, pick a repository and branch, and it tracks the product straight from the source code. It shows what features exist, how they behave, how they connect, and what changed with each release — in plain product language. So it's not release notes about what's new; it's a living map of the entire product. They claim most projects get their first product map within an hour.

Mia: The site shows what that looks like in practice — a product changelog with concrete entries like files now upload in bulk, a size limit changed to twenty megabytes, a save-draft button removed, uploads stuck at ninety-nine percent fixed. There's a product map that follows user journeys — sign-up leads to upload leads to sharing, and so on. There's a product spec with actual scenarios, like selecting eleven files triggers a "maximum ten files" toast.

Mia: And a question-answer feature: ask "any new features this week?" and it answers, then offers to draft release notes.

Milo: The benefits they describe are for specific roles. Support knows what changed before customers ask. Sales demos the product as it is today, not last month. Product sees what actually got built, not just what was planned. Weekly digests arrive automatically. And the line they use: "let me check with engineering" becomes an answer in seconds.

Mia: Now the community evidence — and this is a good example of substantive demand. One commenter said half their support tickets start with "did something change?" and the answer is always "let me check with eng," so the support side is what got them. Then they asked a sharp question: does it pick up changes that only live in feature flags or config, or only what's in the repository?

Mia: That's a genuinely important limitation question — a lot of product behavior these days is toggled by flags, not code changes, and the source doesn't show us the answer.

Milo: There were also testimonials on the site from named people — a co-founder saying product people can't keep up with developers anymore, a CTO praising the product map for a big complex system, a product manager saying no company keeps docs up to date and Specsight gives the answer straight from the code. Those are attributed quotes, so weigh them accordingly.

Milo: Pricing is flat and per organization, not per seat — 150 euros a month, up to three projects and fifty members, with a seven-day free trial option. Per-org pricing is a deliberate choice so you can invite everyone.

Mia: From one source of truth to another, and this one's for finance people. MRRaudit. Built by the ChartMogul team — they've been working on SaaS metrics since 2014. The maker's own framing was great: there are only so many times you can think "we should really build a tool for this" before you have to build it. They built it for their own team to figure out why MRR numbers don't match, then realized there was no reason to keep it to themselves.

Milo: The problem is real and specific: your Stripe number and your ChartMogul number don't agree, and nobody knows why or which one to trust. The site's example shows Stripe at 51,100 and ChartMogul at 55,200 — a 4,100 gap. And the causes they walk through are genuinely instructive.

Mia: Yeah, let me run through a few, because this is where the product shows it understands the domain. Voided invoices: if you void an auto-generated invoice and replace it with a one-off invoice, Stripe still reports the MRR, but ChartMogul sees no recurring invoice and reports zero for that customer.

Mia: Past-due customers: someone can keep counting toward MRR months after they stop paying, if the subscription was never cancelled — their example shows a customer contributing 500 a month with the last successful payment in February. Refunds: whether a refund lowers MRR depends entirely on a setting — refunds ignored versus applied give you 1,200 versus 1,100 on the same transactions.

Milo: And then discounts — MRR should arguably be net of discounts so it matches cash collected, but a ten percent gap across many customers adds up. Usage revenue: Stripe classifies metered usage as non-recurring, ChartMogul can include it in MRR — and the product's point is that neither is wrong; it depends on how your business treats usage. Which leads to the feature: MRRaudit lets you choose the rules.

Mia: The core view is a customer-by-customer diff between Stripe and ChartMogul, where every difference is grouped by cause, explained in plain language, and linked back to the actual invoices and subscription events. Every row traces to the customer behind it. And it's read-only access, works even if you don't have a ChartMogul account — you can audit Stripe data alone.

Milo: The community comments were unusually good here too. One person said the customer-by-customer diff is the view everyone ends up rebuilding in a spreadsheet at month end — that's someone naming their own workflow, which is strong signal. And they asked a specific question: how do you treat a failed payment that gets recovered a few days later? Does that customer drop out of MRR in between, and can I choose that rule myself?

Milo: The product page does say you can choose how billing events affect MRR, but the specifics of recovered payments weren't spelled out.

Mia: Another commenter, a small team on Stripe, described their own trap: renewal invoices sit as drafts for about an hour before the charge, and it's easy to read those as failed payments. They asked whether MRRaudit shows drafts separately. Again — good question, no answer in what we have. But the product positioning claims the ChartMogul team investigated these differences by hand through thousands of calls and support tickets, and this tool is that investigation, automated.

Milo: Okay, third in this cluster — Papermark Data Rooms 2.0. Co-founders Iuliia and Marc, three years in, claiming 80,000-plus users across founders, M&A advisors, VCs, LPs, and sales teams. The recurring problems they heard: setting up a data room takes days or weeks, you never know who actually read your deck, the room carries the vendor's logo instead of yours, and your AI agents can't touch any of it.

Mia: Data Rooms 2.0 answers each: live in under sixty seconds, page-by-page analytics and a full audit log so you know who read what, fully white-labeled — your brand, your logo, your domain — and an API, CLI, and MCP server so agents like Claude, Cursor, or ChatGPT can set up a room when you ask. Iuliia's favorite part is the agents: ask for "a buy-side M&A room for Project Atlas" and you get the folders, permissions, and share link back.

Milo: On the security and compliance side, the site lists SOC 2 Type II, ISO 27001, GDPR, CCPA, HIPAA compliance, AES-256 encryption, self-hostable, data centers in the EU, US, and UAE. Granular permissions with viewer groups, dynamic watermarking, NDA-before-viewing, screenshot protection, built-in Q&A. This is a mature, certified category and they're competing on speed, transparency, and customization against vendors that start with a sales call and put their own logo on your deal.

Mia: And the community — again, a mix of congratulations noise and real substance. A user who's run a raise with it said they'd recommend it to anyone looking for a comprehensive, flexible data room — that's attributed experience, take it as one person's endorsement.

Mia: And the permission question I mentioned earlier came from this thread: someone loved the Claude demo but immediately asked who's allowed to change permissions through the agent — if someone asks it to give an outside advisor access to everything, does it go through or wait for a human? That's the same governance question from the agent infrastructure section, showing up in a compliance-heavy domain.

Milo: Fourth in this cluster: Openstatus incident management. And their launch line might be the most honest sentence of the day: "Because status pages are a lie." A commenter riffed on it: the status page stays green while the Slack channel is on fire — and I think anyone who's been on-call recognizes that.

Mia: What they built is incident management for small teams, sitting next to the monitors and status page that Openstatus already had. You declare an incident from Slack with a slash command — title and severity — approve the card, and it exists. Every incident gets its own channel, named with the date and incident, severity and status in the topic, the incident card pinned on top.

Milo: The clever bits: any message in the channel can be pinned or added to the incident timeline, so the record writes itself as you work — every status change, note, and public update is timestamped as it happens, and the postmortem and audit trail are built from that, not from memory afterward. There are escalation reminders if an incident goes quiet: one hour for critical, four for major, a day for minor.

Milo: And because the monitors live in the same workspace, when a monitor goes down you can declare from its downtime row and the start time is already filled in — so duration counts from when impact began, not when someone got around to declaring.

Mia: Also important: internal and public stay separate. The team works with severities, notes, and a commander; customers read a status report in your words, and the two are linked but never mixed. A first status report is drafted automatically with affected components and start time, ready to publish in one click. Pricing: free to start, paid plans from thirty dollars a month, fourteen-day free trial of the starter tier.

Milo: Community reaction was warm — lots of launch friends and one happy existing customer hoping, quote, "we never have an incident to use your new feature though," which is the nicest possible way to say that. And one commenter asked the operational question: when someone declares from Slack, does the status page update by itself, or does someone still approve what customers see?

Milo: Based on the product description, the status report is drafted and you publish it — so a human stays in the loop on the public side — but that's my read of the description, worth verifying if it matters to you.

Mia: So that cluster is done — four tools, one idea: replace "ask engineering," "rebuild the spreadsheet," "weeks of setup and vendor branding," and "green page, burning channel" with a single source of truth that updates itself. And now, connecting naturally — these are all workplace tools. But the same "know what works" instinct shows up on the consumer side, in podcasting and music. Let's do Yourcast 2.0.

Milo: Yourcast is a Telegram bot for podcasts. You search a show, tap to subscribe, and new episodes arrive as audio right in your chat. The maker, Konstantin, describes the audience precisely: people who live in Telegram and don't want one more app just for podcasts. Fun bit of history: it placed tenth of the day on Product Hunt four years ago, then mostly ran on its own — and in the last seven weeks it changed more than in the five years before.

Milo: Eighty-five merged pull requests against fifty-five commits in those five prior years, written mostly with LLMs.

Mia: That's a striking data point about how AI changes small-team development — one person, and the codebase moved faster in seven weeks than in half a decade. What's actually new in 2.0: AI summaries that give the gist and key points with timestamps, and you tap a time and the audio jumps there. Then you can ask questions about any episode.

Milo: Also: tap a popular show to subscribe and the latest episode arrives immediately. Paste an Apple Podcasts link or migrate from another app with an OPML file. Feeds that repair themselves — a broken or moved feed gets rechecked daily and its new address found automatically. Episodes up to two gigabytes, downloads that resume. Pricing is in Telegram Stars: free tier is ten episodes a week on demand; a dollar tier with automatic delivery; a five-dollar tier with thirty hours of summaries a month.

Milo: It's open source under GPL v3, and available in six languages.

Mia: The community had one comment that shows exactly who this is for. Someone who's been going on podcasts as a guest said they listen to a few of the host's episodes before each appearance, and being able to ask questions about an episode would save real time — then they asked the natural follow-up: can I ask across several episodes at once, like "what does this host usually ask guests?" That cross-episode question isn't answered in the source, but it tells you where the feature wants to go.

Mia: And Konstantin himself asked good questions of the audience: is a summary enough to decide whether an episode is worth your hour?

Milo: Now music — and this one I think is the best product story of the day. Clips by Plastic. The maker, Kai Williams, is a musician with about thirty thousand monthly listeners, and he built it while promoting his own album. The problem: song ads work best when you test several parts of the song — but cutting the same song fifteen different ways in a video editor took a whole evening, so he'd make two and guess.

Mia: So Clips automates exactly that. You drop in a finished song and your own footage or photos. It finds the tempo and every part — verses, pre-chorus, chorus, bridge — and makes a vertical lyric video for each one, cut on the beat, with the lyrics synced word by word. You pick a layout and one of fifty-four effects, then export every part on every backdrop at once, files named and ready for Ads Manager. Run them all for a week and put your budget behind the part that wins.

Milo: And their worked example makes the point beautifully: after a week of running all parts, the chorus — the part everyone would have guessed — cost sixty-three cents per result, while Verse 2 won at twenty-one cents. Strangers pick the winner, not your guess. That's the whole thesis in one chart.

Mia: Practical details: it's a Mac app, runs offline, so an unreleased song never leaves your machine. Free to try with a small Clips tag on exports, then ninety-nine dollars once — no subscription, no credits, no caps. There's a label and studio license at 299 for client work and up to ten Macs, and a bundle with their audio recorder app for 125. It also does lip-sync — film yourself singing along, and Clips plays the take in sync in every clip.

Mia: And it finds your catchiest moments up to fifteen seconds that loop seamlessly on TikTok and Reels.

Milo: On the comparison page they're blunt about alternatives: a video editor is about a hundred eighty a year by hand, other tools run in the cloud with limits — one competitor caps at 100 to 500 posts a month, another limits to about thirty ads per song. Clips has none of those limits and keeps your footage local. Kai's positioning on CapCut is fair too: keep it for one-off edits; Clips is for the fifteen near-identical cuts nobody wants to do by hand.

Mia: And notice the connection to Yourcast — both are tiny teams using AI to kill tedious production steps: Konstantin automated episode summaries and feed repair; Kai automated the fifteen video cuts. And both, in different ways, are about testing what works instead of guessing — Kai literally A/B tests song parts with ad spend.

Milo: Which brings us to the last subject: studying virality itself. How It Spread. The pitch: it's the Mobbin for viral content — Mobbin being that library of app design screenshots. Here it's a library of over sixteen hundred — the site says 1,651 — case studies of films, products, memes, and campaigns, traced from the first post to the peak.

Mia: The makers said they wanted this for themselves — a Mobbin for viral content — and it's aimed at strategists and, notably, their agents. Each case has a timeline of dated, sourced events across platforms, plus metrics like reach, contagion, breadth, velocity, and longevity. Browsing is free; Pro is sixty percent off the first year with a code.

Milo: The example they showcase is a 2025 film called Obsession. The timeline: it premieres at 11:59 pm in TIFF's Midnight Madness section in September; Variety profiles the director that same day, noting his 800-dollar YouTube feature had passed two million views; two days later Deadline reports Focus Features in exclusive talks to buy it for upwards of fifteen million. Nineteen dated events, eight platforms, nine sourced numbers, twenty-three sources — for that one case.

Milo: Box office: 522 million on a budget somewhere between 750 thousand and a million.

Mia: Other cases on the front page give you the range: the Doggface Ocean Spray video at fifteen billion impressions, Dubai chocolate at 120 million TikTok views, Labubu at over two billion in revenue, KPop Demon Hunters at 4.6 billion impressions. So it spans memes to box office to retail products.

Milo: What's honest to say here: the library is real and richly sourced, the framing — virality as something you can study systematically, with metrics and timelines — is coherent, and the audience of strategists running agents makes sense given everything else we discussed today. But the open question is the one the plan of this episode can't answer and neither can the source: does a structured library of past virality actually help you predict or engineer the next one?

Milo: The product doesn't claim prediction outright, and I'd stay skeptical until someone demonstrates it.

Mia: And I'll close the loop on the small delight we promised: Badgey. An indie developer, Marco, turned the iPhone into a name badge. Clip it to a lanyard and turn it upside down, and the badge flips to face the people in front of you and swings a little as you walk.

Mia: Slide it top-first into a chest pocket and it shrinks to a strip so your name shows above the edge — the pocket check uses the front camera for a few seconds while the phone is upside down, a small on-device model decides, and the frames are never stored.

Milo: Multiple badges — work, a conference, a meetup — a link that becomes a QR code on the back, five designs including one that moves. Free with one badge, Pro is a one-time purchase. Community questions were practical: does the camera check run every time you flip the phone, how long does the battery last with the screen on through a whole conference day, and does it stop the phone from auto-locking. One person just wanted to see a video of it in a real setting, which — fair.

Milo: And one called it a good conversation starter for conferences, which is probably its truest use.

Mia: So let's land this. If today's launches share anything, it's turning scattered knowledge into something you can act on. Specsight turns code into product knowledge. MRRaudit turns two disagreeing revenue numbers into a decision. Papermark turns a week of data-room setup into a sentence you say to an agent. Openstatus turns a burning Slack channel into a timestamped record. Yourcast turns an hour of audio into two minutes with timestamps. Clips turns a guessing game into a test.

Mia: How It Spread turns viral chaos into sourced timelines.

Milo: And the agent-infrastructure layer underneath — Moli's browser, Llama's local server, AgentGrid's shared workspace, git-flow-next worktrees — is being built precisely so agents can do that work reliably. The unresolved questions are consistent too: session persistence, dynamic content, and above all, who approves what an agent is allowed to do. Nobody launching today has fully answered that. Whoever does first will probably be the next story on a day like this one.

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