Introducing the Yaju Software Factory: from backlog to pull request

Every engineering team has the same quiet pile. Not the interesting work, and not the urgent work either: the tickets that are clear, small, and never quite worth a sprint. The dependency bump that touches forty files. The endpoint that needs the same validation as the other six. The test nobody wrote because the feature shipped on a Friday.

That pile is where the Software Factory starts.

What it actually does

You point it at a backlog item. It reads the issue, reads the codebase around it, makes a plan, writes the change, runs the tests, and opens a pull request with a description of what it did and why. A person reviews that pull request exactly as they would review a colleague's.

That last sentence is the whole design. The Software Factory does not merge. It does not decide that a failing test is acceptable. It does not quietly widen its own scope from the ticket it was given. It produces something for a human to judge, and then it stops.

Why it sits on the Agent Orchestration System

We could have shipped this as a standalone tool. Plenty of them exist, and most of them demo beautifully. The problem shows up in week three, when you have forty of these running across six teams and nobody can answer three questions: what did they change, what did they cost, and who is responsible for the one that just touched the billing service.

Building on the Agent Orchestration System means those questions already have answers. Every run the Software Factory makes is an agent run like any other, which means it inherits the things we spent three generations building:

• Spend attributed per agent, reported in currency rather than tokens, so a team can see what its backlog automation actually costs per merged change.
• Budgets that stop an overrun while it is happening, with a warning as the limit approaches and a hard block when it is reached.
• Policy enforced at the moment of action, so an agent that should never touch production credentials cannot touch them, regardless of what the plan said.
• Evals on every run, scoring the output against behavioural, structural, latency and cost criteria, and halting the run when a check fails.
• A full audit trail, so the answer to "why did this change happen" is a record rather than a reconstruction.

None of that is a feature of the Software Factory. It is a feature of the platform underneath it, and that is the point.

The part people underestimate

The hard problem in automated code generation was never generating the code. Models have been able to write a plausible function for a while now. The hard problem is everything that surrounds the generation: knowing which ticket is safe to hand over, keeping the agent inside the boundary you set, catching the change that is technically correct and contextually wrong, and being able to prove afterwards what happened.

Teams that skip that part get a fast start and a slow year. The output arrives quickly, and then someone has to read all of it very carefully, forever, because there is no systematic reason to trust any particular run more than any other. Evals are what turn that into a manageable process. When every run is scored against criteria you defined, review stops being uniform suspicion and starts being triage.

Starting small, on purpose

The teams getting the most out of it are not the ones who pointed it at their entire backlog on day one. They picked one category of work that was well-specified and low-stakes, ran it there until the eval scores were boring, and then widened the boundary.

That is slower than the demo suggests. It is also the only version we have seen hold up past the first month.

Where it runs

The Software Factory runs wherever the rest of your Yaju deployment runs. If your code cannot leave your infrastructure, it runs self-hosted, in your own cloud or fully air-gapped, with the same governance applied to every agent. Credentials resolve at runtime from the org-level vault, so the agent never sees a secret in clear text and you never have a key living in a config file.

Try it

The Software Factory is available now. If you want to see it against your own backlog rather than a sample repository, book a demo and we will walk through it with your code and your constraints. If you would rather read first, the Agent Orchestration System pages cover the governance, cost and evaluation layers it is built on.