0907 | Taming Your AI Work: This Week in AI Tools

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

Milo: And I'm Milo. Today we're doing a daily briefing, and there's a thread running through all of these launches that I find genuinely interesting: they're all, in one way or another, about the gap between what AI can do and what you can actually control, reuse, and trust once it exists.

Mia: Right. We've got a tool for organizing your AI conversations, two different takes on speed and efficiency in AI systems, an AI teammate in Slack, a question about who approves what agents write, and a couple of tools that are a bit further from AI but still fit the theme.

Milo: And we're going to be careful here, because a lot of these launches come with big claims from their makers, and big claims deserve scrutiny. So we'll treat those as claims, not verified results, and we'll lean on what actual users and community members said.

Mia: Let's start with the one that speaks to a problem almost everyone using AI daily has run into: losing your work.

Milo: AI Toolbox 3.0. It's a Chrome extension, and the pitch is that it's a missing layer on top of ChatGPT, Claude, Gemini, and Grok. One install covers all four platforms.

Mia: The founder, Adi, one of two founders, wrote the launch post, and the origin story is relatable. He started it two years ago with thirty-two dollars — a cheap virtual machine and the Chrome developer fee. He was living inside ChatGPT all day and kept losing work: chats he couldn't find again, prompts he re-typed for the hundredth time, no way to export anything.

Milo: And what did they actually build? The feature list is concrete. Folders and subfolders right in the sidebar. Full-text search across every conversation — including a single query that searches all four platforms at once.

Mia: There's a prompt library where you type double slashes to insert a saved prompt anywhere, and you can chain prompts into multi-step workflows. There's bulk export to Markdown — with YAML frontmatter — PDF, JSON, or zipping a whole folder. On Claude there's an Artifact Vault that collects every artifact and created file in one browsable place.

Milo: And a live context meter so long chats don't cut you off mid-thought, with a one-click handoff to a fresh chat. One user described exactly how that handoff works in practice: they start a chat in Claude, want to continue it in ChatGPT, press one button, and it summarizes the chat and carries it into a new ChatGPT conversation. That's a workflow that just doesn't exist natively.

Mia: On the trust side, this is local-first. Search and export run entirely in your browser, and your conversations are never sent to their servers. Adi also emphasized that almost every feature came from a user request — he said the support inbox is their roadmap.

Milo: Now, the traction numbers come from the maker, so treat them as claims, but he reports forty thousand plus users in over a hundred and fifty countries, four and a half stars on the Chrome Web Store, five-figure monthly recurring revenue, and forty-five dollars a month of infrastructure. Two people, bootstrapped, no funding.

Mia: The community response was largely positive. One commenter said they'd been using it for a year and called it one of the best additions to their workflow. Another wondered why folders aren't built into the AI platforms already — which is kind of the whole thesis of the product, that the platforms keep not shipping the basics.

Milo: But there was meaningful criticism too, and I want to give it real time. A user who's been working with it alongside Claude for about a month said the JSON export has been very helpful for reviewing outstanding issues in long-running chats — but also that search is sometimes flaky, not finding known values in chats, and that the context meter is, in their words, a "guess" at best. Still recommended the tool overall, but those are real rough edges.

Mia: And the sharpest technical question came from another commenter about the local-first design itself. They pointed out that a local search index across four platforms would live in IndexedDB, and Chrome evicts that storage under pressure without telling anyone. Two years of history plus a folder tree is exactly the thing that could quietly vanish and then look like a bug in the extension. They asked whether the team calls navigator.storage.

Mia: persist and surfaces the quota anywhere, or whether the context meter is the only storage number in the UI.

Milo: Which is a genuinely important question, because the whole value proposition is "your conversations are your work" — if the index is evictable, you could lose the organization. And another commenter asked directly whether they copy or use your data to train their AI or let third parties see it, saying they'd already been burned by one AI provider. The team's stated position is local-first and that conversations never hit their servers, but the eviction question wasn't answered in what we have.

Mia: There was also a good forward-looking question: ChatGPT, Claude, Gemini all change their DOM structure pretty often. When one ships a UI update, does the extension quietly break for that platform until a patch ships, or is the scraping resilient by design? That's the inherent fragility of building on top of platforms you don't control.

Milo: Which, by the way, is the flip side of the theme we set up — AI Toolbox gives you control over AI output after it exists, but it has to fight the platforms to do it. Okay, speaking of control, let's shift from organizing AI work to generating it, specifically video.

