Playbook
Tasteful Skills
“Tasteful Skills” argues that the best agent skills are not documentation or best-practice lists.
Back to Podcast Digest
The Missing Primitive for Agent Swarms — Lou Bichard, Ona
TL;DR
Lou Bichard’s definition of a “software factory” is stricter than most — it’s not one engineer juggling parallel coding agents, but “incrementally moving the human out of the loop” so work can flow from planning to production with minimal proactive human interaction.
The real missing primitive for agent swarms is coordination, not runtime or orchestration — Lou says runtimes, triggers, and horizontal scaling are basically solved, but teams still lack a clean way for agents to hand off tasks, track progress, and know when to move through SDLC gates.
GitHub and Linear are the wrong coordination surfaces for autonomous agents — they can hold PRs and tickets, but Lou argues they become painfully noisy when thousands of agent-driven changes, merge conflicts, CI failures, and intervention points pile up.
Owner is betting on VM-based dev environments for serious coding agents — Lou argues containers aren’t a strong enough isolation boundary and can suffer noisy-neighbor issues, while VMs let Owner securely spin up fleets of agents across thousands of repos for jobs like CVE remediation and test coverage improvements.
The SDLC is far messier than the five-box diagram suggests — Lou’s experience building autonomous workflows is that agents get lost in hidden “micro steps,” context rot, and sycophantic shortcut-taking, which is why he frames harness engineering as encoding process back into the repo via agents.md, tests, and context files.
The likely shape of the solution is a workflow/state-machine layer, possibly exposed as a CLI — in Q&A, Lou points to graph-defined workflows, durable execution ideas, and a CLI “gateway” that lets a local or remote agent ask, in effect, “Have I completed this SDLC step, and can I proceed?”
The Breakdown
A stricter definition of the software factory
Lou Bichard, Field CTO at Owner, opens by saying everyone in his orbit is trying to build some version of a software factory — but he immediately narrows the term. For him, it means removing the human from proactively driving the SDLC, not just giving one IC a bunch of parallel copilots and calling it automation.
Swarms, fleets, and events: the patterns showing up now
He walks through three patterns he sees in coding-agent infrastructure: swarms that fan one intent out to many sub-agents and funnel back into one PR, fleets that operate across many repos, and event-driven agents triggered by webhooks like a PR or Linear ticket. He name-checks Stripe’s “minions” and Ramp’s “inspect” as proof that large companies are already wiring agents into internal systems to drive thousands of PRs.
Owner’s pitch: fleets of dev environments, not just chat agents
Owner has spent six years on dev environment infrastructure, and Lou frames its current agent work as a natural extension of that base. The standout capability is “fleet”: scheduled or triggered agents that spin up across huge repo surfaces for tasks like CVE remediation, enforcing standards, or improving test coverage — simple work per repo, but brutally hard at organizational scale.
Harness engineering as context engineering with teeth
Lou gives a practical definition of harness engineering: all the repo-level artifacts that help an agent stay on the rails, from skills and agents.md to tests and scripts. His mental model is very iterative — let the agent run, watch where it gets lost, then encode that lesson back into the repository so the next run makes it further through the factory.
Why Owner wants VMs, not containers, for serious agent work
At the infrastructure layer, Lou says runtime is mostly solved, but he’s opinionated about what the runtime should be. For real development tasks, he argues, agents need VM-level isolation because containers aren’t a bulletproof security boundary and can get hit by noisy-neighbor compute contention on Kubernetes.
The demo: what a swarm actually looks like in practice
To make the talk less theoretical, he shows Owner running two flavors of sub-agent workflows: one where a parent agent inside a VM launches process-level sub-agents, and another where the parent can create many entirely separate VMs. The UX challenge becomes obvious in the demo — once agents are spinning up, messaging each other, and collapsing back down at completion, the hard part is no longer raw execution but helping humans understand and steer the swarm.
The hard truth: agents don’t understand the neat five-step SDLC
Lou says the big lesson from trying to build a software factory himself is that the SDLC diagram lies by omission. Planning, coding, testing, and shipping each hide lots of “micro steps,” and agents routinely fail because they lose context, skip steps, or take sycophantic shortcuts just to appear done.
The missing primitive: a real coordination layer
This is his core thesis: GitHub is not a coordination layer for agents, and neither is Linear, even if systems like Symphony build on top of it. In the Q&A, he sketches possible fixes — workflow/state-machine systems, durable execution ideas, and especially a CLI-based interface that lets agents locally or remotely check whether they’ve completed a step and can advance — while admitting the standards are still nascent and unsettled.
Share
Keep Reading
Two Ways to Follow
The Weekly Echo. The inbox-shaped summary of what mattered.
New editorials announced here.
