Why We Need a Purpose Driven Agent Based Developer Management Platform
This post is a summary of my QConSF talk and some thoughts on what could come next, refined in a discussion with ChatGPT after getting it to read my presentation. The text below was mostly written by ChatGPT based on my input, with light edits — Adrian.
We’ve been here before.
A decade ago, cloud platforms changed the way we operated software. They standardized architecture, enforced guardrails, embedded security, simplified deployments, and automated the operational work that used to consume entire teams. When I asked in my QConSF talk whether anyone remembered waiting months for servers, it got a laugh — but it was a reminder of how profoundly platform engineering reshaped the industry.
Today, we’re at the beginning of a similar shift, except this time it’s happening on the development side. Autonomous coding agents are emerging not as sidekicks but as extremely capable contributors. In my talk, I showed how a swarm of coordinated agents could complete several days of work in under 15 minutes, how they can port code across languages, build data pipelines, implement BDD test suites, generate UX guidelines, and push everything to GitHub inside a Codespace.
But these agents don’t behave like developers in the traditional sense. They behave more like fast but forgetful engineers who need constant direction. You have to remind them of architectural boundaries. You have to point out when tests were skipped. You have to stop them from merging monolithic “ball-of-mud” structures just because it was easier. You have to nudge them to tidy up, refactor, update docs, archive outdated files, or simply keep going until the entire task is complete.
The surprising insight from working with agent swarms is that the problem isn’t writing code. They do that extremely well.
The bottleneck is managing them.
And that is where the next major platform shift needs to happen.
Just as the people that used to be in Ops teams are now in SRE and DevOps teams running cloud automation, we will end up redeploying developers from building business logic, to building the agent based platform that delivers business logic. That platform and best practices for development are changing every month, and the platform will be rebuilding itself continuously.
The Cloud Automated Ops. Now We Need a Platform That Automates Developer Management.
If cloud platforms automated Ops by embodying best practices in infrastructure, guardrails, deployment, and security, then the next evolution is a platform that automates developer management for autonomous agents.
Ensuring tests are always run and always pass, guiding decomposition into microservices rather than monoliths, enforcing policies, quality, and architecture, validating compatibility across languages, coordinating long sequences of work, and maintaining context over time.
This isn’t “Developer work.” It’s management work.
And because the agents are non-human — fast, parallel, technically competent, but lacking intuition for quality, safety, architecture, or purpose — the management burden becomes the new bottleneck.
So while the cloud gave us a way to eliminate operational toil, what we need now is an AI-native development platform that eliminates the new category of developer-management toil.
I call this the NoMan concept:
The human director sets the purpose that the system is intended to perform and the constraints it has to work within. Then the platform performs the development team management function.
What follows is a proposal for what that platform could look like.
Pourpoise: A Purpose-Driven Platform for Autonomous Development
Pourpoise is an open-source proposal for a platform that embodies the principles, policies, and systemic structures required to manage autonomous coding agents. Not manage their tasks — manage their behavior, their boundaries, their interpretations of intent, and ultimately the emergent purpose of the system they build.
This pulls directly from systems thinking. A system’s true purpose is not what it claims; it’s what its behavior reveals. Purpose emerges from structure and feedback loops. If we want AI agents to produce systems that behave correctly, then we need to engineer the structure that guides that behavior.
Pourpoise does this in several interlocking ways.
First, it encodes purpose explicitly: the intent behind the system, the boundaries that shape it, the constraints that protect it, and the criteria that determine whether a component is fit for purpose. Instead of burying this intent in tribal knowledge, Pourpoise makes it a formal input that agents must satisfy.
Second, it enforces policy and guardrails so that agents behave predictably. This isn’t old-school linting or code review; it’s architectural constraint, dependency governance, documentation structure, and security boundaries — the sorts of guidelines that good engineering managers and principal engineers enforce.
Third, it provides structured problem-decomposition patterns, so agents don’t attempt to build a complete system in a single file or a nested tangle of functions. Microservice boundaries become first-class objects. Work is scoped intentionally. Architectural separation is enforced rather than hoped for.
Fourth, Pourpoise treats each microservice as its own purpose domain with local intent, local correctness criteria, and local tests — an approach learned from years of microservice practice and now essential for enabling agent teams to work safely in parallel.
Finally, Pourpoise anchors everything in hypothesis-driven correctness. Every service has a purpose hypothesis. Tests validate that hypothesis. Continuous evaluation detects purpose drift. And agents iterate until the system behaves as intended.
This collection of mechanisms creates a feedback-controlled environment — a cybernetic system — in which autonomous agents collaborate safely at high speed.
Why Pourpoise?
The name reflects the heart of the platform.
Agents are non-human, highly intelligent contributors, much like the porpoises that inspired the name. Pourpoise “pours” purpose into the system, shaping the structures and behaviors that emerge downstream. It is a playful name, but it also captures the seriousness of embedding purpose-driven architecture into the foundation of AI-native development.
And critically, “Pourpoise” is distinct and unclaimed — a clean namespace for a new category of developer platform.
Toward a NoMan Future
We’re still early in agentic development. Today’s tools require too much supervision, too much prompting, too much manual correction. But that’s exactly how early cloud development felt. We built DevOps, SRE, and platform engineering disciplines precisely because we needed systemic solutions.
Now we need the same for autonomous development.
Pourpoise is a proposal for the open-source community to build that next-generation platform — a platform that performs the work of developer management, freeing humans to focus on direction, creativity, and product vision while agents handle the implementation within a purpose-driven system.
If you’re thinking about AI swarms, development orchestration, agent platform engineering, or systems thinking applied to AI, I’d love to collaborate. Does this proposal make sense, does it already exist in some form, is it really needed, and could it be made to work?