Mia: H3 Max, by fal. This one has some of the boldest claims of the day, so let's be precise about what's claimed and how.

Milo: The story is that generative video usually forces a tradeoff: quality or speed, pick one. Want a good video? Wait longer. Want it fast? Accept worse output. fal claims to have broken that tradeoff.

Mia: How they claim to have done it: they started with the open-weight MiniMax H3 model and post-trained it with substantial new data focused on prompt adherence and visual quality. Then their inference team rebuilt the serving stack around it, running on NVIDIA GB200 NVL72 systems, so the speed gains don't eat into the quality. They describe the research and inference work as deeply connected — training and inference decisions informed each other during development.

Milo: And an important detail from their writeup: they had a discipline about speed optimizations. There are ways to make a video model faster — reduce precision, remove sampling steps, approximate expensive operations — but for H3 Max, an optimization only survived if the model kept its position in internal quality evaluations.

Mia: The claimed result: a five-second video generated in roughly three seconds. That's about thirty-five times the throughput of the official MiniMax H3 endpoint, and on average fifteen times faster than anything of comparable quality, by their numbers.

Milo: On quality, they benchmarked against twelve leading video models — including the official H3, Gemini Omni Flash, Wan 3.0, Seedance 2.5, Kling 3, and Veo 3.1 — using head-to-head human preferences aggregated with Bayesian Elo ratings and ninety-five percent confidence intervals, scoring separately on overall preference, prompt understanding, and aesthetics. They claim number one across all three dimensions and majority wins in head-to-heads against every model tested.

Mia: And they point to independent benchmarks backing it up — Artificial Analysis and Design Arena. Design Arena's quote, as cited by fal, says H3 Max delivers the quality of MiniMax H3 at more than fifty times the speed, establishing a new speed-preference Pareto frontier.

Milo: Now, we should flag the obvious caveat: these are fal's own evaluations first, and even independent benchmarks are still benchmarks, not your specific use case. But there's one community comment that cuts right to the practical concern.

Mia: Yeah — someone said three seconds for a five-second clip is wild if the quality holds up at that speed, noting that most "fast" video models they've tried get noticeably worse motion coherence past two to three times realtime. They said they'd try the image-to-video endpoint on something with actual camera movement, since that's usually where speed tricks fall apart.

Milo: That's exactly the right question. Motion coherence under real camera movement is where these models tend to show cracks, and we don't have community evidence yet either way on whether H3 Max survives it. Availability-wise, it's usable through fal's Playground, their agent, or the API, with text-to-video and image-to-video endpoints. The MiniMax team also gave a supportive statement about the partnership.

Mia: There's a line in fal's own blog that's worth repeating because it frames the whole thing: a model isn't useful in production just because it's good — and with video moving into interactive and high-volume workloads, speed and quality have to improve together. That's the thesis.

Milo: Which brings us neatly to another runtime-efficiency story, except instead of video, this one's about coding agents. Kit, by Speakeasy.

Mia: Kit is a coding agent runtime, and the pitch in one line is "Claude but fast, cheap, concise." The core idea is a departure from how most agent harnesses work.

Milo: Most agent harnesses expose many tools, and each tool call costs one model round trip. Kit exposes one tool: compose. The compose argument is a short program — in a language they call Runlet — and in a single round trip that program can read files, run tests, apply edits, retry failed commands, delegate to subagents, and return structured data.

Mia: Fewer round trips means less repeated context and more work per request. And within a compose program you get real composition: independent calls run concurrently, you can control execution order with data dependencies or after blocks, and there's boundary-retry and fail for error handling. The subagents are reusable values too — you can continue them, fork them, inspect them, close them, and require JSON that matches a schema.

Milo: One detail I find notable: you can use Claude Code, Codex, Cursor, or Kit itself as the subagent harness, over ACP — the Agent Client Protocol. That protocol is the architectural point of the whole thing: ACP separates agent clients from agent runtimes, so Kit works in compatible editors and can orchestrate other harnesses without custom integrations. There's also an A2A endpoint, and support for MCP, Agent Skills, and Agent Plugin packages.

Mia: On efficiency, they claim roughly half the input tokens and active time per hand-written line compared to Codex CLI or Claude Code on size-matched production tasks. Same rule as before — that's the maker's claim, and the comparison conditions matter.

Milo: Practical stuff: it ships as one static binary — terminal client, ACP server, A2A endpoint, and subagent orchestrator all in that binary. Install is a curl script, then kit init, kit auth login, kit tui. It supports ChatGPT subscriptions through native OAuth, models via OpenRouter and the Speakeasy AI Control Plane, and you can switch models mid-session with a slash command.

