0910 | Agents Everywhere: From Duck Sumo to the Human Genome

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

Milo: And I'm Milo. Today's episode is basically a snapshot of one very strange, very busy day in software. Almost everything we're going to talk about involves AI agents in some form — agents writing code, agents getting watched by a security layer, agents needing infrastructure, agents talking to your bank, and, at the very end, an AI map of every possible human DNA mutation. There's a throughline here about autonomy: what happens when software acts on its own, and how we keep track of it.

Mia: Right, and we're not just going to list things. We want to dig into a few of these properly — who they're for, what they actually claim, what the community pushed back on — and then move through the rest at a reasonable pace. So let's start with the question a lot of developers are quietly asking themselves right now: how many AI agents can one person actually be in charge of at once?

Milo: Two products tackled that from different angles today. The first is called 49Agents IDE. The maker describes running up to fifteen Claude or Codex command-line sessions at the same time, across multiple repos, and hitting what he calls context fatigue — forgetting which terminal is doing what. His fix is spatial. Instead of a grid of tabs, you get a 2D canvas, a kind of city-builder layout where every agent, terminal, repo, and machine lives as an object you place yourself.

Mia: And the pitch for why that works is interesting. He says our brains remember information in relation to things around it — where a pane sits relative to its neighbors is itself the memory of what that process is for. So when you come back days later, you're not reading tab titles, you're remembering a location.

Milo: One commenter on the launch nailed this better than I could. He said his old loop was: Claude writes code, command-tab, open lazygit, inspect, command-tab, tell Claude it hallucinated an API, repeat. And he wrote, "I have apparently been context switching recreationally." With the canvas, you can put the git diff literally adjacent to the agent and leave it there.

Mia: It's open source, it's free for individuals and small teams under a BSL license, it connects to machines you own so you can open terminals on your home PC, an AWS box, or a laptop — with little CPU and RAM readouts — and you can put it all on a private network and reach it from your phone. There's also a hosted version if you don't want to self-host.

Milo: Now, the obvious objection, which came up in the comments: every spatial tool people have used falls over somewhere around thirty objects. One commenter's suggestion was decay rather than zoom — things you haven't touched in a week shrink on their own so the map stays legible without gardening. And another asked directly whether panning and zooming around a big map to find the one stuck agent is just moving the fatigue rather than removing it.

Milo: Has the maker tested this at fifteen-plus concurrent agents, or is the sweet spot five or six?

Mia: Worth saying the maker did run it himself at fifteen CLIs, but that's his claim, his workflow. There were also practical asks — like turning off all the machine telemetry, with one commenter joking his terminal manager doesn't need to cosplay as Grafana — and questions about whether agents idle versus working are visually distinguishable when you're zoomed out. The site does mention panes glow blue while Claude works and pulse vermillion when it needs permission.

Mia: And they're experimenting with coworking on a shared workspace and looking for testers.

Milo: So 49Agents is about supervising many agents from one chair. The second product in this pair asks a bolder question: what if you barely supervise them at all? That's Mastra Factory. Mastra is a YC-backed company that started as a TypeScript framework for building AI agents, and Factory is their open-source, agent-powered software delivery environment.

Milo: The idea is a full pipeline — intake, triage, planning, building, review, done — with persistent coding agents and repository workspaces, running in a web application you control.

Mia: You connect GitHub, optionally Linear and Slack, and you define the rules for how work moves between phases. Agents triage issues, write and validate code, release changes, update docs, monitor production. You tag the factory in Slack for one-off tasks. And there's a board view showing issues moving through columns like any kanban, except the workers are agents.

Milo: The evidence here is real but it's maker-reported, so treat it as claims. They say Factory already writes more than a quarter of Mastra's own pull requests — the numbers quoted ranged from 25 to 30 percent, and one person said it closes 60 percent of their issues. There's also a nice dogfooding loop: they built Factory with Mastra, and now they use Factory to build Mastra.

