Today we’re launching Islo enterprise software factories, backed by $15M from Insight Partners. We started by asking a question that sounds almost too basic to ask: what is a factory actually for?
A factory is a machine for producing trust
We usually describe factories by what comes out of them, but a workshop can build a car too. What a factory adds is the ability to build the same car ten thousand times and know that every single one of them works.
Software engineering has always worked this way, even if we rarely describe it like that. Work enters as a ticket, someone builds it, CI tests it, a reviewer checks it, and it gets released, and every station on that line exists to turn “someone wrote this” into “we can ship this.” Version control, code review, test suites, staging environments and release trains are all inventions for producing trust in change.
For about fifty years the scarce input to that factory was human labor. Writing code was slow and expensive, so we designed the entire system, including our processes, org charts and tooling, around protecting engineers’ time. That assumption just broke.
What happens when labor becomes cheap
Agents can now take real work through several stations of the line on their own: they investigate a bug, write the fix, run the tests and open the PR, and the marginal cost of producing a code change is collapsing toward the cost of compute.
Economists Manuel Trajtenberg and Timothy Bresnahan have a useful way to think about technologies like electricity, semiconductors and AI. They call them general-purpose technologies: they spread across many parts of the economy, keep improving, and make new kinds of innovation worthwhile for the people and companies that adopt them.
That last part is the important one. The value of a general-purpose technology doesn’t live only in the technology itself; it comes from all the complementary changes its users make around it.
The history of factory electrification gives us a model of the transition we’re in the middle of right now. When factories first electrified, many owners removed the steam engine, installed an electric motor in the same place, and left everything else alone. The machines stayed where the old system of shafts and belts required them to be, work moved through the factory in the same way, and the organization kept operating around constraints that electricity had already removed.
The big productivity gains came later, when factories stopped treating electricity as a replacement power source and started redesigning around it. Smaller motors could power individual machines, so the factory could be built around the flow of production rather than the location of a central shaft. This changed the layout, the machinery, the movement of materials, the jobs people performed, and the way the whole organization worked.
This is the lesson for AI. Access to frontier models matters but isn’t enough, just as owning the best electric motor didn’t make a factory productive. When every company can use the same leading models, the advantage comes from how deeply they redesign their work.
The natural first move is to treat AI as a productivity tool and give every engineer an agent, the same way we once gave every engineer an IDE, and that’s where most enterprises are today: one agent on one laptop, paired one-to-one with one human.
The agent on a laptop is an electric motor sitting in the old factory. It is a new kind of power bolted onto a system designed around the old constraints. You can see the limits almost immediately:
- It’s siloed. The agent works inside one engineer’s setup and context, so nothing about how it worked is shared, repeatable or visible to the rest of the team
- It isn’t safe. The same agent decides what to change, how to test it and whether the result is good enough, with no deterministic process enforcing the required checks, verifying the outcome or keeping the work within boundaries the organization controls
- It only works when the human works. Close the lid and the agent stops, which quietly turns the engineer into the scheduler, the babysitter and the bottleneck
- It’s limited by one machine. A handful of cores and one build at a time, so running three agents in parallel just means three agents fighting over the same CPU
Everything other than writing code is now a bottleneck
Every production system has a single constraint that limits its throughput, and if you speed up anything other than that constraint nothing changes, but if you speed up the constraint itself, the constraint simply moves somewhere else.
In software the constraint used to be writing code, which AI agents are removing. So where does it go next? The answer is every station that comes after the code is written: environments that can actually build and run the software, testing that can scale to agent output, code review that can read 50–100× more code than last year, and CI pipelines that can handle both the volume and velocity of pipeline runs now required.
Generating code got cheap, but proving that the code works didn’t. Doing verification is now the scarce resource.
The real barrier is trust, not capability
The models are clearly capable, but the question enterprises are actually grappling with is one of trust.
Trust comes in layers. The engineering organization has to accept that an agent can own a piece of work, the way a new hire eventually does, and nobody gives a new hire production access on their first day. They earn it task by task, through evidence. Then comes security and control, because before a CISO signs off they need clear answers to plain questions about what the agent can reach, which secrets it can see, which actions need a human’s approval, and whether you can reconstruct exactly what happened when something goes wrong.
A smarter model doesn’t answer any of those questions, but a better system does. Trust has never come from the intelligence of the worker; it comes from the process around the worker, and that’s exactly what an enterprise software factory should provide.
What a software factory designed for agents looks like
If you start from those principles instead of from today’s tools, the requirements fall out pretty quickly. Agents need somewhere real to work, because a worker that can’t build the product can’t verify the product. The factory has to outlive any individual worker, because models and agents and harnesses will keep getting better every few months while your process, your policies and what you require to trust a change are assets that actually last. The factory has to encode those processes, policies, requirements and gates.
Engineering teams need to decide which work agents can start, what context they receive, what evidence proves the work is done, which actions require approval, who owns an escalation, and how much agent output a human can realistically supervise. If you multiply code production without redesigning review, testing and decision-making, you haven’t created more throughput. You’ve created a larger queue.
That’s what we’re solving for.
Launching the Islo Enterprise Software Factory
Islo is a platform for running safe software factories, built around three ideas.
Lines: your engineering process, not a one-shot prompt
In Islo you define your engineering process as a Line, where agent stages handle the work that needs judgment and deterministic stages handle the work that should never depend on a model’s judgment, like running the build, executing the test suite or checking that the change compiles on every target. Failures route back to the right stage, risky actions pause for a human, and lines can start from a schedule, a webhook, a Slack message or a new issue.
This is the part I care about most. You write down how your team actually ships software and agents follow that process, which means it stops living in a few senior engineers’ heads and starts living in a system you can inspect, improve and audit.
Machines: real developer environments
Every agent gets its own Machine: a persistent, hardware-isolated environment with the toolchains, services, private dependencies and compute your software actually needs to build and test, rather than a stripped-down sandbox that can run hello world and not much else.
Safety lives in the Machine rather than being bolted onto the agent: network egress is deny-by-default, credentials are injected at the gateway so they never sit inside the environment where an agent could leak them, and every command, file change and network call is logged, so your security team can see what an agent can reach before it runs and replay what it did afterward. And because machines live in the cloud, agents keep working after you log off, with as many running in parallel as the work needs.
Lines and Machines come together in verification. The Line defines the specification, acceptance criteria and checks, while the Machine gives each stage the real project environment it needs to run the software rather than reason about the code in isolation.
Deterministic stages build the application, execute the test suite and inspect its behavior, while review stages compare the implementation and evidence against the original specification. If the evidence doesn’t match, the line routes the work back for another attempt. The result is not just a pull request; it is a change with proof that it matches the spec and actually works.
Model independence: models don’t own processes, they execute tasks
The workers are going to keep changing, and your factory shouldn’t have to change with them. Islo runs Claude Code, Codex and other harnesses. You can choose the model per stage, so you can use a strong reasoning model to plan, a fast one to implement and a different one to review. When a better model ships next quarter, you swap a single stage instead of re-platforming your entire workflow.
To make this possible, every change to the model, harness or prompt needs to be evaluated before it reaches production. Islo runs evals on your own historical tickets inside your real environment, restoring the world to the point when the ticket was created and using stateful fakes for systems like GitHub, Slack and Linear so the agent cannot discover the final answer. We then grade the result, hidden tests, side effects, attempts and cost, giving you evidence that the new setup is better on your real life work rather than on a vendor’s benchmark.
Do all the work that never gets done
Every engineering organization carries a shadow backlog: QA and test coverage, the bugs nobody gets to, legacy refactors, framework and dependency migrations, and documentation. That work isn’t unimportant so much as it’s unaffordable. It loses in every prioritization meeting because human time is scarce and features win. Once labor gets cheap, that calculation flips, and the work that was never worth an engineer’s week becomes very much worth an agent’s afternoon.
It’s also the right place to build trust, since the inputs are clear, the checks are objective and every completed task is pure gain. Start with one repository, build one Line, watch the runs, tighten the environment and the checks, and then add parallelism, more stages and more autonomy as the evidence builds up, at whatever pace your organization is comfortable with.
The goal is not to automate the old process one task at a time; it is to learn what the engineering organization should look like when software labor is no longer scarce.
Teams are already running factories on Islo
Our customers are quickly moving from isolated experiments to Lines that run 24/7, automating recurring engineering work. “The moment I could trust that what came back actually worked and my only job was merging the PR, that was a huge change for us,” says Obert CEO Matan Kleyman.
Rite is using Islo for feature delivery and bug fixing. Incredibuild started with automated PR review, then expanded to bug fixing, feature delivery and CI triage. At ARIMLABS, a small pilot grew into evaluations running 24/7 at roughly half a million executions per day. Alon Gubkin, CEO of Alien, described the shift simply: “Islo proved for me that the dream of having an actual software factory is actually realistic.”
$15M from Insight Partners, and Databricks as a partner
We’re also announcing $15M in funding from Insight Partners, along with a partnership with Databricks to provide inference at scale and secure access to lakehouse data for our customers. Both say something about where this is heading. The companies that understand enterprise software best are betting that the next generation of engineering organizations will run on software factories rather than on one agent per laptop, and that the infrastructure underneath those factories has to be built for trust from day one.
Let’s build!
The electric motor didn’t transform manufacturing by itself. The businesses that redesigned their factories around it did. Software is at that same point right now. The organizations that pull ahead will be the ones that learn how to use agents most deeply, redesign the flow of engineering work around what AI makes possible, and build the environments, verification and controls that let everyone trust the result.
That’s the software factory we want to help you build.