Mia: For long sessions, Kit synchronizes each transcript item to disk before accepting it, compacts context automatically at eighty percent of the context window, lets you resume sessions from the TUI or any ACP client, and retries eligible OpenAI subscription failures for up to twenty-four hours. Also worth noting honestly: Kit has no permissions framework, no sandbox, no web UI. The docs are explicit that it's a runtime, not a security boundary — you run it inside a security boundary you trust.

Milo: The community reaction highlighted exactly the things you'd expect. One person said the static binary is the part that gets them — every Speakeasy thing just runs with zero setup — and they're making it their daily driver rather than just poking at it. Another liked having terminal, ACP server, A2A endpoint, and orchestration in one binary because it simplifies setup.

Mia: And the open question, from a technically sharp commenter: the ACP separation is interesting, but for the subagent orchestrator specifically — when a subagent's output gets merged back into the main session, is there any validation step, or does whatever the subagent produced flow straight through as if the top-level agent wrote it itself? That's unanswered in what we have, and it's a real trust question, same flavor as the ones we heard about AI Toolbox.

Milo: There's also an honest asymmetry to name: Kit is MIT-licensed and open on GitHub, but it's young — twenty-one stars there at the time of this data, so you're trading the maturity of established tools for a genuinely different architecture. Which is a good segue, actually, because the next product is about trusting AI output too — but in Slack, where it's your work contacts reading it.

Mia: Tadata. It's positioned as "the AI employee in Slack that reads the room." It lives in Slack, connects to your tools, learns your company and your preferences, and does work for your team.

Milo: The co-founder, Tori, explained the philosophy: people should be able to delegate to AI like a teammate — tell it what you need, give feedback, let it figure out the rest — without having to learn how to build agents. Her favorite example is lead finding: she describes exactly who she's looking for, and Tadata researches across internal tools and harder-to-reach sources like LinkedIn or Google Maps. If the results aren't right, she just replies with what to change.

Milo: She's not choosing data providers or wiring tools together — she's delegating the job, and Tadata puts the system together underneath.

Mia: On the team's background: they came from the infrastructure side. They created FastAPI-MCP, which grew to twelve thousand GitHub stars and over seventy million downloads. Their framing is that knowing how to give agents tools is very different from having an AI teammate you can rely on. And a fun admission: Tadata helped with nearly every part of their own launch.

Milo: The product details are pretty concrete. It connects to tools like HubSpot, Attio, Notion, Linear, GitHub, Google Sheets, Gmail, Google Calendar, Hunter.io, Monday.com, plus any MCP or API. External context covers company sites, careers pages, LinkedIn, Google Maps, job boards, filings and reviews, social platforms, local listings.

Mia: There are pre-built agents to start from — outreach personalization that adds a researched opener to every message, a warm intro finder, call preparation, a LinkedIn listener that flags posts where a solvable problem gets named, a new hire finder, conference prep. And there's a daily rhythm described: a 7:45 AM briefing in Slack with your calls, what changed since you last spoke, and relevant news. During the day it notices what repeats and offers to take it — asking before automating anything.

Mia: After a call, follow-up email drafted, CRM fields filled, next step written — nothing goes out until you approve.

Milo: The positioning against lock-in is deliberate: it's model-agnostic, and your automations, preferences, exceptions, and learned recipes are exportable and versionable — take them with you when you switch models. They stress scoped access and credential isolation.

Mia: Now the community, and this is where it gets interesting, because the questions were hard and specific. One commenter asked the failure-mode question: if Tadata researches a lead and gets something confidently wrong — stale data, wrong company, a hallucinated detail — does it flag its own uncertainty, or does it just show up as a normal Slack message and get treated as ground truth by whoever asked?

Milo: That's the question that matters for an "AI employee." If it talks like a colleague, a wrong answer has the same credibility as a right one. Another person who lives in Slack all day asked how it handles channels that are half decisions and half noise — does it need to be tagged or is it listening in the background — and how deep the "learns your company" part goes after a week versus a month.

Mia: There was also a comparison question to Claude Tags — one commenter said they're a big fan of Claude Tags and see Tadata as an accessible alternative that's model-agnostic and could eventually run on local models — asking whether Tadata requires tagging or decides when to jump in on its own. And someone else asked how it compares to a competitor called Viktor, and whether it connects to Shopify.

Mia: Another observed the category is heating up and asked what, beyond model-agnostic, differentiates Tadata.