Mia: Pricing is worth knowing. There's a free starter tier with 100,000 observability events and 24 CPU hours, a Teams plan at 250 a month with a million events and 250 CPU hours, SSO and SOC 2 docs, and custom enterprise pricing. The platform handles auth, database, and sandboxes; the server, UI, and Studio all run locally until you deploy.

Milo: One early user made a comparison I found useful. He'd spent a year trying factory-like tools and found they split into two camps: easy to use but hard to shape to your process — which makes them glorified bug fixers — or powerful but painful to set up, which kills adoption. His claim is Factory hits the middle. Again, that's one person's experience, but it's a specific one.

Mia: And community questions cut at the hard parts. How does memory behave when one agent serves many users? Does context get trimmed or stored indefinitely? Can you drive it entirely from Slack? The FAQ suggests the design uses explicit gates at each stage — so changes stay measurable and reversible — with an optional goal mode using subagents and durable background agents. That gating philosophy actually connects straight to our next topic.

Milo: Yes. Because here's the thing both of those products push toward: agents acting without a human watching every step. Which raises the question — what stops the agent from doing something catastrophic while you're getting coffee? That's Harden, and their product is called AIF, the Agentic Integrity Foundation.

Mia: The founder's framing is very relatable. He says the best days with coding agents are when you hand off something real and walk away, and the worst days are when you sit there approving every command like a nervous parent. And babysitting caps how much work you can delegate. So AIF checks every agent action before it runs — commands, file edits, tool calls, outbound requests — using your request and session context.

Milo: The technical claim: a post-trained 8-billion-parameter model that runs locally, so your repo and tool output never leave your machine, and that beats frontier models on agent-security benchmarks. It pauses, rewrites, or blocks the one dangerous action while the agent keeps going with everything else — which matters, because a security layer that constantly interrupts the workflow is its own problem.

Milo: It works with Claude Code, Cursor, Codex, Hermes, OpenClaw, Kiro, and Antigravity, and it's free for individual developers.

Mia: My favorite anecdote from the discussion, and this is the team's own story so take it as their account: an agent was debugging a Stripe issue, reading logs, editing code, running tests. An earlier edit accidentally left customer email addresses in a file, and the agent later tried to upload that file to Datadog. AIF connected the upload to the earlier edits, stopped the transfer, and told the agent what to fix. That's exactly the failure mode nobody catches when they're not watching.

Milo: Now the unknowns. Community commenters asked how much latency the local model adds per tool call in long sessions — no answer captured in what we have. They asked whether it inspects script contents below the tool-invocation level. They asked whether it sees the whole session or just the current request when making a decision. And the sharpest one: how does it handle actions that aren't obviously dangerous but are still outside the intent of the original task?

Milo: Everyone can catch rm dash rf in the wrong directory. The gray zone is where this gets hard.

Mia: Someone in the comments said AIF had already blocked 49 risky tool calls for them — that's an attributed user experience, not a benchmark. And one person mentioned the Hugging Face attack as a reason to take agent security seriously, asking about MCP connectors. So the category has clearly arrived.

Mia: Which leads naturally into the plumbing underneath all of this — because whether it's a security layer, a router, or a guide-drawing assistant, the pattern is the same: agents need governed, mediated access to real products.

Milo: Three products today fit that frame. First, GoModel. It's an open-source AI gateway written in Go — think an OpenRouter or LiteLLM alternative you self-host. One OpenAI-compatible API in front of 31 providers: OpenAI, Anthropic, Gemini, Bedrock, Vertex, Azure, Groq, Ollama, vLLM and more. Plus budgets, caching, guardrails, load balancing, failover, and rate limits.

Mia: The origin story is a solo founder in Warsaw, Jakub, first Product Hunt launch. Last October he wanted an AI gateway for his startup, found that LiteLLM — the pioneer in this space — had, in his words, serious quality problems with 500-plus unexplainable production issues, and concluded Python is the wrong tool for proxy-like software. So he wrote one in Go and has been full-time on it since December.

