Solutions
We build agentic software factories.
Whether you have a vibecoded prototype or an empty repository, we build the codebase and the coding-agent pipeline that ships it. You own all of it.
You own the stack · Audit in 2–3 days · No vendor lock-in
Built on tools you already own, and get to keep
Two ways to start
Bring a prototype, or bring nothing.
Most of this work starts with something already built and stuck. It does not have to.
You have a prototype
It works, customers are using it, and every change has become slow and risky.
01
Audit
Two to three days, fixed fee
02
Rebuild
Fixed price from the audit
03
Pipeline
Built on the rebuilt codebase
You are starting from scratch
An idea, a spec, and nothing written yet. There is no audit to run, so we skip it.
01
Architecture
Stack and boundaries agreed
02
Factory
Built before the first feature
03
Feature one
Ships through the pipeline
What the audit finds
A vibecoded prototype is unmaintainable.
AI-built prototypes fail the same ways, because the tools take the same shortcuts. Two or three days finds all of it and prices the fix.
- Dead code
- Half-built features nobody deletes.
- Tests that assert nothing
- Green suite. Mocks the thing under test.
- Duplicated logic
- Auth and validation re-derived per file.
- Hand-rolled primitives
- Custom modals and tables instead of libraries.
- No module boundaries
- Everything imports everything.
- Dependency sprawl
- Unpinned, unused, some unmaintained.
- Secrets on the client
- Service keys shipped to the browser.
- Specs written afterwards
- Intent the code never implemented.
- Types that lie
- Shapes that do not match the API.
- Queries that die at scale
- No indexes. A round trip per loop.
What we build instead
We rebuild it so agents can maintain it.
Agents read the codebase to make one change. Smaller and clearer means faster, cheaper, and less likely to break something you did not ask them to touch.
An atlas for agents
A map of the codebase that agents read first, so they navigate it instead of guessing at it.
A structure you can predict
One obvious place for every kind of change, so a feature lands where the next person expects it.
Proven libraries
Widely used components and frameworks, instead of primitives rewritten from scratch each time.
The smallest codebase that works
Every file is context somebody has to load. Less code is cheaper to change and cheaper to run.
No document bloat
No sprawling design files that fill the context window and starve the task you actually asked for.
Tests agents cannot skip
Tests engineered to mean something, and a pipeline that forces every agent to work against them.
The pipeline
Agents build it. You approve it twice.
Appliscale engineers watch every stage: constraints, drift, cost per ticket, and stuck sandboxes.
Spec
Written with the AI you already use.
Size
Checked, sized and costed.
Build
Isolated sandbox. Tests against the contract.
Review
A second model, a different prompt.
Staging
Your gate. Click through it for real.
Release
Your gate. You pick the moment.
Monitor
Sentry, Grafana and Langfuse watched. An agent files the bug with a fix already drafted.
Bugs re-enter as specs with a fix already drafted. Nothing skips the gates on the way back.
Quality control
Every change passes the same checks.
Speed without constraints produces a codebase nobody can touch in six months. These gates are not advisory. An agent cannot merge until all of them pass, and our engineers own the list.
The question is not "can an agent write this?" It is "what has to be true before it merges?"
Merge gates
Enforced- Contract testsBehaviour tested against the spec
- Review agentsA second model, a different prompt
- DuplicationNo second copy of existing logic
- Security scanDependencies, secrets and inputs
- Token budgetRunaway tasks stopped, not billed
Who does what
You decide. Agents build. We keep it maintainable.
Two of these three columns are not headcount. That is why a small team can carry a real product.
Your team
Decides
- Write the specs
- Set the priorities
- Approve the releases
The agents
Execute
- Build in a sandbox
- Write the tests
- Review each other
Appliscale
Constrain
- Architecture and drift
- The constraint list
- Cost and incidents
- Stuck agents and sandboxes
Ownership
You own the factory from day one.
Agents run in your repo, your cloud, your issue tracker. There is no platform to rent and no seat to lose access to. If you stop working with us tomorrow, the pipeline keeps shipping.
- Your IP from the first commitRepo, infrastructure and prompts live in your accounts, never ours.
- Swap any part of itHarnesses and models change every quarter, including running open-weight models on your own hardware.
- Priced against tokens, not headcountWe tune for the cheapest model that still clears every gate.
How an engagement runs
Four stages, from audit to handover.
01Audit
We read the prototype and tell you what a rebuild actually costs.
Output: scope, fixed price, go or no-go
02Bootstrap
Rebuild the codebase and stand the pipeline up in your accounts.
Output: a working factory in your cloud
03Onboarding
Train your product engineers to write specs the agents can build from.
Output: your team running it
04Maintenance
We watch quality, drift and spend, and step in when agents cannot.
Output: fixed hours plus token cost
Each phase has a stop condition. If the audit says a rebuild is the wrong move, we say so, and you have paid for three days instead of a project.
Why Appliscale
We are not paid by the token.
Model providers bill per token, so more code and bigger models are good for them. We charge fixed hours plus the tokens at cost, so the cheapest run that still clears every gate is good for us too.
We run it on our own product
Claude Code, Codex and Cursor run against Arctus, our own reporting product, every day. A harness regression shows up in our codebase before it reaches yours.
You see the cost of every ticket
Each task carries its token spend and wall-clock time. A field rename does not get a frontier model, and you can open the log and check that we meant it.
Your cloud account, not ours
AWS Advanced Tier Services Partner. We deploy into your AWS, GCP, Vercel or your own datacentre, so support paths, credits and billing stay yours the day we stop working together.
Engineers who have carried the pager
The people holding your architecture have run real-time bidding at 500,000 requests per second. When the pipeline cannot fix something, they are who fixes it.
Track record
We build agentic systems for a living.
Harmonyze - AI
From contract AI to the coaching command centre for franchise brands
An AI teammate for contract and compliance work that delivered a 10x ROI, and the engineering now behind a coaching platform for franchise brands.
AI powered scalability
Automated data conversion to scale elite CrossFit programming
Reduced training plan creation time by automating freeform-to-structured data conversion, unlocking scalability for elite CrossFit programming
Cloud-Native Acceleration
Production-grade MVP of StarOps in customer pilots within months
Delivered a production-grade MVP of StarOps in customer pilots within months, without requiring the client to build a large in-house platform team.
Frequently asked questions
Questions founders ask first.
Clear answers before a discovery call.
What does an agentic software factory cost?
Four stages, priced separately. The audit is a fixed fee for two to three days. The bootstrap is a fixed price set by three things: whether we are rewriting a prototype or starting clean, whether we set up the cloud account, and how many custom integrations you need. Onboarding is training for your team. Maintenance is a monthly retainer of Appliscale engineering hours plus the tokens your agents spend, at cost.
Do we still need to hire engineers?
You need a small number of product engineers who understand your business and can specify how the product should behave. You do not need a DevOps engineer, a QA team, a scrum master and a project manager before you have a product. Appliscale covers architecture, pipeline maintenance and troubleshooting on a retainer.
Can we run this without sending code to model providers?
Yes. We can run open-weight models on hardware you control, so no source leaves your network. Most teams start on frontier APIs for speed and move sensitive repositories onto self-hosted models once the pipeline is stable.
What happens when an agent ships a bug?
Nothing reaches production without two human approvals, one before staging and one before release. When something still slips through, Sentry catches it, a monitoring agent files the ticket with the stack trace, and the fix enters the same pipeline. Our engineers step in when the pipeline itself is the problem.
Can we run this without Appliscale?
Yes, and that is the point. The repository, the infrastructure, the prompts and the pipeline configuration live in your accounts from the first commit. Ending the retainer costs you our engineering hours, not your ability to ship.
Start with an audit
Send us your prototype.
Two to three days, a fixed fee, and a written scope with a price at the end of it. If the answer is that you should not rebuild it, we will tell you that instead.