This week’s ‘Works on My Machine’ explores a pattern that leans into the “Waste Inferences!” concept I’ve shared in the past and asks the question: what if we just trigger multiple AI attempts automatically from our project management tool and just pick the best result? Inspired by Steve Yegge’s thoughts on Agent Clusters/Fleets in Revenge of The Junior Developer, this experiment connects Asana directly to the Aider coding agent via a Sublayer agent.
This demo showcases an automated workflow triggered entirely by assigning an Asana task:
A bug exists in a simple Rails Todo app, tracked as a task in Asana.
We assign the task to our designated “BugfixAgent” user in Asana.
A running Sublayer BugMonitorAgent (code below!) detects this assignment via an AsanaAssignedToAgentTrigger.
The agent takes a step: it fetches the task details (title, description) from Asana.
It then scripts the Aider coding agent, instructing it to fix the bug based on the task info.
Crucially, the agent runs Aider three separate times using the exact same prompt but targeting different powerful LLMs: GPT-4o, Claude 3.5 Sonnet, and Gemini 2.0 Flash.
Each Aider run operates in its own Git branch, applying the changes and running tests.
The result: Three distinct PRs are automatically created on GitHub, each representing one LLM’s attempt to fix the bug
This experiment highlights a few key things relevant today:
Agent Clusters are Accessible: While Yegge places Agent Clusters/Fleets in late 2025/2026, this simple setup demonstrates a basic form available now. We’re not coordinating deeply, but we are leveraging multiple “minds” on one problem.
“Wasting Inferences” is Cheap: The core idea from my previous post holds up surprisingly well here. Running three separate attempts with powerful models cost basically nothing for this simple bug - less than 10 cents! If we continue to see the costs of models of this scale fall by by 90% again, not only will parallel attempts be economically feasible, but they could become the standard way we get a high success rate when working with LLM-based agents.
Redundancy & Comparison: Even if one model fails or produces a suboptimal fix (which happened!), others might succeed. You also get to compare different valid approaches (like Claude and GPT-4o in the video). This can be valuable learning or provide options.
Automation Potential: The entire bug-fixing attempt happened automatically, “out of band” from my direct workflow, triggered solely by an Asana assignment. It transforms a manual coding task into a background process initiated by standard project management workflows. The idea of manually “driving” these AI agents with chat seems to me like it wont be a thing much longer…
While this demo used a simple bug and app, the low cost and automation potential suggest this “Waste Inferences” / Agent Cluster approach could absolutely scale to more complex scenarios especially as models and tooling improve. It shows us that we can and should actually experiment with these future workflows today because they’re closer than we think.
The “Buggy Todo App” is available at sublayerapp/buggy_todo_app but the code for the agent that interacts with Asana and Aider is in the bugfix_agent/agents/bug_monitor_agent.rb file.
We also heavily relied on the open-source Aider coding agent: https://aider.chat
The agent framework and Asana trigger use the Sublayer Rubygem, an agent framework designed to make it easy to build your own AI powered devtools.
I’d love to know what you think of this multi-LLM, “wasteful” approach to automated coding. Even I was surprised at how cheap it ended up being. If you get a chance to try this out or have been playing around with ideas like this on your own, I’d love to chat and hear how it’s going for you!