uBuild
Your own development pipeline, staffed by AI agents.
uBuild gives you your own environment in our development pipeline. You describe what needs to be built, AI agents design, build and review it, and you approve at every step. Whatever passes review lands as a pull request in your own repository.
Part of the development pipeline
One development pipeline, three ways to use it. The difference is who does the work and what you end up with.
Website in 48 hours
We buildYou describe what you want, we deliver a complete and secure website.
uCompose
You manageYou keep that website up to date yourself by typing, in plain language, what needs to change.
uBuild
You are hereYou build software in your own environment. AI agents do the work, you approve every step.
How it works
How a feature comes about
Every assignment runs through the same fixed sequence. Between the phases there is always an approval moment, so a run never moves on to the next piece of work unseen.
The assignment
YouIn about one page you describe what needs to be built: the behaviour you want, the acceptance criteria, and what is explicitly out of scope. We help sharpen that assignment, because a sharp assignment determines the result.
Design
ArchitectThe architect reads the assignment, decides on the approach, and splits the work into packages that can be built independently.
Your approvalApprove, give feedback or stopBuilding
BuildersOne or more builders carry out the packages. In parallel when the parts are genuinely separate, and neatly in sequence when they are not.
Your approvalApprove, give feedback or stopReview
ReviewerThe reviewer tests the result against the acceptance criteria from your assignment and sends back whatever does not hold up, exactly as a colleague would.
Your approvalApprove, give feedback or stopPull request
YouWhatever passes review lands as a pull request in your repository, with the full history attached. Merging and releasing stays your decision.
A complete development process, without building one yourself
Having AI write software is the easy part. The hard part is everything around it: version control, reviews, test and production environments, a deployment process, and someone who says no in time. With uBuild all of that is ready from your first assignment.
What makes uBuild different
Everyone has the technology to generate code by now. The difference sits in what surrounds it.
A human in the loop
Every phase ends with you: approve, give feedback, or stop. Choose feedback and the same agent continues with your comments included. It is the most powerful steering instrument you have, and it saves a lot of starting over.
Roles instead of one all-rounder
An architect splits the work, builders carry it out, and a reviewer tests the result. The same separation a good development team applies, because the builder is never the best judge of their own work.
Governance is not optional
Changes arrive as a pull request under a dedicated service account, with mandatory review before anything can reach production. There is no route by which an agent writes straight into production.
Our standards built in
The agents work to the standards we apply ourselves: naming, security checks, permission verification and logging. That knowledge sits in the pipeline, not in the head of one developer.
Cost visible per step
You see what a run costs per phase, while it runs. Not an open-ended bill of hours afterwards, but an amount per piece of work you can steer on during the project.
Everything stays yours
The code, the history and the environment belong to your organisation. Under the bonnet it is plain git, so you are not locked in and you take everything with you if you leave.
Part of the development pipeline
uBuild and uCompose come from the same pipeline
uCompose is for websites and portals you then manage yourself. uBuild is for applications and integrations that no off-the-shelf product covers. They run on the same development pipeline and the same infrastructure.
See the development pipelineCurious whether your idea fits?
Book a one-hour introduction. Together we look at what you want to build, whether it suits a short first assignment, and roughly what it will cost.
Cost
What it costs
We deliberately quote no amounts here, because they move with how much you build. What we can explain is what the bill consists of, so you know what you are steering on.
Access to your environment
A fixed amount per month for your own environment in the development pipeline, including the development and test environments that come with it.
Consumption per run
What the agents actually execute is billed per run. You see it back per phase while the run is going, so an outlier shows up before it reaches the invoice.
Hosting what you build
Whatever goes live runs on European Azure infrastructure. Those costs depend on what the application does and are separate from the building itself.
The comparison most customers make is not uBuild against a cheaper platform, but uBuild against the day rate of a development team. That is where the difference sits, and it is why we would rather work it through for your specific plan in an introductory conversation than put a starting price on this page.
Who may do what in your environment
Permissions are set per person. The principle: anyone may propose work, but approving and releasing is done only by the people you designate.
| Role | Submit assignment | Start a run | Approve a phase | To production |
|---|---|---|---|---|
| Requester | ||||
| Builder | ||||
| Owner |
Frequently asked questions
Not to submit an assignment. Technical knowledge does help when judging the result, which is why most customers have someone with an IT background on the approval moments. If you do not have that in house, we fill that role.
Your organisation does. The repository, the history and everything in it are yours. If you stop using uBuild, you take the code with you and it runs elsewhere without a problem.
In an isolated environment on European Azure infrastructure. Every customer has their own environment; projects from different organisations never touch.
No. Agents work in their own working copy and deliver through a pull request. Only what a human has approved reaches production, along a protected route with mandatory review.
Then you give feedback at the next approval moment instead of approving. The same agent continues with your comments included, so you do not have to start over. Stopping is always an option too.
About one page of description works best: a bounded piece of functionality with clear acceptance criteria. Larger work is split into several assignments, because a sharp scope always produces a better result than a broad one.
Yes. Under the bonnet it is plain git. Your developers clone the repository, make their own commits, and review the agents' pull requests as if they came from a colleague.
Then you stop it. You see what a run costs per phase, so you can weigh up at any moment whether continuing makes sense. That is exactly the difference with a project where the bill only becomes visible afterwards.