Listen: https://blossom.nostr.xyz/e626d7c3d55ad18a9c86e87a43d5098e1316d7bb979cd481ba676d2d4318e42a.mpga

Source: Seroter’s Original Post

Listen: (audio URL to be added)

Source: Seroter’s Original Post

Episode 792 — May 27, 2026

Seroter flags this as a big reading list today with many articles carrying important insights. So let’s get into it.

Starting with Phil Schmid on Google’s Gemini Managed Agents. Seroter tried this out last week and plans to spend more time with it, impressed by how rich the service is for executing custom agents. The Interactions API provisions a Linux sandbox that handles reasoning, code execution in Python, Node.js, and Bash, package installation, file management, and web browsing. You can start with the Antigravity agent out of the box or build custom agents with your own instructions and skills. Multi-turn conversations work through environment IDs that persist sandbox state between calls, so you can hand off a workspace mid-task and pick it up later. Streaming lets you watch the agent work in real time as it reasons and calls tools. Data loading supports Git repos, Cloud Storage buckets, or inline content mounted into the sandbox at environment creation. For custom agents, you define instructions, skills, and data declaratively through configuration files, and you can fork a live environment after setting it up interactively. The service bills only for model tokens during preview, not for compute. Security features include domain allowlists and credential injection through an egress proxy, so secrets never actually enter the sandbox. There’s also a CLI for terminal-first workflows that scaffolds, tests, and deploys agents. The broader takeaway is that Google is building a full developer experience around managed agents, not just an API endpoint.

From InfoWorld, a piece on the role of MCP in context engineering. The core idea is that context engineering is the practice of supplying AI coding agents with relevant data and capabilities to improve output accuracy and relevance. MCP has become a standard way for AI systems to connect to various business tools, and the key benefit is that agents can determine what context they need based on the task and fetch it in real time. One perspective from a solutions architect frames MCP as the saving grace of vibe coding. The piece gets into how MCP accelerates the knowledge-hunting that engineers perform daily, letting agents fetch structured data contextually rather than operating blind. Seroter’s takeaway is nuanced: MCP has legit value and it’s different from what skills or CLIs do, but you can overuse it or underuse it. The point is to understand what each approach is actually doing.

A more sobering piece from HR Dive on a GoTo survey showing that amid heavy AI use, workers say their skills are atrophying. Half of employees say they depend too heavily on AI, and nearly a third say they couldn’t function without it. Thirty-nine percent of all workers and forty-six percent of Gen Z say their reliance on AI has weakened their skill sets. Meanwhile, sixty percent say they feel pressured to use AI to increase productivity. When companies demand AI proficiency without providing effective training or policies, misuse and workslop become more common. Almost one in four IT leaders say AI-related mistakes have already affected customers or the company’s bottom line. Seroter notes this is the real risk: if you use AI to do your job instead of making you better at your job, you’re going to feel unsettled. The data suggests the productivity pressure is real but the human cost is being felt.

From Google’s Medium blog, Karl Twynam on a practical guide to evaluating multi-turn agent trajectories. The key point is that you can’t just look at success or fail for your agent, especially if they’re long-running. Multi-turn agents do complex sequences of work where the path matters as much as the destination. Evaluating them requires looking at things like task completion, consistency, error recovery, and how well the agent handles ambiguity over time. Seroter flags this as good advice for anyone running agents in production.

TechCrunch with a piece on tech CEOs apparently suffering from AI psychosis. The framing comes from Box founder Aaron Levie, who observed that CEOs are uniquely prone to AI psychosis because they’re sufficiently distant from the last mile of work that generates most value with AI. They play with AI, develop a prototype, or generate a contract and then make the leap to believing agents can do the work. But these executives aren’t the people who have to review code, discover bugs, and identify calls to hallucinated libraries. Levie’s advice is to use AI a ton and come out the other side with an appreciation for both the upside and the real work. The article notes that in just the first five months of 2026, the tech industry has had nearly as many layoffs as in all of 2025, with AI cited as a reason. One example: ClickUp CEO Zeb Evans laid off twenty-two percent of employees after rolling out about three thousand AI agents to do internal work, declaring he wants a workforce of people who run agents and review their work, a hundred times org. Meanwhile, MIT researchers have concluded that agents just aren’t doing human-quality work yet in many cases, and predict models will reach base competence on most text tasks by 2029. The takeaway is clear: don’t let one demo or hands-on effort delude you into thinking AI can do everything for everyone. Really understand what it can and can’t do.

