My view of where software and agentic development are heading. Until now we’ve used AI as an assistant, like pair programming with it, but with the latest models, Fable, Astra, it’s starting to become possible to take agentic code to production without causing problems. With Fable I realized it’s the first model capable of writing code where I really wouldn’t change anything.
Until now, I could always improve something: over-engineering, too many tests, overcomplicated solutions, there was always something to pick at in its PRs. With Fable that doesn’t happen to me, it’s a model that can code like a senior. It is, however, extremely expensive; if you had to pay API prices, it would be cheaper to hire a senior developer for your project.
With Sol it’s different. Its code isn’t as clean and good, but if you have a problem and you specify the exit condition in the prompt, for example “search until you find the problem”, it won’t stop until it finds it, no matter how many tokens or hours it takes. It’s a really useful tool and you can clearly see the difference in agentic level compared to previous versions. Before, you had to say “continue”, “do it”; that’s over. They’re much more autonomous: they’ll solve it, test it, create the commit, the branch, the PR, and even wait for comments from the review bots on the PR. We’re reaching a level of autonomy and quality in frontier models that unlocks new horizons, in this case the viability of Software Factories.
Many people are mentally stuck on what models could do a few months ago, like an Opus 4.5, or less intelligent models like a Luna. Overly complex code, wrong claims, no real confidence to deploy that code to production. That makes you delegate less, because you don’t know how to take advantage of the capabilities of frontier models.
One of my projects is a software factory. It’s the way I found to deal with the bottleneck and lack of organization I have with my ideas.
My goal is to be able to offload my ideas, organize them into projects and have agents help me research and develop them.
My idea of a software factory isn’t very different from conventional software development, but it tries to progressively delegate parts to autonomous systems.
The project is currently in development, but I’m already using it through dogfooding (it’s developing itself). It’s not open source, although maybe I’ll make it so at some point, since every time I build something that moves “at the frontier” of current development, similar projects end up coming out within weeks. In the end, there are a lot of us building right now, having similar ideas, although each one has their own particular way of solving each problem.
In this project you have to know very well where to keep the human in the loop and where to replace it, since human judgment will always make the project better.
One thing I learned from my previous Agent Orchestration Platform is to delegate, and not to build myself what already exists and I can reuse. The most important case is agent management. There are a thousand different ways to do this; the one I like best is taking advantage of the harnesses already installed on the machine, so you reuse their implementation of subagents, skills… and on top of that, as they update them, you get those new features. But there’s more: in my previous project, the connector between those harnesses and the project’s threads, which in that case were kanban tasks, was custom and I had to maintain it. This time I’ve reused the T3 Code connector, open source and with a license that allows this use. In fact, I’m using an idea from its creator that I imagine will gain more traction in the future: using patches in markdown format, which let the agent modify a future version and leave it with your changes.
So I can also delegate maintenance of the connector between the software factory and the model to the T3 team.
Another important point is where those agents run, and this is really cool, because they don’t run on your local machine; instead, they have one or several full machines available.
I connect each machine to the BE so I can manage where I want each thread to run. I also include features like harness updates, account management with CLIProxyAPI, skill and MCP management, and even syncing between different machines. This allows things like spinning up agents from a phone on a Linux machine with lots of cores and RAM so they can work.
Once this whole system is set up, how do I get a project into the agentic loop?
If it’s an idea that doesn’t have a project started yet, I create a thread in the ideas section, where I drop a small proposal, and the agent itself, using the MCP, creates a project in the Software Factory, creates a GitHub repository that it assigns to the project and creates the initial Schedules it sees fit.
Schedules are one of the ways I currently have to trigger new Threads; other projects call them heartbeats. They’re used so your agent “is proactive”. In the research and planning phase, I use them to find competitors, similarities, synergies, related papers, similar projects, related social media content. It’s important to try different models, skills, synonyms, to look for creativity.
Everything they find is managed from the Documents section through the MCP. I didn’t want them to have to make commits to store research documents, so I created that section, and agents can create or edit documents, even at the same time. It also creates snapshots to recover from if any problem happens.
With this I have a way to offload the ideas I have in my head, things I’d like to exist, problems I see and possible solutions.
Once the Software Factory has it, we’re a team.
Design and development deserve a whole other post, but right now it’s about using frontier models with high agentic capabilities to be able to delegate with enough confidence to merge code that agents have written and reviewed with barely any human intervention. With enough risk management, you can let them merge on their own once all the checks pass.
This is achieved partly with good anti-regression tests, automated QA and AI reviews on every PR.
But in the agentic world another factor comes in: being able to respond automatically to possible regressions and deployed problems. By monitoring all errors and feedback we get that shield, being able to revert or apply automatic patches while taking into account affected users and risk management.
All of this is achieved with Triggers that launch Threads on machines connected to the factory.
Once a project has been developed, we can keep collecting feedback and running A/B tests automatically, with agents relying on telemetry, discovering what can be improved and iterating on what they learn. The goal would be for each step forward not to depend on me sitting down again to tell it what the next step is.
I want to keep contributing ideas and direction, but I also want the factory to have enough information to make decisions on its own. And to look outward: trends, conversations on social media and changes that could open up new possibilities for the project.
Another cool thing is that the software factory is multiplayer. It supports organizations, and you can see your organization’s Projects/Threads/Documents/Machines, so more humans can help you move projects forward.
I think in a while we’re going to see several tools like this.
A while ago, before AI existed, I worked on my ideas at a veeery slow pace and they just kept piling up in a notebook indefinitely. I thought about hiring a programmer, paying them half my salary and at least having someone to help me with my ideas. Today, thanks to AI and Software Factories, I can have exactly that but MUCH cheaper. So a $200 subscription is only expensive depending on what you compare it to.