Anchor now runs in your environment. Bring Your Own Cloud and full on-prem deployments are available today.
Some browser work has to run where you are. The data cannot leave your network. The site your agent needs is an internal app that is only reachable from inside your VPC. Security wants the cookies, the session recordings, the downloaded files, and the logged-in browser profiles somewhere they control, under policies they wrote.
That is the reason to run Anchor in your environment. You keep the same browser and the same core APIs. What changes is where it runs, and where the data stays.
This post covers why that is harder than it sounds, why “we'll just run Chrome in a container” is a different product, and how the work splits between your team and ours.
A container of Chrome is not Anchor
Putting Chromium in a container is a weekend project. It is also a different product from the one that was passing your sites.
Anchor's browser is a compiled, patched Chrome. The work that makes it hold up on hostile sites lives inside that build, in the source, below the layer any flag or extension can reach. It is not a config file you add to the Chrome everyone can download. Swap in a stock binary and it is gone.
That is what makes containerizing it hard. You are not packaging an app. You are packaging a browser fork, and it has to behave the same inside your cluster as it does in ours:
- The patches have to survive the container. A headless Linux pod has no real display, a different font set, different GPU paths, and different resource limits than a desktop. Each of those is something a site can observe. The build and the image around it have to keep presenting a consistent browser, not a server pretending to be one.
- Chrome never stops shipping. Since Chrome 153 in September 2026, a new major version lands every two weeks, twice the old pace, with weekly security fixes in between. Each one is another compile, another pass over every patch to see what upstream changed underneath it, and another round of proving the browser still behaves on real sites. That job does not end.
- Falling behind is its own signal. Pin an old version to avoid the work and the browser starts to look old, and to miss security fixes. Track upstream without the patches and you lose the stealth. There is no setting that makes this go away.
A team that starts from upstream Chrome has opted out of all of it. The gap shows up on exactly the sites that were the reason to buy Anchor.
The browser is only half of it
Around that browser is the control plane. It is the part customers never think about, because on Anchor it just works. Every one of these is a system someone has to build and run:
- Session lifecycle. Starting a browser on demand, scheduling it onto capacity, enforcing timeouts, and cleaning it up completely so nothing leaks into the next session.
- Persistent profiles. Saving a logged-in browser state, cookies and storage included, and restoring it intact on a different machine days later.
- Network egress. Choosing how each session's traffic leaves: proxies, sticky IPs, and routing that matches what the site expects to see.
- Agent handoff. Exposing the browser over CDP and the Anchor APIs so an agent framework can drive it, and running AI-powered browser tasks on top.
- Live view. Letting a person watch a session in real time, and step in when a workflow needs a human.
- Recordings and artifacts. Capturing session recordings and downloaded files, and storing them where they can be found and governed later.
Those are the benefits people expect to come with the browser. Rebuilding them, on top of a fork you also have to keep compiling every two weeks, is how “we'll just run Chrome ourselves” turns into a second engineering team. One that is on call whenever your agents are running.
Who does what
You keep the infrastructure. Your machines, your network, your security boundary. The browsers run where they can reach your systems, and the data they produce stays with you.
Anchor keeps the patched Chrome. We compile it, patch it, and ship every new version, so you are not maintaining a browser fork to keep stealth working. Your team rolls those versions out to your cluster.
There are two ways to deploy, depending on where the control plane is allowed to live.
Bring Your Own Cloud (BYOC). You install Anchor's Browser Agent Helm chart in your own Kubernetes cluster, on any cloud, and it connects to Anchor's managed control plane. Browsers, recordings, and files stay in your environment, and Anchor's control plane orchestrates them. We compile, patch, and ship the browser, and your team rolls it out with a Helm upgrade.
On-prem. The control plane also has to stay inside your environment. A Helm chart deploys the entire Anchor platform into your Kubernetes cluster: the API, the browser infrastructure, the database, and object storage. Your team operates that cluster, which needs autoscaling nodes, ingress, DNS and TLS, and RBAC. We ship new browser builds and platform releases as image bundles, and your team applies them with a Helm upgrade.
| BYOC | On-prem | |
|---|---|---|
| Where browsers run | Your Kubernetes cluster, on any cloud | Your Kubernetes cluster |
| Who runs the control plane | Anchor | Your team, on Anchor's platform |
| Where browsers, recordings, and files live | Your environment | Your environment |
| Who compiles and patches Anchor's Chrome | Anchor | Anchor |
| Who rolls out upgrades | Your team, via Helm upgrade | Your team, via Helm upgrade from image bundles |
| How it's deployed | Browser Agent Helm chart in your cluster, connected to Anchor's control plane | Full-platform Helm chart in your cluster |
| Requires | Kubernetes | Kubernetes with autoscaling nodes, ingress, DNS and TLS, RBAC |
| APIs and SDK | Core Anchor APIs at control.anchorbrowser.io | Core Anchor APIs at your own endpoint |
| Plan | Enterprise | Enterprise |
Your developers keep the same APIs
Same APIs and SDK either way. With BYOC, your code keeps calling Anchor's API. With on-prem, point the SDK at your own endpoint. The core Anchor APIs, the same CDP connection, and the same patched browser are there in both, so code written against them keeps working.
The teams this is built for usually have one of three reasons:
- Data residency and compliance. Session data, recordings, and cookies have to stay in a specific region or under a specific policy.
- Internal applications. The agent needs to work in tools that are only reachable from inside your network, with no public endpoint to point a cloud browser at.
- Security control. Your security team wants the browsers, the credentials they hold, and everything they produce inside a boundary they own and audit.
Get started
You do not need to staff a browser team to run browsers in your environment. Keep the infrastructure. Let Anchor build the browser and the platform that runs on it.
BYOC and on-prem deployments are available now on the Enterprise plan. Talk to the Anchor team and we will scope the right setup for your environment. The deployment guide is in the Anchor docs.
The same Anchor experience, deployed wherever your requirements demand.