Mia: Those are his characterizations, but the architectural argument is real: proxies want tiny footprints and reliability, and a single binary with a 20-megabyte Docker image is a much easier sell to a security-conscious team than routing your API keys through someone else's infra.

Milo: The feature set is genuinely detailed. Virtual models you publish under stable names like "smart-chat" and remap behind the scenes. Exact-match response caching so identical prompts don't pay twice — the site shows a cache miss at 1.9 seconds and 42 cents versus a hit at 38 milliseconds and zero. Per-request usage tracking mapped to teams, tenants, and features. Audit logs for every fallback. Virtual API keys you hand to teams instead of raw provider credentials, revocable from an admin UI.

Milo: Storage goes SQLite to Postgres to Mongo. It's MIT licensed, installable in ten seconds with a curl command.

Mia: The questions from the community were smart and technical. Someone running OpenRouter as a primary asked whether self-hosting lets you pin a fallback order per model, since two of their models have no direct key and the router is a single point of failure. Another asked the genuinely hard question: when a provider is degraded but not down — elevated latency rather than hard errors — does failover wait for a timeout or react to error rates?

Mia: The docs describe availability-error failover, retries with backoff, and circuit breakers, but the degraded-but-slow case is the open one.

Milo: Second in this layer: Frigade Assist API. The problem they're attacking is that in-app AI agents answer "how do I do this?" with a wall of text, because they can't see the screen. Frigade's answer is one tool call your existing agent makes. Frigade draws a step-by-step guide directly on the page — highlighting where to click. And it tells the agent what the user is currently looking at, so "what does this error mean?" actually has a "this."

Mia: The part their CTO, Christian, is proudest of is how it knows the product: you give it a test account, a browser-based agent logs in and builds its own map of how the app works, and that re-runs on a schedule. So when you move a button or ship a feature, the knowledge refreshes. It works with the Vercel AI SDK or anything that can call a tool.

Milo: The community immediately went for the jugular on staleness, and it's a great critique. One commenter wrote: a stale text answer you can usually tell is stale, but a stale pointer confidently highlights the wrong button and the user does what they were told. He asked whether the target is derived live from the DOM every time — a completely different product from a stored selector — and said anyone who's built this internally asks that within ten seconds. Fair.

Milo: Other reasonable questions: who decides when to draw a guide versus hand back plain text, and what about things a test account can't see, like feature flags or higher plan tiers?

Mia: Third: Noodle Seed. This one is about making your software agent-ready from the outside in. The cofounder Fahd noticed he no longer buys software without an MCP connector for Claude or Codex — he considers it a table stake now. So the pitch: define workflows in TypeScript, expose them through a secure, branded assistant inside your product, and make the same capabilities available to external agents like ChatGPT and Claude.

Mia: The runtime handles identity, permissions, secrets, credential brokering, OAuth, rate limits, audit, and observability, so one useful workflow doesn't turn into an infrastructure project.

Milo: What I like about it is the bidirectionality. Most teams treat "bring my product into AI agents" and "bring an AI agent into my product" as two separate projects. Noodle Seed says they're the same building blocks. Their examples: a restaurant taking orders conversationally on its website, a travel agency accepting bookings inside ChatGPT, B2B software transactable inside an employee's Claude.

Milo: And the flow is governed: customers can make useful progress before signup, carry the draft through your existing sign-in, and finish through your authorized API, with your product as the system of record.

Mia: Community pushback asked about control over brand voice and guardrails, whether complex booking flows actually work conversationally, how a branded app gets surfaced organically in ChatGPT's app ecosystem today, and whether anyone's measuring whether AI conversations drive qualified leads. All open. But the direction is clear — and it connects to the consumer side, because if agents are going to act for regular people, the same questions about permissions and surfaces apply to daily life.

