0912 | Agents Everywhere: The Week AI Got a Desk Job

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

Milo: And I'm Milo. Today we've got a whole stack of launches to dig into, and honestly the thing that connects most of them is that AI agents are everywhere now — agents that write code, agents you talk to, agents that need data fed to them — and around them, a whole layer of tools is growing up to steer them, review them, and keep them honest.

Mia: Yeah, and then in the second half we'll get into the non-AI stuff too, because there were some genuinely nice free browser tools this cycle. But let's start where the action is: parallel AI agents, and the tools people are building to run them.

Milo: So the headline here is Cline Desktop. Cline is open-source, it's got eleven million users, and the new desktop app is built for open-weight models — so models you can run or swap in yourself rather than being locked to one provider's closed model. And the two big features are parallel agent sessions — you can run multiple agents at the same time instead of one at a time — and task import from Claude Code and Codex.

Mia: That task import bit is interesting, because it signals something. It's saying: we assume you're already using other coding agents, and we want to be the place where that work lives. It's not trying to pretend the competition doesn't exist.

Milo: Right, it's meeting people where they actually are. Most developers working with agents right now aren't married to one tool — they've got Claude Code for some things, Codex for others. Cline saying "bring your tasks here" is a bet that the orchestrator, the place where sessions get managed, is where the value is — not the individual agent.

Mia: And then there's Jackalope, which takes that idea even further. It's an open-source desktop workspace where you can run Codex, Claude Code, Grok, and OpenCode — all of them — in parallel, each in its own Git worktree, with a review step built in.

Milo: Git worktrees is the detail worth pausing on. If you've got four agents all editing the same repo at once, they'd step on each other constantly. Worktrees give each agent its own checkout, its own sandbox of the code, so their changes stay separate until a human looks at them.

Mia: And the review part matters just as much. Because when agents write the code, the human's job shifts from writing to reviewing. Jackalope is built around that reality — you're the person at the end of the pipeline deciding what gets merged.

Milo: So you've got Cline on one side — one agent framework, parallel sessions, open-weight models — and Jackalope on the other — multiple different agents side by side, each isolated. They're different answers to the same question: how do I run more than one agent without chaos?

Mia: And there's a third piece: Cadenya. This one's a hosted agentic loop. So instead of you managing the sessions on your desktop, Cadenya runs the loop for you — it handles compaction, which is the context management problem where long-running agents fill up their window and you have to compress what they know. It handles approvals, webhooks, and widgets.

Milo: So approvals means the agent asks a human before doing something consequential. Webhooks mean it can react to events from outside. Widgets presumably means you can surface the agent's state somewhere. And it's model-agnostic — it works through OpenRouter or any OpenAI-compatible endpoint, so again, you're not locked to one model.

Mia: So across all three — Cline, Jackalope, Cadenya — the pattern is the same. Nobody is building a better single agent this cycle. They're building the scaffolding around agents: parallelism, isolation, review, approvals, context management.

Milo: Which is why it matters. It suggests developers are standardizing on a workflow, not a product. Parallel, reviewable agent runs are becoming the assumed way of working, and the open question is which layer actually wins. Do you want the desktop app that imports from everyone, the workspace that hosts everyone, or the hosted loop that abstracts everyone away? That's genuinely unresolved.

Mia: And those agents, once they're running in parallel, leave stuff behind. Mountains of it. Conversations, decisions, specs. Which brings us to what happens after the agents run — how humans actually review the work.

Milo: So the most provocative idea here is easyspecs.ai. It documents your codebase and turns what it finds into trusted specs — with oracles and rubrics attached. The pitch is that spec review replaces code review.

Mia: Let's unpack that, because it's a real inversion. Code review means a human reads the diff the agent produced and tries to judge whether it's correct. Spec review flips it: before anyone writes code, you agree on a specification — here's what the feature must do — and the spec comes with oracles, meaning testable criteria that tell you if the behavior is right, and rubrics, meaning graded standards for quality.