Milo: Those are fair. The positive reactions were about feel: one person said the short, crisp answers and giving instructions in Slack feel more seamless than other Slack bots. Another said they'd been looking for a place in Slack to delegate endless context switches to and thanked the team for solving it.

Mia: So Tadata's bet is that delegation is the interface, not building agents. And the open questions all cluster around trust: uncertainty signaling, background listening, and differentiation in a crowded category.

Milo: Which leads perfectly into our next item, because it takes the trust question into documentation — and one of its commenters made an argument that challenged the product's whole design. DocsAlot.

Mia: DocsAlot is a documentation platform, and this launch is specifically its visual editor. The founder, Faizan, framed the tension well: almost everything in software is being rebuilt for agents right now — DocsAlot gives agents access to docs through the CLI and MCP, and AI can help create and update content — but a human still needs to make the final call before documentation becomes public.

Milo: The technically hard part, as he describes it, wasn't putting a text box in a browser — it was building visual editing without breaking the underlying Markdown. A page can move between visual and source mode while preserving its frontmatter, tables, code, links, and structure.

Mia: And the workflow separates editing from publishing. Changes live in a working draft. A human deliberately saves a version, can return to earlier versions, and chooses exactly when that version becomes public. Navigation is treated as real site data, so moving pages and groups updates the same structure the published site uses. Everything comes from one source — hosted docs, llms.txt, skill.md, and MCP.

Milo: The editor itself has documentation-specific blocks: code groups for multiple languages, callouts for warnings and context, steps for guided workflows, tables, tabs and cards. And the AI assistant works inside the workspace rather than a separate chat box — you ask for an outcome, then inspect exactly which pages it touched.

Mia: Now, community reactions split in a fascinating way. On the supportive side, one person called it a genuine issue — keeping documents updated in multiple locations is a hassle, and having AI agents pull outdated or random context makes it worse — and they loved having a single source of truth.

Mia: Another commenter, who'd tried building something similar, said the Markdown-preserving part is what they'd worry about breaking, because visual mode always mangled frontmatter or code blocks eventually — and they asked how long the team has been dogfooding it on their own docs.

Milo: And then the critique that I keep thinking about. One commenter argued that a human approval gate catches formatting but not the failure that actually costs you — an agent writing a code sample that reads perfectly and doesn't run. Nobody rejects a diff that looks right. Their point: since DocsAlot already has the CLI, the review step should be mechanical — compile the snippets, check every endpoint against the OpenAPI spec, then show the human only the pages that failed.

Milo: Their line was that approving forty pages of prose is theatre; approving the three flagged ones isn't.

Mia: That's a strong argument, and it's a fair challenge to the product's central design decision. The human gate is about control, but control over what, exactly? If you can't actually evaluate forty pages, approval becomes a rubber stamp.

Milo: There was also a forward-looking question about the agent side: if an agent proposes an update and a human edits or rejects most of it, does the agent see what changed and why, or does it try again from scratch with no memory of the correction? Also unanswered. DocsAlot is free to try, and the bigger platform includes an AI audit, docs benchmarking, and SDK and CLI generation — so the editor is one piece of a larger docs stack.

Mia: So far, everything we've covered lives in the AI world. But the theme of "know the moment an opportunity appears, and act on it" applies elsewhere too. Notify.domains.

Milo: This one has a founder with real domain industry credibility: Michael Cyger, fifteen years in the industry, founded DomainSherpa, created DNAcademy, and ran it as GoDaddy's Director of Education after the acquisition.

Mia: The product monitors any domain you want, twenty-plus times a day — the full monitoring tier claims twenty-five-plus checks — across WHOIS, RDAP, auction platforms, marketplaces, and website signals, covering all IANA TLDs. When something changes, you get a plain-English notification with exact next steps, not raw data. Things like: your domain changed, here's what we saw. Domain in auction, bid here now. Pending delete started, here's your backorder checklist.

Mia: Marketplace listing dropped thirty-five percent.

Milo: And the key insight from his launch post is something most people learn the expensive way: expired domains don't just drop and become available to anyone. That's a myth. Registrars quietly send expiring names to their auction partners before the public sees them — some go to GoDaddy Auctions, some to NameJet, some to smaller networks — with no master list and no single schedule. Miss the right place or time, and the name slips away forever.

Mia: Pricing is refreshingly concrete: twenty-four dollars a year, seven-day free trial, no credit card required. And there's a human element — every domain you track includes a direct line to the founder in the app. There's also a time-saved tracker, which one user mentioned appreciating.

