This week's video

Spotify's internal coding agent, Honk, is now merging 1,000 pull requests every 10 days, up from 1,000 every three months just six months earlier (per Spotify engineers at QCon London 2026). The agents can clearly ship code. The question that actually matters is which tasks you hand them, and how much rope each one gets.

This week starts a new build series: Building a Software Factory with Mastra. I'm building it station by station, and the first one is deliberately small: a read-only Dependabot triage agent that reads every changelog then posts a merge-or-hold call to Slack.

Watch the video →

A factory is a delegation ladder, not an autonomy switch

"Software factory" already means two different things right now.

One version is agents running whole businesses with no human in the loop: shipping products, monetizing them, collecting the revenue. That's a real thing happening, and it's not what this series is about. The other version, the one BCG and a handful of engineering orgs are actually running, is agents absorbing the operational loops of software delivery. Dependency triage, PR review, incident response, ticket to PR. Humans still hold judgment. That's the lane I'm building in.

The mental model is a ladder, not a switch. Autonomy scales with the scope, size, reversibility, and blast radius of the task. A patch bump with green tests can ship itself. A scoped ticket comes back as a draft PR. A judgment call gets you evidence and stops there, waiting on you. Station 1, the one in this week's video, sits at the bottom rung on purpose: read-only to start.

That distinction matters because the failure mode people worry about, the "dark factory" where nobody's watching, isn't caused by giving an agent autonomy. It's caused by giving it unscoped autonomy: turning it loose on a task without matching the level of trust to the size of what could go wrong. Widening scope deliberately, one earned station at a time, is a different thing entirely.

The factory map has six stations: dependency triage, giving the factory hands to actually check out and test a repo, a PR review station, production signal triage off Sentry, ticket-to-PR delegation from Linear, and eventually scaling the factory across repos. Each one lights up a new node on the map and hands the agent a little more scope than the last. I'll be building this one in public, bi-weekly, against a real running app. The companion repo is where each station lands, so you'll see what breaks along the way, not just the parts that worked on the first try.

Contributor Spotlight: Greg Wilson

Greg's back with a piece that fits this week's theme better than I planned for. His post: a single Grafana dashboard for watching a Mastra agent during an incident. Five golden-signal numbers, a real windowed p95 latency instead of an average, and token throughput and spend sitting right underneath. He wires Mastra's metrics through a Prometheus exporter and attaches trace IDs as exemplars, so a latency spike in Grafana links straight back to the trace that caused it.

That's exactly the kind of observability a factory needs once agents start acting instead of just reporting. Right now Station 1 posts a Slack message. Once later stations touch the repo directly, knowing what an agent is actually doing, and how much it's costing you to do it, stops being optional.

Open source updates

agent-skills shipped a team code review skill. It's an evidence-driven, multi-agent code review: specialist agents cover architecture, readability, testing, maintainability, security, and documentation, but the main agent independently verifies every finding before it makes the report, so nothing gets flagged just because a specialist thought it sounded plausible. It also ships an opinionated Rails review profile with POODR-inspired object design checks. Same read-only discipline as the factory I'm building this week: gather evidence, verify it, then hand the judgment call to a human. Grab it here.

Curated Links & Tools

Catching up on the building blocks. Software Factory doesn't start from zero. It's built on three things I've already shown working: Mastra Workspaces gives an agent a sandboxed filesystem and shell so it can check out a repo and run commands, Human-in-the-Loop Approvals is the suspend-and-resume pattern behind every gate in the delegation ladder, and Mastra Supervisor Agents covers the routing and orchestration a multi-station factory eventually needs. If Station 1 has you curious how the later stations will actually work, these three are where the primitives come from.

Bonsai 27B just made a 27B-class model fit on a phone. PrismML open-sourced it today (Apache 2.0) in two builds: a ternary 5.9GB version aimed at laptops, and a 1-bit 3.9GB version small enough for a phone. Built on Qwen3.6 27B, it brings multi-step reasoning, structured tool use, and agentic loops down to that size class, the same capability tier that used to require a server or a serious workstation. A strong 4-bit build at this size still runs around 18GB, so the compression here is doing real work, not just shrinking a small model further. Worth watching if any part of your agent stack could move off a hosted API and onto the device instead.

What's the one operational signal at your job that everyone quietly ignores because reading it properly takes too long? Reply and tell me. It might be Station 7.

If you're running Mastra in production and want help figuring out where agent autonomy should actually sit in your stack, here's how I help Mastra teams.

Damian