Milo: Which brings us to Meta. Muse is Meta's personal AI agent. Give it a goal or an everyday task — finances, health, shopping, the people you care about — and it handles the rest. It ships its own messaging experience, with WhatsApp as the currently supported external messaging integration. One commenter framed it as Meta's swipe at ChatGPT and at Poke, and noted Alex Cornell surfacing on it given his earlier work on Cocoon.

Mia: The question everyone should be asking came from a commenter who put it perfectly: finances and health are the two categories where you want the most guardrails, not the least. What does the approval flow actually look like when Muse wants to move money or book something on your behalf? Is every action confirmed individually, or does it get standing permission after the first few tasks?

Mia: That's the same standing-permission question we just asked about factory agents, now applied to your bank account. No answer in what we have.

Milo: Also worth noting: a lot of people in the discussion are waiting for EU availability. Multiple comments asking when it's coming to Europe. So the product is live, but the map of where is still patchy. And the skeptical take appeared too: how is this different from hooking your Claude or ChatGPT account up to a bunch of existing services? That's the differentiation question Meta hasn't publicly answered here.

Mia: Sticking with consumer-facing AI: OpenAI shipped ChatGPT Images 2.5. The claims: sharper details, faster generation — up to 50 percent lower latency than Images 2.0 — better subject preservation, and more reliable multi-turn editing. New stuff includes sketch-to-image, templates for posters, flyers, merch, and product photos, comments directly on images for focused edits, and sharing prompts alongside images.

Mia: Available to ChatGPT, ChatGPT Work, and Codex users, plus API models aimed at creative, marketing, retail, and media workflows.

Milo: One marketing person in the comments said their team already uses the previous model heavily and 2.5 will be a welcome upgrade. Beyond that, there isn't deep independent evidence yet — these are launch-day claims, and the benchmarks behind "50 percent lower latency" aren't something we can verify from here. But the multi-turn editing reliability point matters for real workflows, because anyone who's tried to iterate on an image across five edits knows how fast consistency falls apart.

Mia: Okay, let's shift gears. The next three products are about trust and verification in different flavors — and one of them, I promise, is a wrestling league for robot ducks.

Milo: I was wondering when we'd get to the ducks. But first, hiring. WorkID.ai starts from a real problem: hiring runs on self-claims. A CV says whatever someone types into it. And in the last two years, AI made it free to apply everywhere — and free to be whoever you like on paper. The founder, Thor, has 25-plus years in tech hiring, and his framing is that recruiters now open pipelines of 300 applications, most generated, some from people who don't exist.

Mia: He cites a Gartner expectation that one in four candidate profiles will be fake by 2028 — that's a cited prediction, not a measured fact. But his deeper point is about collateral damage: when a recruiter can't tell who's real, they stop reading carefully and filter brutally, and honest candidates disappear into the pile without even a rejection.

Mia: So WorkID lets you verify your identity and work experience, and companies see a checked profile with a Trust Score out of 100 they can search and filter by. You prove things once instead of starting from zero in every process. Free to start, live globally.

Milo: The obvious question, asked twice in the community, is the right one: how do you actually verify employment? And a second commenter pushed harder — if the Trust Score is built on self-reported resume data plus some cross-checking, that's not solving the trust problem, it's adding a confidence label on top of the same self-claims. The site shows an example profile with each position marked "Verified," but the verification mechanism itself isn't spelled out in what we have.

Milo: Thor also posed a genuinely interesting question to recruiters: would a verified profile ever be enough to skip the first screening call? He admitted he isn't sure where that line sits.

Mia: Now AdScope, which is about trust in a different domain — knowing where your ad money goes. The founder Oren spent fifteen years managing ad campaigns and saw a disconnect: agencies spend hours building manual reports while business owners just want to know where their money is going without deciphering spreadsheets.

