Ya’ll just have Opus generate a petrinet . Ask it to verify it’s properties. And then use stochastic analysis over the net to guess token cost. Then guide to the cheapest net to implement your feature.
Here's the multi-agent system driving our software factory right now. Core pieces:
- We say what to build (sometimes Linear issues, mostly Slack threads)
- Triage agent researches and decides whether to implement or to ask questions (think /grill-me but smarter)
- Implementation agent builds, maybe collaborating with us on a spec with a subagent first
- Verification subagent tests the implementation agent's work e2e
- Code review agent cycles with the implementation agent for a few rounds before human review
- Human reviews and ships
- Monitoring automation responds to alerts and files issues (our first step to closing the factory loop)
There's room to simplify this. We're benchmarking whether we need separate agents for steps like triage vs. implementation, or if a single high-intelligence model can do most of it. The core loop remains the same though.
Curious how this compares to factories others are deploying

ALT A flowchart of an agent-driven software factory loop. A new task or issue goes to a triage agent, which routes it four ways: automatable (straight to implementation), needs specs (spec agent, then human spec review, looping back for revisions until approved, then implementation), needs human clarification (human input, then triage again), or park for now. After implementation, agents handle code review and verification. A human then reviews the code and verification output and decides if it's ready to ship. If not, it goes back to code review. If approved, it goes through CI/CD and ships. A monitoring agent then checks for issues: if one is found, a new issue is created and the factory loop starts over; if not, monitoring continues.