Self-hosted · your own AI subscription
Agentouch hands a task to an AI coding agent, runs it on your own servers, proves it against your own tests, and gives you back a review request with a live link to the working result. Nothing merges without a person. Nothing leaves your network.
Opened by Linh · Product · 6 minutes ago
fix(checkout): keep the discount code across guest sign-in
Merge request !318 · 2 files · +24 −6
Your test suite passed
t412-k9x2.sbx.your-company.com
Open the working page
6m 12s
Until it was ready to review
$0.21
AI cost for this task
0
Lines of your code sent out
Who this is for
An AI coding tool is bought by the person who signs the invoice, defended by the person who reviews the code, and trusted by the person who promised the date. Agentouch gives each of them something to point at.
CEO · VP Engineering
One dashboard answers the only question that matters at board level: what share of AI-written changes shipped without a single person editing them? Plus cost per shipped change and lead time, sliced by team.
Product owner · Project manager
Every task gets its own running copy of the product at its own URL, with its own database. You open the link and use the feature. No deploy request, no screen share, no waiting for a dev to be free.
Tech lead · Reviewer
By the time the review request appears, your test and lint commands have already run inside the sandbox, and a review pass has left a verdict on the change. You start from evidence instead of from reading.
Agency owner · Compliance
Agentouch installs on your own machine. The repository, the credentials and the containers all stay on your hardware — which is a clause you can put in a contract, not a promise you have to make.
Why this keeps stalling
The hard part was never generating code. It is everything between "the agent finished" and "this is live, and we know it works".
The agent says it is done. Nobody can tell whether it is.
Agentouch only marks a task successful when the change is non-empty and your own verify command passes. When it fails, the agent repairs and retries — twice by default, under a spend ceiling.
Reviewing what the AI wrote costs more than writing it myself.
Each task comes with a live URL running that exact change, against a real database. The reviewer opens it and uses the feature. The diff becomes the second thing they look at, not the first.
The invoice keeps growing. The evidence does not.
Outcomes are recorded per task: merged without edits or not, cost, lead time, which agent and which model. You compare tools on numbers instead of on opinions.
Our contracts forbid uploading client code to a third party.
Nothing to upload. A single binary runs on your server; the control plane sends typed jobs and never receives your code. Every competitor requires the opposite.
We pay for a subscription that only works while someone is at the keyboard.
The agent CLI logs in on your own host and the credential stays in your own volume. The subscription you already pay for keeps working overnight.
We do not dare let an AI near the production repository.
Agentouch never merges by itself. Merge conditions are all off by default, and you switch them on one at a time — green CI, an approving review, a change-size limit, no sensitive paths touched — once you have the numbers to justify it.
How it works
No new process to learn and no new place to work. A task goes in; a review request with a working link comes out.
A single sentence is enough. Agentouch reads the repository and turns it into a proper brief — title, acceptance criteria, the files likely involved, and any question it needs answered before starting.
Plain language. No ticket template, no prompt engineering.
A container on your server clones the repository, runs the agent you chose, and is destroyed afterwards. It holds no git token and no access to Docker, and it can only reach the AI provider and your package registry.
Your hardware, your network, your AI account.
Your own test and lint commands run inside the sandbox. If they fail, the agent reads the failure and fixes it, up to a configured number of attempts and a configured maximum cost. A task that cannot pass does not reach you as "done".
Evidence, not a claim.
A merge request appears with a live URL of the running result. Comment on it and the agent picks the feedback up and pushes again. Agentouch never merges on its own.
The decision stays with a person. Always.
What you get to report
“What percentage of the changes our AI wrote got merged without anyone editing them?”
Almost no tool can answer that, because almost none record it. Agentouch defines it strictly: the commit at merge time has to be the one the run pushed. If a person committed on top — even to apply a suggestion — the task counts as edited.
What you get to report
On the roadmap68%
Merged with no human edit
$0.31
AI cost per shipped change
4h 12m
From request to ready
1,284
Changes shipped this quarter
Merged with no human edit · 6 × 30d
Illustrative figures. This dashboard is specified and not yet built — it is the next thing we are shipping, and we would rather show you the shape of it than pretend it already exists.
The part nobody else has
Every task gets its own running copy of your product, with its own database, at its own address. That is the difference between reviewing code and reviewing software.
Task #412 · the checkout fix, running, with real data
Declare your app and the services it needs — MySQL, Redis, whatever — and each task gets its own containers, its own volumes and its own network. Vite hot reload and WebSockets are proxied through.
Keep it behind your login by default, or make a link public and send it to a client for sign-off. No account needed on their side.
A sandbox sleeps after thirty idle minutes and wakes on the next request. There are system-wide and per-person quotas, and everything is destroyed on a deadline.
Engineers can open a shell into the running sandbox from the browser and read the logs themselves. Every session is recorded: who, which container, which address, and why it ended.
The honest comparison
Devin is a service — you send your repository to them. Agentouch is infrastructure — you install it, and it uses the AI subscription you are already paying for.
Scroll to compare
| The honest comparison | Devin | Copilot Agent | Cursor agent | Codex Cloud | Agentouch |
|---|---|---|---|---|---|
| Self-hosted — your code never leaves | No | No | No | No | Yes |
| Runs on your own AI subscription | No | No | No | No | Yes |
| Swap the agent (Claude, Codex, OpenCode, your own) | No | No | No | No | Yes |
| Live preview URL with a real database, per task | Partly | No | No | No | Yes |
| Browser terminal into the running sandbox | Partly | No | No | No | Yes |
| Merge conditions you configure and audit | No | No | No | No | Yes |
| Reports merged-without-edit rate | No | No | No | No | Roadmap On the roadmap |
| Pool one AI subscription across a team | No | No | No | No | Roadmap On the roadmap |
Trust model
An AI agent is an untrusted process that reads text from your repository, and text from a repository can carry instructions. Agentouch is built so that it does not matter.
Read the full security modelControl plane
Sends typed jobs. Never a shell command. Never receives your code.
Your runner — one Go binary
Clones, runs the agent, verifies, pushes. On your hardware.
Agent container
No git token. No Docker socket. Allow-listed egress.
Sandbox
Live URL, real database, destroyed on a deadline.
The git directory is never mounted into the container · every git command runs with core.hooksPath=/dev/null
Where this goes
Describe the work, run it in an isolated sandbox, prove it against a check, hand a person something to approve, record what happened. None of that is specific to writing code — and it is the part most AI tools skip.
Label an issue in GitHub or GitLab and it becomes a task. Send one line to a Telegram bot and get the review request back the same way. Nobody has to learn a new tool.
Monthly spend limits per project and per person, enforced before a task is queued. Owner, member and viewer roles with a permission for each action.
When a person has to correct a change, the system reads that correction and proposes a rule to remember. An owner approves it, and later tasks start with it.
Borrow a teammate's agent when your own quota runs out mid-sprint. The code comes back as a patch; their secrets and their sandbox never move.
Point an adapter at any OpenAI-compatible endpoint, including one running on your own hardware, and nothing about the pipeline changes.
Runs, steps, logs, terminal sessions, merge decisions and webhook deliveries are all recorded. Not as a feature, as a byproduct of how it is built.
For the engineers in the room
If you are the person who will actually run this, here is what it is: a Laravel control plane, a Go runner daemon on your host, and a console gateway for browser terminals. Jobs are typed. The runner is not trusted.
Fair questions
Often, yes — so we do not ask you to trust it. Your tests run, a review pass gives a verdict, your CI runs, and the merge conditions sit between the agent and your main branch. And we measure the merged-without-edit rate so you know exactly how bad it is for your codebase rather than guessing.
Copy the example environment file and start the stack. You do not need PHP, Composer, Node or MySQL on your machine. Add a project, write a task, press run. The one real prerequisite is a config file in your repository declaring the image and the commands — see the next answer.
This is the honest blocker, not a sales objection. A sandbox needs a small config file declaring the base image, the setup commands and the processes to run. Writing it takes an afternoon for a typical app. Generating it automatically from the repository is the top item on our roadmap, because it is our biggest onboarding cost too.
We agree, which is why every merge condition ships switched off and Agentouch never merges on its own. You turn conditions on one at a time, once you have the data. Production always keeps a manual gate, and the config file itself is always treated as sensitive.
A run times out at an hour. There is a maximum cost per run and a maximum number of repair attempts. The runner heartbeats every thirty seconds, and a container whose runner went quiet is killed after two minutes.
Both are supported through the same abstraction. Nothing in the pipeline changes between them.
Everything from outside — issue text, comments, repository content — is wrapped as data with an instruction not to follow it. Beyond that the containment is structural: the agent container has no git token and no Docker socket, the git directory is never mounted, egress is allow-listed, and read-only runs mount the working tree read-only. The worst case is a wasted run, not a compromised repository.
FAQ
You need either an API key or a logged-in agent CLI. Most teams use the subscription they already pay for — the agent logs in on your own host and the credential stays in your own volume, which is the point.
Nowhere. It is cloned onto your runner, worked on in a container on your runner, and pushed from your runner to your own git provider. The control plane sends typed jobs and reads status from your provider's API; it never receives your source.
Writing a task and opening the preview link, yes — that is most of the value for a product owner. Setting it up the first time is an engineering job: a server, a config file in each repository, and a git token.
The software plus one server you already have or a small VPS, plus whatever your AI provider charges — which is often a subscription you are already paying for. There is no per-seat AI markup, because we are not reselling you inference.
Bugs with a reproducible failure, chores, dependency upgrades, test coverage, and small-to-medium features in a codebase with tests. Large architectural work is not what this is for, and we will say so rather than sell it to you.
The self-hosted edition is free to run and open to read, which is the only way a claim like "your code never leaves" can be checked rather than believed.
Next step
Nothing to send us, no trial account, no sales call first. If you would rather be walked through it, we will show you a real task end to end in twenty minutes.