Mia: AdScope pulls Meta and Google Ads into one dashboard, and the key design choice is showing every live Meta creative — the actual image or video — right next to its own spend and cost per result. So you recognize the winner instead of decoding a row called "final-3-copy."

Milo: It's read-only, so it can never edit or pause a campaign. No pixel, no code, two logins. It's phone-first — the pitch is you check yesterday's cost at 7 a.m. before opening the laptop. Onboarding asks your business type, e-commerce or lead generation, and the dashboard adapts. Leads are traceable back to the exact ad that captured them. Pricing: a 10-day trial, then $9.99 a month locked for 12 months as launch pricing, down from a listed $39.99. One user per workspace.

Milo: No card until your dashboard is built.

Mia: Caveats worth knowing: agency features — client workspaces, white-label reports — are still in design, and they're recruiting agencies running five-plus client accounts as design partners. TikTok is coming but not live. And one commenter asked the differentiation question head-on: bigger platforms already show creatives next to metrics, so what's the actual moat versus a cleaner UI over the same Meta and Google data? Oren's answer isn't captured here, so that stays open.

Mia: There was also a sharp piece of community critique about onboarding: the homepage says no card until your dashboard is built, but after "fetching account structures," the next screen was plan selection — one commenter wanted a quick receipt of connected accounts and one real campaign before choosing a trial. Small, but it's the gap between promise and proof.

Milo: And now the ducks. DuckFightClub. Imagine WWE SmackDown, but the wrestlers are 25-centimeter open-source bipedal robots — Pollen's MicroDuck, which Hugging Face and Pollen Robotics unveiled, and which per the discussion pre-sold more than 10,000 units within days. You don't build the robot. You train its brain: eight teams spend days training reinforcement-learning policies in the simulator, then the ducks fight sumo, best of three, last duck standing in the ring.

Milo: The prize is the Golden Beak Belt. The first event, called QuackDown, streams live on YouTube on October 2nd, 2026.

Mia: The context that makes this smart: instead of being a Kickstarter where you pay and hope, the team shipped a simulator and full training environment before the robots ship, so people are already teaching their virtual ducks to break dance or move like a swan. One person's sumo simulation caught the launcher's eye, and that became this. There's a full bracket — teams like Pollen Wildcard, Hugging Face Pond Ops, MIT WaddleWorks, CMU Servo Squad — no byes, quarterfinals through a final.

Mia: There's a schedule: registration opened September 9th, teams announced the 16th, policy freeze the 23rd, bracket reveal the 26th, and a Stanford versus Berkeley side-card on the 30th they're calling the Battle of the Nerds.

Milo: And the community loved it. One called turning an RL leaderboard into a spectator sport a genuinely good idea, and asked whether policies carry over across seasons or start from scratch. Another pointed out the comedy of livestreaming a competition whose first rule is don't quack about it — clearly a Fight Club reference — with several people noting this breaks the first rule.

Milo: There are even physical chapters planned: Paris confirmed for December, Barcelona coming, and a format anyone can host in their own city. Sponsors can buy placements in the virtual arena — mat center from $2,000, apron boards from $500, the back-wall marquee from $15,000.

Mia: What I'd say this proves, cautiously, is that reinforcement learning has a marketing problem and DuckFightClub is a possible answer. It makes the skill visible. It's the same instinct as Mastra's shared factory board — making AI work watchable instead of hidden.

Milo: Which actually segues us into the last group, because the frontier items today are all about scale and persistence. Let's start with the biggest one: AlphaGenome Atlas from Google DeepMind. This is a precomputed, 1-petabyte dataset of predictions for how every possible single-letter DNA change — all 9 billion of them — might affect human biology. That's every possible single-nucleotide variant, across both coding and non-coding regions.

Milo: Free to explore through a visual web interface, with API and Antigravity access for deeper research.