Milo: The user stories are actually touching. One person said they've been tracking a name they've lusted over for more than a decade — it's not being used, not for sale, and the owner won't respond — and knowing Notify is working around the clock gives them hope. Another user said Michael genuinely listens to feedback and keeps improving.

Mia: On the criticism and open questions: one commenter asked the race question — if a domain is desirable enough that you're watching it, other domainers and sniping services are probably watching the same signals. Once the alert fires, is there still a real window to act, or does it come down to who has the fastest registrar API hooked up? That's the harder problem, detection versus speed.

Milo: Another commenter shared a painful story — they lost a dot-com exactly that way a few years back, watched it expire with zero idea drop-catchers already had it lined up before they even noticed the page went down. And there was a really practical question from someone running a business on a dozen small sending domains: the failure they actually worry about is one of their own domains quietly lapsing or having DNS changed under them.

Milo: Does Notify watch domains you already own, or is it purely for names you're trying to acquire? The feature list does include brand protection and status monitoring, but that specific owned-domain lapse use case wasn't fully answered.

Mia: One more community question worth noting: someone asked whether it can search by keyword or industry instead of specific domains, and whether two people monitoring the same name would each get the same alerts — the answer appears to be yes, nothing stops multiple people from watching the same name.

Milo: So Notify is the non-AI entry in the briefing, but structurally it's the same idea as everything else today: a monitoring layer that turns scattered, hard-to-track signals into a clear action.

Mia: And that brings us to our last item, which loops back to the efficiency theme from H3 Max and Kit — but this time from Google, and on the analysis side of video. Agentic video understanding in Gemini.

Milo: This is a new processing mode, not a separate product, and it's live now across Gemini 3.7 Flash, 3.6 Flash, and 3.5 Flash-Lite. The change: instead of scanning footage at a fixed frame rate, the model runs an internal agentic loop and decides what to watch, at what speed, and through which modality — frames, audio, or the transcript — fetching only the segments it needs.

Mia: The claimed numbers: up to eighty-eight percent fewer tokens, up to sixty-six percent lower cost, and up to seven percent better accuracy — with the biggest wins on long-form video. Use cases listed include needle-in-haystack search across multi-hour video, sub-second moment retrieval for auto-editing, anomaly detection via variable FPS resampling, and accurate counting of repeated actions or objects.

Milo: Availability is the notable part: it's live in the Gemini API in AI Studio and the Gemini Enterprise Agent Platform, at standard pricing, no extra fee. You just set processing to "agentic." So unlike fal's H3 Max, which is a new model you adopt, this is a toggle inside models you may already be using.

Mia: And it's worth holding the two side by side for a second. Both are attacks on the cost-quality-speed tradeoff, but from different directions. fal post-trained a model and co-designed hardware-optimized inference to make generation faster without losing quality. Google made analysis smarter by having the model allocate its own attention dynamically instead of processing everything uniformly.

Milo: Both claims share the same caveat: these are maker-reported numbers. Google's blog cites up to eighty-eight percent token reduction and seven percent quality gains, but we don't have independent benchmark data or community experience with this mode yet — it just shipped. The community discussion was thin: one commenter said the token and cost cuts caught their attention, and asked about speed, but there wasn't substantive field experience to draw on.

Mia: So what should we take away from the whole briefing? I keep coming back to one pattern. None of these products are building better AI models per se — they're building control layers, efficiency layers, and trust layers around AI.

Milo: Yeah. AI Toolbox gives you ownership of conversations the platforms treat as disposable. Kit collapses agent overhead into a single round trip. Tadata turns AI into something you delegate to and can correct in plain language. DocsAlot gates what agents write before readers see it — though its sharpest critic would say the gate needs to be mechanical, not just human. H3 Max and Gemini's agentic video mode both refuse the old tradeoff between speed and quality. And Notify.

Milo: domains watches signals nobody else is watching, in a domain industry where the insiders have always had the edge.

Mia: The open questions matter just as much, though. Can a Chrome extension survive platform UI changes and browser storage eviction? Does H3 Max hold motion coherence with real camera movement? Does Kit validate subagent output? Does Tadata flag its own confidently wrong research? Do agents learn from human doc corrections? Does a domain alert fire early enough to beat the drop-catchers?

Milo: Those are the questions worth watching as these products mature. That's the briefing for today — thanks for listening, I'm Milo.

Mia: And I'm Mia. We'll be back with the next one.