Milo: And the argument for it is scale. If you have four agents working in parallel, reading four diffs by hand doesn't scale. But reading four specs — especially specs that were generated from your actual codebase, so they're grounded in reality — that might. You're checking intent instead of implementation.

Mia: The honest caveat is that it's unproven whether this scales. A spec can be correct and the implementation still wrong in ways the oracle didn't anticipate. Oracles are only as good as the person who defined what "correct" means. So it's a promising direction, but it's a claim, not a settled result.

Milo: And there's a complementary tool on the history side: chat-recall. It builds one searchable history across all your agent chats — Claude Code, Codex, Cursor, OpenCode — and it scans that history for leaked keys. And it's free and runs locally.

Mia: That leaked-key scan is quietly important. If you're pasting secrets into agent prompts, or an agent encounters credentials in your codebase and logs them, those are now sitting in chat histories scattered across four different tools. chat-recall consolidates the history locally and checks it. That's a real security answer to a problem parallel agents make worse.

Milo: And it doubles as institutional memory. If you ran a task in Codex last week and want to know what the agent actually did and why, you search one place instead of four. So easyspecs handles the forward-looking review — the spec — and chat-recall handles the backward-looking record.

Mia: There's a support piece that fits here too: Anysite.io. It's a B2B data layer for AI agents, accessed through MCP or REST, with over 650 sources and more than 3,500 endpoints. And notably, it outputs compact, context-friendly data.

Milo: The compact part is the telling detail. Agent context windows are expensive and finite, so a data layer that returns dense, relevant output instead of bloated API responses is designing for agents specifically. It's infrastructure for the same ecosystem — agents that need real-world data to work with.

Mia: So the picture after two topics: agents run in parallel, work gets reviewed at the spec level, history gets searched locally, and data comes in through dedicated layers. The plumbing is maturing faster than any individual agent.

Milo: Which brings us to the control surface. Because another way this is shaking out: you don't always type at agents anymore. You talk to them.

Mia: The big one here is Devin Voice, from Cognition. The idea is you speak a task out loud, and Devin plans it, schedules it, and delivers it. Under the hood it's using GPT-Live for the voice layer and Cognition's new SWE-2 model for the actual software engineering work.

Milo: Worth noting the source here is Spanish-language — the writeup describes it as "habla una tarea" — speak a task. So the flow is conversational: instead of composing a careful prompt, you just describe what you want, and the agent handles the planning and scheduling.

Mia: And what makes that more than a gimmick, if it works, is that voice lowers the friction of delegating. Typing a detailed task spec is work. Saying it, the way you'd brief a colleague, is not. If the comprehension is good, voice becomes the natural interface for delegating to agents.

Milo: Then there's Loqua, which takes a different, more research-grounded approach. It's built by speech researchers, and it has its own omni model — meaning a model that handles voice and vision together — so it shares context between what you're saying and what's on your screen.

Mia: That's the key differentiator. Most voice assistants only hear you. Loqua's model sees what you see, so you can say "what about this?" and it knows what this is. On top of that it does dictation, it has a Capture to Ask feature — grab something and ask about it — and it can take actions in apps.

Milo: So Devin Voice is voice as a way to delegate tasks to an autonomous agent. Loqua is voice as a general assistant that shares your visual context. Different bets on what voice-first means.

Mia: And the third piece here is Accordio, which is less about voice and more about giving an assistant hands. It's a free MCP connector that gives Claude thirty admin tools — time tracking, contracts, invoices, payments. And the paid part, at 39 dollars a month, is the drafting layer.

Milo: So picture it: you're talking to Claude, and now Claude can actually log your hours, generate an invoice, handle a contract. The MCP connector is free; the drafting — actually producing the documents — is where they charge. It's a freemium wedge into the "AI as back office" idea.

Mia: The open question for all three of these is the same: accuracy in real workloads. Voice demos are easy. Voice that correctly captures a complex task, or an omni model that correctly reads your screen context, or an agent that correctly drafts your invoice — those are the things we don't have evidence for yet. These are claims from the makers, and the gap between demo and daily driver is where most of these live or die.

