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
Last updated
Built on tools you already own, and get to keep
- Claude Code
- Codex
- Linear
- GitHub
- Sentry
- Langfuse
Claude Code
Codex
Linear
GitHub
Sentry
LangfuseTwo ways to start
Bring a prototype, or bring nothing.
Most of this work starts with something already built and stuck, and it does not have to. When you have a prototype, Appliscale runs a two to three day audit at a fixed fee, prices the rebuild from what the audit finds, and builds the coding-agent pipeline on the rebuilt codebase. When you are starting from scratch there is nothing to audit, so we agree the stack and the boundaries, stand the factory up, and ship the first feature through it.
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.
| Finding | Why it blocks change |
|---|---|
| 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, so smaller and clearer means faster, cheaper, and less likely to break something you did not ask them to touch. Appliscale rebuilds it around an atlas agents read first, a predictable structure with one obvious place for every kind of change, and proven libraries instead of primitives rewritten from scratch. We keep the codebase and its documents small, because every file is context somebody has to load, and we engineer tests the pipeline forces every agent to work against.
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.
You write the spec with the AI you already use, and an agent checks, sizes and costs it before anything gets built. Appliscale's pipeline then builds in an isolated sandbox against the contract, has a second model review the result on a different prompt, and stops at your two gates: staging, which you click through for real, and release, which you time. After release a monitoring agent watches Sentry, Grafana and Langfuse and files the bug with a fix already drafted.
Appliscale engineers watch every stage: constraints, drift, cost per ticket, and stuck sandboxes.
01
You
Spec
Written with the AI you already use.
02
Agent
Size
Checked, sized and costed.
03
Agent
Build
Isolated sandbox. Tests against the contract.
04
Agent
Review
A second model, a different prompt.
05
You
Staging
Your gate. Click through it for real.
06
You
Release
Your gate. You pick the moment.
07
Agent
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, so these merge gates are not advisory: an agent cannot merge until all of them pass, and Appliscale engineers own the list. Every change is tested against the spec by contract tests, reviewed by a second model running a different prompt, and checked for a second copy of logic that already exists. A security scan covers dependencies, secrets and inputs, and a token budget stops runaway tasks instead of billing them.
The question is not "can an agent write this?" It is "what has to be true before it merges?"
Merge gates
EnforcedContract tests
Behaviour tested against the spec
Review agents
A second model, a different prompt
Duplication
No second copy of existing logic
Security scan
Dependencies, secrets and inputs
Token budget
Runaway tasks stopped, not billed
Who does what
You decide. Agents build. We keep it maintainable.
Your team writes the specs, sets the priorities and approves the releases. The agents build in a sandbox, write the tests and review each other, and Appliscale holds the constraints: architecture and drift, the constraint list, cost and incidents, and any agent or sandbox that gets stuck. Two of those three columns are not headcount, which 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 and your issue tracker. There is no platform to rent and no seat to lose access to: the repository, the infrastructure and the prompts live in your accounts from the first commit, and any part of the harness or the model behind it can be swapped, including open-weight models on hardware you own. If you stop working with Appliscale tomorrow, the pipeline keeps shipping.
Your IP from the first commit
Repo, infrastructure and prompts live in your accounts, never ours.
Swap any part of it
Harnesses and models change every quarter, including running open-weight models on your own hardware.
Priced against tokens, not headcount
We tune for the cheapest model that still clears every gate.
How an engagement runs
Four stages, from audit to handover.
An engagement runs in four stages. Appliscale audits the prototype and tells you what a rebuild actually costs, bootstraps the rebuilt codebase and the pipeline inside your own accounts, trains your product engineers to write specs the agents can build from, and then maintains it, watching quality, drift and spend and stepping in when agents cannot. Your issue tracker, your GitHub and your cloud account throughout, and we hand you the keys.
01
Audit
We read the prototype and tell you what a rebuild actually costs.
Output: scope, fixed price, go or no-go
02
Bootstrap
Rebuild the codebase and stand the pipeline up in your accounts.
Output: a working factory in your cloud
03
Onboarding
Train your product engineers to write specs the agents can build from.
Output: your team running it
04
Maintenance
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. Appliscale charges fixed hours plus the tokens at cost, which makes the cheapest run that still clears every gate good for us too, and every ticket carries its own token spend and wall-clock time so you can open the log and check that we meant it. We run the same harnesses against Arctus, our own reporting product, we deploy into your AWS, GCP or Vercel account as an AWS Advanced Tier Services Partner, and the engineers holding your architecture have run real-time bidding at 500,000 requests per second.
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.
- AWS Services
- Clerk (authentication)
- LangChain
- Next.js
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.