1. Mastra Processors: The Guardrail Layer That Runs on Every Step — Matias Lapolla

  • Why read: Why basic guardrails fail in agent loops and how to fix safety at every step.
  • Summary: Input and output filters aren't enough for agents because they can fail mid-loop with bad tool calls or hallucinations. Mastra uses processors for every reasoning step and tool call. By splitting logic into input and output stages, you can check for costs, PII, and moderation before the model runs. This turns guardrails into a feedback loop that cleans history and triggers retries instead of just blocking progress. Preventing "context poisoning" keeps the agent on track.
  • Read more

2. Slippery Slop — Max Brodeur-Urbas

  • Why read: A warning against letting "agentic slop" ruin human craft and client trust.
  • Summary: As connecting agents gets easier, companies risk replacing high-value human work with low-effort AI noise. A good rule: if content takes less time to build than to read, it’s probably slop. In support, AI that acts as a wall instead of a bridge causes churn. Teams also suffer when they stop talking directly and hide behind agents. The goal is combining AI speed with the effort that makes work actually good.
  • Read more

3. The Rise of Multi-User, Multi-Channel Agents — Sam Bhagwat

  • Why read: The technical changes needed to move agents from 1:1 chats into shared Slack or Discord channels.
  • Summary: Agents are moving from private assistants to teammates in shared channels. This requires new ways to handle concurrency, permissions, and memory. Mastra maps platform threads to agent threads and uses user IDs to keep context separate. Since every platform handles auth and token rotation differently, you need reliable handling of these messy details so agents can help groups without leaking private data between users.
  • Read more

4. How To Implement Agentic Systems In An Enterprise — Josh Schultz

  • Why read: Why agents fail in companies because of system design, not model limits.
  • Summary: Most enterprise agents break because they ignore the feedback loops and delays built into business systems. Like high-frequency trading, agent workflows have to respect organizational structure to avoid "flash crashes" in operations. Implementation means mapping feedback, delays, and how humans respond. Moving from a demo to a working system is a systems science problem. That is the main hurdle for scaling.
  • Read more

5. We've been running an "AI Pilled" playbook for non-technical teams — Daniel C. Liem

  • Why read: A guide to getting non-technical teams to actually use AI.
  • Summary: Decagon moves teams away from web chats and into desktop tools that feel like coworking. By building internal connectors (MCPs) for Salesforce or Gong, they give sales and ops teams the context they need for an immediate win. Success comes from finding internal champions and making AI use feel like a standard part of the job. The goal is a "Glass" interface that hides the configuration mess.
  • Read more

6. How we built a lab to evaluate data agents — Izzy

  • Why read: How to build testing infrastructure for data agents.
  • Summary: Data analytics is a trap for agents because questions look easy but bugs are often hidden in silent assumptions. Hex built "The Shoebox" to test the whole context loop in a real data warehouse. They use pairwise tests, comparing new runs against a stable production version. This lets teams test models and memory with real data. The takeaway: context quality matters more than which model you pick.
  • Read more

7. The VibeSec Reckoning — Daberechi Ruth Edeokoh

  • Why read: Security basics for moving "vibe coded" prototypes into production.
  • Summary: Prototyping with AI is fast, but it often ignores security. Research shows a quarter of AI-generated code has flaws, like making storage public or giving too much access. These are systemic issues. To ship safely, you need to bake security rules into the first prompt and use automated checks. Human review is still the only way to catch risks like lateral movement that tools miss.
  • Read more

8. A Market for Machine Labor — Sishir

  • Why read: How software is shifting from a tool for humans to a producer of labor.
  • Summary: AI is starting to do work end-to-end instead of just helping humans. In this model, tokens are just the meter for the real product: machine labor. This changes the market from selling seats to selling completed work. For this to work, we need clear standards for model quality and reliability. Eventually, pricing will move to outcome-based models that charge for the task finished, not the tokens used.
  • Read more

9. The end of the software era is the beginning of the harness era — Tomasz Tunguz

  • Why read: The seven components you need to turn an AI demo into a production agent.
  • Summary: The LLM is the smallest part of the puzzle. The "harness" around it—memory, tools, loops, state, compute, governance, and cost—does the heavy lifting. As models get more similar, the winners will be those who build the strongest surrounding systems. Persistence is the most important layer. It lets agents recover from crashes and continue long tasks instead of starting over.
  • Read more

10. Skills as the next frontier in AI? SkillOpt — Peder Aaby

  • Why read: Research on treating agent behaviors as trainable skills rather than prompts.
  • Summary: The SkillOpt paper argues that the next step for agents is persistent, executable memory. By treating "skills" as artifacts you can optimize, researchers are bringing math-based tuning to text-based behavior. This uses validation gates and edit buffers to keep things stable. For companies, building a library of these proprietary skills and workflows will be a bigger advantage than the model they use.
  • Read more

11. English isn't a programming language (yet) — kasey

  • Why read: Why "vibe coding" makes team collaboration harder and how to bridge that gap.
  • Summary: AI lets anyone write code, but English doesn't have the versioning or logic of programming languages. This creates a "fog of war" where one person is productive but the team slows down because the "why" behind the code is lost. As code volume grows, the bottleneck isn't writing lines. It's understanding how the system works. We need tools that combine the clarity of English with the reliability of Git.
  • Read more

12. Inference Market Dynamics: OpenRouter and Chinese Models — Tommy

  • Why read: Analysis of the inference provider boom and the shift toward closed-source Chinese models.
  • Summary: OpenRouter’s recent funding shows a gap for Western providers as top models go closed-source. As Chinese models move behind APIs to keep their data, providers can use GPU scale to cut costs and offer privacy. This is an opening for a Western Open Source lab to step in. The market currently favors those who can deliver open-source intelligence cheaply and use their hardware to fine-tune future models.
  • Read more

13. Building an AI agent to automatically investigate support tickets — John Yeo

  • Why read: Using structured logs and tenant context to automate support ticket investigation.
  • Summary: Billing bugs are hard to fix because they require digging through hours of logs to see what happened. This project uses "wide logging" to add tenant and state data to every request. By making logs searchable and structured, agents can query tools like Axiom to reconstruct events like plan changes. The agent’s success comes from the quality of the telemetry, not the complexity of the AI loop.
  • Read more

14. Avoiding Death on the Yellow Brick Road — Joe Schmidt IV

  • Why read: How startups can survive without being replaced by big AI labs.
  • Summary: Labs like OpenAI solve horizontal problems that get better as models improve. Startups that just use basic connectors will get replaced. To win, startups need to focus on vertical problems. This means specialized work that needs heavy scaffolding, compliance, and industry knowledge. Big enterprise deals show that labs cannot solve everything with a general tool. Focus on the architecture below the model.
  • Read more

15. How to Make Friends and Influence Agents — Simon Corry

  • Why read: Architectural lessons for giving agents long-term memory.
  • Summary: Most agents today are one-offs, but real projects need continuity. This setup uses an eight-step loop that starts by reading session history to see where the last agent stopped. It uses a "plan mode" and engineering basics to manage complexity before writing code. The goal is building a registry of specific institutional knowledge. Without this continuity, agents are too expensive to retrain on context for every session.
  • Read more

Themes from yesterday

  • The Harness Era: The LLM is just a runtime. Real value comes from the surrounding systems of memory, safety, and structured context.
  • Quality over Slop: With AI code and content everywhere, the focus is shifting to human craft and automated security checks to keep standards high.
  • Machine Labor Markets: Experts are reframing AI as a direct provider of labor. This means moving toward outcome-based pricing and clear standards for work quality.