Milo: Okay, deep breath. Let's pivot to something completely different, and honestly refreshing — free browser tools with no AI in them at all. This cycle had a surprisingly strong crop.

Mia: First, Design Studio by Monday Merch. It's a browser canvas for designing merch, and the scale is the selling point: over a thousand products you can design on, in both 2D and 3D. And the printing rules are baked in.

Milo: That last part is the difference-maker. Anyone who's designed a shirt or a mug knows the pain: what looks good on screen fails in print — wrong resolution, colors out of gamut, design over a seam. If the tool enforces print constraints as you design, in real time, you can't ship something unprintable.

Mia: And it's free. Then there's Sliick, which solves a different but related problem: device mockups. It makes 3D device mockups for screenshots and videos, right in the browser, and it's free with no account, no watermark, and no uploads.

Milo: No uploads is the security-adjacent point. Traditional mockup tools make you upload your screenshot to a server. Sliick does the compositing on-device — your media never leaves your machine. For anyone mocking up anything sensitive, that's a real differentiator, not just a convenience.

Mia: And third, GLYPH Immersive. It's a free browser tool for modular grid lettering — rounded-pixel letterforms on an adjustable grid, no signup. So it's a typographic toy, basically, for making display type out of grid modules.

Milo: It's narrower than the other two, but it fits the same pattern: a professional-grade creative capability, delivered in the browser, zero friction, zero cost. Which raises the obvious question — what's the business model? Free tools with no accounts are great for users and mysterious as businesses. Either these are marketing funnels for something else, or they're betting on scale we can't see yet. That's the genuine unknown here.

Mia: From free creative tools, let's move to tools about control — privacy, portability, and paperwork. There's a theme here: what leaves your machine, and who owns your data.

Milo: Starting with TIM PG. It's a Windows tool, offline, and explicitly AI-free, and what it does is mask personal data in your clipboard before you paste it into an LLM — and then restores it in the response.

Mia: Walk through that flow, because it's clever. You copy text containing, say, a client's name or account number. Before pasting it to ChatGPT or Claude, TIM PG replaces the personal data with placeholders. The LLM works on the sanitized text. Then when the response comes back, TIM PG swaps the placeholders back to the real values.

Milo: So the LLM never sees the personal data, but you get output as if it had. And the fact that it's offline and AI-free is almost a philosophical statement — the privacy tool itself doesn't phone home or use a model.

Mia: The open question is how the masking holds up against complex prompts. If your placeholder tokens collide with something else in the text, or the model rewrites the structure around them, the restore step could get messy. Simple find-and-replace patterns are robust; convoluted prose is harder. That's worth testing before trusting it with anything sensitive.

Milo: Then ChatHop, which is about portability of conversations. It moves AI conversations between assistants with the context included, and it can copy chats as text or Markdown. Free tier is twenty uses a month.

Mia: This exists because of lock-in. Your conversation history is trapped in whatever assistant you started with. If you want to move a long, developed conversation from one assistant to another — because the second one is better at a task, or cheaper — normally you'd lose all that context or retype it. ChatHop carries it over.

Milo: And third, Formesign, which brings legally binding eSignature to Google Forms. When someone submits the form, you get signed PDFs by email, an audit copy goes to your Drive, and everything syncs to Sheets.

Mia: This fills a real gap. Google Forms is great at collecting responses but has no signature capability — so anyone needing a signed agreement, consent, or contract at the moment of form submission has had to bolt on a separate e-sign flow. Formesign folds it in, with the audit trail in Drive, which is what makes it legally meaningful rather than just a checkbox.

Milo: So across these three: mask what leaves, move what you've made, sign what you've collected. It's the unglamorous layer, but it's where a lot of real friction lives.

Mia: Alright, let's shift to workspaces and how people spend their attention — watching, sharing, launching.

Milo: LiveGrid first, and this is a fun one. It's from a solo founder, Lucas, and it lets you watch multiple live streams side by side in one browser grid — Twitch, YouTube, and Kick all together.

