How to run AI coding agents in GCP

Teams that run on Google Cloud usually want their coding agents there too. Source code already lives in repositories connected to GCP workloads, test databases run on Cloud SQL, and security teams already review access through IAM and Cloud Audit Logs. An agent running on a developer laptop sits outside all of that.

Running coding agents in your own GCP project gives you more control over their execution environment, network access, and identity permissions. The agent can work alongside your existing GCP infrastructure, authenticate with a service account, and call Claude through Vertex AI. This guide covers the ways to run AI coding agents in GCP, how to set one up on Compute Engine with Vertex AI, where that approach breaks down, and how to run coding agents in your GCP project with Northflank Cloud Harnesses.

Running coding agents in your GCP project gives you more control over where they run, which credentials they have, and which resources they can access. The agent can reach Cloud SQL instances, Memorystore, and internal services over private networking in your VPC, so it can run integration tests against real dependencies without exposing them publicly. IAM service accounts define what the agent can access, and Cloud Audit Logs record the Google Cloud API calls it makes.

Compute runs on your Google Cloud bill, so it counts toward committed use discounts and appears in your existing billing reports and budgets. With Vertex AI, Claude Code can make model requests through Google Cloud, with usage billed to your project. This lets you run the coding environment and model access through your existing GCP infrastructure.

A Compute Engine VM works for a basic setup, but every additional agent means another environment to configure and maintain. Northflank Cloud Harnesses give each coding agent its own isolated cloud environment, ready to use with the compute, storage, networking, credentials, web terminal, and SSH access it needs. You can create multiple Harnesses for parallel tasks, pause them when they're not needed, and run them in your own GCP infrastructure through BYOC. That gives you the control of your cloud account without having to build a coding agent platform yourself.

1. Create a service account for the agent and grant it only what it needs, such as reading a secret from Secret Manager and calling Vertex AI:

gcloud iam service-accounts create coding-agent

gcloud projects add-iam-policy-binding YOUR-PROJECT-ID \
  --member="serviceAccount:coding-agent@YOUR-PROJECT-ID.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

gcloud secrets add-iam-policy-binding github-token \
  --member="serviceAccount:coding-agent@YOUR-PROJECT-ID.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

1. Create a VM that runs as that service account:

gcloud compute instances create coding-agent \
  --zone=us-central1-a \
  --machine-type=e2-standard-4 \
  --service-account=coding-agent@YOUR-PROJECT-ID.iam.gserviceaccount.com \
  --scopes=cloud-platform \
  --image-family=ubuntu-2404-lts-amd64 \
  --image-project=ubuntu-os-cloud

1. Connect and install Git, tmux, Node.js, and the agent CLI:

gcloud compute ssh coding-agent --zone=us-central1-a

sudo apt-get update && sudo apt-get install -y git tmux
# Install Node.js using your preferred method, then:
npm install -g @anthropic-ai/claude-code

1. Read the Git credential from Secret Manager at runtime instead of writing it to disk:

export GITHUB_TOKEN=$(gcloud secrets versions access latest --secret=github-token)

1. Clone the repository, create a branch, and start the agent inside tmux so the terminal session remains available when you disconnect:

git clone https://github.com/your-org/your-repo.git
cd your-repo && git checkout -b task-142
tmux new -s task-142
claude

1. Detach with Ctrl+B, then D, and reattach later with:

tmux attach -t task-142

Running one coding agent on Compute Engine is straightforward. The complexity comes when you need to manage multiple isolated environments, credentials, networking, persistence, and team access.

Northflank Cloud Harnesses handle that infrastructure for you, while letting the Harnesses run in your own GCP project through BYOC.

Think of a Harness as a dedicated cloud environment for your coding agent, without the infrastructure work normally required to build one.

Northflank Cloud Harnesses are cloud workspaces built for coding agents. Each Harness is configured for one agent at creation, whether Claude Code, Codex, Cursor, OpenCode, Pi, or bring your own agent, with the agent CLI pre-installed and its credentials injected as environment variables. A Harness can clone a connected Git repository and branch on start, and you work in it through the web terminal in the Northflank dashboard or over SSH from your local terminal.

With BYOC on GCP, Northflank provisions and manages a GKE cluster inside your GCP project, and your Harnesses run on it. This puts the Harness workload and its workspace inside your GCP infrastructure, while letting the agent reach Cloud SQL and internal services over private networking when your VPC routing and firewall configuration allows it. The underlying compute is billed by GCP.

Every Harness runs in an isolated microVM. When workspace persistence is enabled, files in the Harness workspace are retained across restarts. You can pause a Harness and resume it later, or delete it when the task is done. Teammates with access can connect to the same Harness through their own Northflank accounts.

For Claude Code, you can combine BYOC with Vertex AI by configuring Claude Code to use Google Cloud as its model provider. This lets Claude Code make model requests through Vertex AI while the coding environment runs in your GCP infrastructure.

Create your first Harness on Northflank, or follow How to run a coding agent in the cloud for the full Harness setup.

1. Connect your GCP project. In the Northflank dashboard, create a provider link to your Google Cloud project.
2. Create a cluster. Northflank provisions a GKE cluster in your project, in the region you choose.
3. Add node pools. Configure the node pools that will run your workloads, including machine types and zones.
4. Deploy workloads. Your cluster is ready for projects and Harnesses.

See Integrate your Google Cloud account for the full steps and required GCP permissions. If you already run a GKE cluster, you can also import an existing cluster for Northflank to manage.

1. Create a Northflank project on your GCP cluster. When you create a project, choose your GCP cluster as where its resources deploy instead of Northflank's cloud.
2. Create a Harness in that project. Select your agent, environment size, authentication, and the repository and branch to work on. Add any other secrets the task needs, such as Vertex AI settings for Claude Code.
3. Connect and run the agent. Open the Harness in the web terminal, or connect over SSH with the Northflank CLI, and start the agent:

northflank dev ssh --projectId your-project-id --harnessId your-harness-id
claude

The Harness runs as a microVM on your GKE cluster, inside your GCP project.

With Northflank BYOC on GCP, the Harness runs on a GKE cluster in your own Google Cloud project, so the repository clone and agent workspace run in your infrastructure. Northflank manages the cluster and Harness configuration. Where the agent sends model requests depends on its configuration: Claude Code with Vertex AI sends model requests through Google Cloud, while an agent using another model provider's API sends requests to that provider.

Yes. Claude Code supports Vertex AI as a model provider. Configure the required Google Cloud project, region, authentication, and Vertex AI permissions, then enable Vertex AI in Claude Code. See the Claude Code documentation for the current configuration.

Yes, if the network allows it. With Northflank BYOC, Harnesses run on a GKE cluster in your GCP environment, so they can reach private resources when your VPC and firewall rules permit it. Give the agent a scoped database user rather than an application or admin user.

With BYOC, the compute resources running in your GCP project are billed by Google Cloud, so they count toward your Google Cloud spend and commitments. Claude usage through Vertex AI is also billed to your project. See Northflank pricing for the BYOC platform pricing.

Yes. Northflank can provision a new GKE cluster in your project, or you can import an existing Kubernetes cluster for Northflank to manage. See Import an existing cluster.

• How to run AI coding agents in AWS
• How to give AI coding agents secure access to private repositories, databases, and services
• How to run remote coding agents