Ethan Mollick at oneusefulthing on choosing to stay human. This is a notable writeup on what happens when we offload the wrong work to AI. Mollick starts by observing that AI writing is now everywhere, and while frequent AI users can often detect it, the sameness of AI writing eventually gets tedious. Using AI for writing has a cost beyond turning off readers: it risks undermining the development of an important human skill. He contrasts two studies. In the first, students in Turkey who used plain ChatGPT did their homework better but underperformed on tests because the AI gave them answers rather than helping them think through problems. Actual learning requires mental effort. In the second study from Taipei, students given a personalized sequence of problems by an AI tutor scored point fifteen standard deviations higher on a final exam taken without AI help, the equivalent of six to nine months of additional schooling. The difference is how you use the AI: to shortcut thinking or to help thinking. Mollick calls the wrong mode cognitive surrender, and notes that agents designed to make your life easier are great for getting stuff done but bad for learning or staying authentic. His advice is to be intentional about what you hand to AI and what you keep for yourself, because once a generation of workers and students has built habits around frictionless AI use, it will be hard to reverse those defaults.

From the Chrome developer blog, Thomas Steiner on building new features using built-in AI in Chrome. It’s fairly easy to build apps that take advantage of Chrome’s built-in AI model, running directly on the user’s device. Benefits include no cloud inference cost, privacy since sensitive data never leaves the browser, offline functionality once the model is downloaded, and performance from hardware acceleration. The APIs available include the Summarizer API for generating headlines and meta descriptions, the Prompt API with JSON Schema for structured output like tag generation and comment moderation, multimodal input for alt-text generation from images, the Writer and Rewriter APIs for expanding and editing text, and the Translator API for real-time translation. Partners already shipping these include Drupal for SEO tag generation, Yahoo Japan for community comment moderation, and Trip.com for flight booking assistance.

From O’Reilly Radar, an article on the delegation problem in multi-agent AI. The core question: your AI agent booked a meeting, summarized a financial report, and emailed highlights to three stakeholders. To do this, it called a calendar agent, a document analysis agent, and an email agent. Who authorized the email agent to read that financial report? In most architectures, no one explicitly did. The authorization leaked silently through the chain. As enterprises connect agents through protocols like MCP and A2A, they’re solving the connectivity problem faster than the authority problem. The piece identifies three failure modes: ghost permissions where a downstream agent inherits privileges without an explicit grant, scope drift where delegation widens rather than narrows access as it travels through multiple agents, and broken audit trails where the audit trail fragments across agents, protocols, and services so the action traces to a system but not to a decision. The authorization didn’t fail loudly, it leaked silently. Seroter’s takeaway: is authorization adapting as fast as it needs to be? Probably not.

The Google Cloud blog on securing AI agents with MCP Authorization. This follows from the previous article and addresses how to improve authorization for key data and tools in agent workflows.

From The New Stack, an article on the AC/DC framework for governing AI coding agents at scale. AC/DC stands for Agent Centric Development Cycle. The framework explains how agent development works at scale, with some valid points according to Seroter. It’s a process framework for thinking through how to manage agents responsibly as they become more central to development work.

That’s episode 792. Ten items, and the thread running through most of them is a reckoning with what AI actually means for how we work and build. The authorization question is one of the more structural ones: we’re connecting agents faster than we’re figuring out who authorized what. The skill atrophy question is more human: the productivity pressure is real but the human cost is being felt. And the broader tension, visible across pieces from Levie, Mollick, and others, is between using AI to do more and using AI to think less. The first is genuinely useful. The second is genuinely risky.

1. Gemini Managed Agents: Developer Guide — Phil Schmid
2. The role of MCP in context engineering — InfoWorld
3. Amid heavy AI use, workers say their skills are atrophying — HR Dive
4. A Practical Guide to Evaluating Multi-Turn Agent Trajectories — Google Cloud
5. Tech CEOs are apparently suffering from AI psychosis — TechCrunch
6. Choosing to Stay Human — Ethan Mollick
7. Build new features using built-in AI in Chrome — Chrome Developers
8. Who Authorized That? The Delegation Problem in Multi-Agent AI — O’Reilly Radar
9. Securing AI agents with MCP Authorization — Google Cloud
10. The AC/DC framework helps teams govern AI coding agents — The New Stack