Mia: The multi-platform support is the point. If you follow streamers across Twitch and YouTube and Kick, you're currently juggling browser tabs, each with its own volume and layout. LiveGrid puts them in one grid, in one window. It's a small product from one person, but it solves a real, specific annoyance.

Milo: From watching streams to working together: Spaces is a desktop app that gives teams one shared space per project, with AI agents in that space alongside shared chats and files. And the price is striking — 10 dollars and 99 cents per person, per year.

Mia: Per year, not per month. That's aggressively cheap for team software — it's priced like a utility, not a SaaS platform. The bet is clearly on volume. The model is: instead of AI being a sidebar in your chat app, the project space itself is the unit, and agents live in it next to your files and conversations.

Milo: And then Raycast 2.0, which is a rebuild of the macOS launcher. New features: cross-app AI actions, Automations, Projects, dictation, and file search. One caveat to flag clearly — it requires macOS Tahoe.

Mia: The cross-app AI actions are the headline. Launchers used to be about opening apps and files. Raycast 2.0 is positioning itself as the control surface for your whole machine — do AI things across apps, automate flows, organize work into projects, all from one place. The Tahoe requirement is a real limitation though — anyone on an older macOS is locked out of this version entirely.

Milo: So there's a thread through all three: consolidation. One window for your streams, one space for your project, one launcher for everything. Tools keep collapsing into fewer surfaces. The unknown is adoption — whether people actually abandon their existing scattered workflows for the consolidated one.

Mia: Last topic, and it's a fun one to end the loop on — niche verticals getting the AI treatment. Specifically: construction ditches and advertising.

Milo: Starting with sizeless. It's backed by YC and ETH Zurich, and what it does is wild: you take smartphone video of an open trench, and it turns that into a 3D model, with CAD and BIM plans and billing quantities.

Mia: Think about what that replaces. Traditional progress documentation on a construction site means someone measures, someone photographs, someone reconciles it all into plans and quantities for billing. If a phone video can produce a dimensioned 3D model and billable quantities directly, that collapses a multi-step, multi-person workflow into a ten-second clip.

Milo: And the credibility signals are real — YC and ETH Zurich backing means there's serious research muscle behind the computer vision. But the open question is exactly the one you'd expect: measurement accuracy. Construction billing is contractual. If the extracted quantities are off by even a few percent, that's real money and real disputes. The gap between "impressive 3D model" and "numbers you can bill against" is where this lives or dies.

Mia: Then Wisry, on the marketing side. It uses AI agents to scan the Meta and TikTok ad libraries — the public archives of ads — find winning ads, clone them into your brand, and launch them on Meta and Google, optimized for ROAS, which is return on ad spend.

Milo: So the loop is: observe what's already proven to work at scale, adapt it to your brand, launch it, optimize for the return metric. It's performance marketing fully automated — no creative team, no media buyer, just agents watching the ad libraries and iterating.

Mia: The open question is the ROI of the clones themselves. A winning ad worked for a specific brand, product, and audience. Whether a brand-swapped clone retains that performance is exactly the thing nobody knows until the spend happens. It's a bet that creative patterns transfer — which is sometimes true and sometimes very not.

Milo: And the third piece here loops back to where we started: Anysite.io, the B2B data layer for agents — the one we mentioned earlier with 650-plus sources and 3,500-plus endpoints over MCP and REST, outputting compact, context-friendly data.

Mia: And that's why it belongs here and not just in the agent plumbing discussion. Because sizeless and Wisry are both data-hungry verticals. Construction runs on measurements and quantities. Advertising runs on performance data and competitive intel. And agents can only be useful in those domains if something feeds them clean, dense, relevant data. That's the layer Anysite is building.

Milo: So the loop closes: we started with tools to run agents in parallel and review their work. We end with agents reaching into trenches and ad auctions — and remember that everything an agent does downstream depends on what it can see upstream. The data layer, the review layer, the control layer. The agents are the flashy part, but this cycle was really about everything growing around them.

Mia: And a lot of it is still unproven — spec review at scale, voice in real workloads, trench measurements you can bill against. Those are the questions to watch.

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

Mia: Bye everyone.