Mia: The comparison people keep reaching for is the AlphaFold moment, but for genetic variation instead of protein structure. And there's something genuinely notable about the interface layer: you don't need to be a programmer. One commenter who describes themselves as "a mere pleb" with no biology background was marveling that they can access a dataset of this scale.

Mia: DeepMind's Pushmeet Kohli and Žiga Avsec announced it, describing it as the most comprehensive catalogue of how mutations affect molecular biology.

Milo: But here's the criticism that stuck with me, from one commenter: everyone's reacting to the 9 billion, and that number is closer to the problem than the achievement. Precomputing every possible single-letter change means almost all of it is noise by construction — deciding which variants are worth looking at was already the hard part, and a petabyte of predictions doesn't by itself decide it.

Milo: Other open questions from the community: how accurate are the predictions across different mutation types, can researchers compare multiple mutations side by side, can predictions show effects on gene regulation, and how fast can you actually explore a dataset this size? One more asked whether the output is legible to non-specialists or strictly for people who already know how to read a variant effect score.

Milo: Those are the questions that will determine whether this is a landmark or a very large bookmark.

Mia: From the genome to something much lighter: Diiverge. You take any picture — a photo, a painting, a screenshot — and it becomes a point-and-click adventure. Glowing dots mark what you can click; you choose what happens; AI generates the next scene and a short film of the moment in between. The clever part is persistence: every path anyone takes is saved, so each world grows as visitors explore it, and a map shows every branch.

Milo: The maker, Charlie, runs it as a series of volumes — The Crystal Pass has 2,831 scenes after five days, The Lantern Cove has 3,033. Playing is free; generating new scenes costs real money, so each volume has a fixed budget of free scenes and stops growing when they're used up, with sponsorships adding more for everyone. In the studio, you can turn your own picture into an adventure with paid scene packs and share it privately until you're ready.

Mia: Two good community notes: one person suggested a cheap mechanism the data already supports — show how many branches nobody has opened yet, because an unexplored count is a stronger reason to click than "play." And another asked the continuity question: does a playthrough remember earlier choices, or does each scene generate independently?

Mia: The site's FAQ says a judge model reads the story so far and cuts choices that break continuity — so there is a continuity mechanism, though how well it holds over long branches is exactly what you'd want to test.

Milo: And our closer: Type.com. The thesis from cofounder Fletcher — whose previous company Halp was acquired by Atlassian, with Slack as an investor and OpenAI as a customer — is that the teams winning with AI aren't the ones with the most agents, but the ones whose best AI work is visible across the whole team. That's how work compounds.

Milo: Type is a cloud, multiplayer workspace where you share sessions, integrations, skills, automations, and even apps you build together, on what they call a company brain that gets smarter as you work.

Mia: A reviewer in the comments said that framing is right because most team AI tools reset context every session. Someone else loved working as a team on marketing with a consistent voice and brand. The genuinely hard question asked: how does it handle conflicting edits when two people build on the same thread or skill at once? That's the multiplayer-meets-state problem, and it's unresolved here.

Milo: So let me try to pull the thread through the whole episode. Today we saw the same arc at six different altitudes. Agents multiply, and we invent spatial maps to keep track of them. Agents act, and we invent local security models to check them. Agents need access, and we invent gateways, guide-drawers, and governed runtimes to mediate it. Agents reach consumers, and we immediately ask who approves the money moves.

Milo: And at the far end, an AI system precomputes the entire space of possible human mutations — and the critique is the same one we heard about agent canvases and duck arenas: the map is not the same as knowing what matters on it.

Mia: That's a good place to land. If you take one thing from today: every one of these products is really selling supervision — of agents, of ad spend, of hiring pipelines, of ten billion DNA letters. The unsolved question in all of them is the same one Thor asked recruiters and Pushpak's users asked Harden: how much do you trust the system when you stop watching?

Milo: We'll be back with the next day's launches. Thanks for listening — Mia.

Mia: And Milo. See you next time.