What it costs
The harness is Apache-2.0. No licence key, no seat count, no paid unlock, no watermark, no attribution nag, no "contact us for enterprise". We are not building a funnel on this page. What you pay is your own Google Cloud bill and your own model plans — and since you set the caps on both, the only person who can tell you the number is you. This page is the breakdown you need to work it out.
Three bills, one of them empty
Every cost associated with running this system falls into exactly one of these. There is no fourth column, and we do not appear in any of them.
Free
Apache-2.0, the whole tree, including the installer, the executor, the crypto envelope and the ~55-tool MCP server. Fork it, run it, modify it, ship it inside your own product. No tier above this one exists to be upsold into.
Metered
Billed by Google, to your billing account, for resources in your project. Scale-to-zero across the request path means an idle install is close to nothing; a busy one costs what a busy one costs. You set the budget and the caps.
Yours already
Your own Claude plan, and optionally your own Gemini or Vertex credentials. The three-position work-mode switch decides which is used, and one of its positions spends nothing beyond the plan you are already paying for.
We will not quote you a monthly figure, because any figure we invented would be wrong for you. Cost here is a function of how much you actually run.
Line one
Not a promotional price. There is no mechanism in the software by which we could charge you.
The harness installs into a Google Cloud project you own, using your credentials, creating resources under your IAM. It does not register with anything of ours. There is no licence check at boot, no telemetry beacon, no usage counter reporting home, no account of ours in the trust path. That is not restraint on our part — it is the architecture. Software that runs entirely inside your tenancy has nowhere to send a bill from.
This has consequences you should weigh in both directions, so here they are honestly.
If you want somebody to be accountable to you for uptime, this is the wrong shape of product and we would rather say so on the pricing page than after you have installed it.
Line two
Component by component, with the cost driver named. Prices come from Google's public pricing and change without asking us; check the current rates for your region before you commit to anything.
.git/index, packed-refs, the working
tree, work items, memory graph, journal entries. Billed on document reads, writes, deletes and
stored bytes. Agent activity is the driver: a fleet doing a lot of small commits and journal
writes does a lot of small operations. Compare-and-swap on refs runs as a Firestore transaction,
which is a write like any other.useToDecapsulate), and the asymmetric
signing the executor verifies. Rotation creates key versions; each version held is billable
for as long as you keep it.home and this line does not
exist.Line three
The switch that decides this has three positions, and one of them spends nothing new.
Strains think with models you bring. The harness does not resell model access, does not proxy your calls through us, and holds no key of ours in the path. A three-position work-mode switch determines where inference comes from.
Work runs through the Claude plan you already pay for, from the client you already use, over the MCP endpoint your install exposes. Spends nothing beyond that plan. If you hit a usage limit, that is a limit on your plan, not a bill from anyone new — and because agent state lives in your project, you can move to another plan, paste the bootstrap, and resume with the history intact.
Interactive work on your plan, queued and background work through the model bus. You are now paying two meters on purpose: the plan you already had, plus per-token charges for whatever the bus consumes. Choose this when you want work items progressing while you are not in the chat.
Work items run against Vertex from inside your project using workload identity — keyless, no API key to leak or rotate. Billed per token to your Google Cloud account, on the same bill as everything else in the breakdown above, with the same budget controls applying.
Gemini or Vertex credentials, if you use them, are yours and stay in your project. The keyless path exists because a long-lived API key sitting in a config file is a liability with a cost attached to it that nobody puts on a pricing page: the day it leaks.
The table
If you want to estimate, estimate from the right-hand column. That is where your usage actually enters the arithmetic.
| Component | Billed by | What drives the cost | Idle cost |
|---|---|---|---|
| The harness itself | Nobody | Apache-2.0. Nothing to meter, nothing phones home. | None |
| Cloud Run — console | Human sessions: requests, request duration, allocated CPU and memory. | Scales to zero | |
| Cloud Run — MCP | Tool calls from your MCP clients and agents. More agents, more calls. | Scales to zero | |
| Firestore | Reads, writes and deletes: commits, ref transactions, work items, journal entries, memory-graph updates. Plus stored bytes. | Stored bytes only | |
| Cloud Storage | Git objects and lake files — stored bytes, operations, egress. Grows with history. | Stored bytes only | |
| Secret Manager | Secret versions held; access operations at runtime. | Versions held | |
| Cloud KMS | Key versions held; encapsulation and signature operations. Rotation adds versions. | Versions held | |
| Cloud Build | Build-minutes: the install, release cuts, and every container a strain builds for you. | None when not building | |
| Vertex AI (optional) | Tokens through the work-mode bus. Only in dual or work. | None in home | |
| Workstation VM (optional) | Running time plus persistent disk. Idles off. | Disk only | |
| Your Claude plan | Anthropic | Whatever plan you already hold. Unchanged by installing this. | Your plan's terms |
| Support & SLA | Nobody | There is none to buy. The repository is the support channel. | None |
Control
An autonomous fleet with an uncapped budget is a bad idea regardless of whose software it is running. Google gives you the controls; use them before you give a strain work to do.
Set a budget with alert thresholds on the billing account, scope it to the project you installed
into, and put a quota ceiling on the services that can run away — build-minutes and, if you
turned it on, Vertex tokens. Then keep the work-mode switch in home until you have
watched a full week of real usage and know the shape of your own curve.
# Point every control at the one project the harness installed into.
gcloud config set project YOUR_PROJECT_ID
# What has this project actually cost so far?
# Billing console -> Reports -> filter by project -> group by service.
# That grouping maps 1:1 onto the table above.
# Then: Billing -> Budgets & alerts -> Create budget
# scope: this project
# amount: a number you are willing to lose
# thresholds: alert well below it, not at 100%The comparison
Compare this against the honest alternative, not against zero.
You pay a monthly figure that is pleasantly predictable, and in exchange your agent state — memory, history, files, repositories, the transcript of everything your team asked and everything the fleet did — lives in somebody else's tenancy, under somebody else's IAM, on somebody else's retention schedule.
The predictable number is real. So are the things attached to it: pricing that changes on their schedule, terms that change on their schedule, an export path that is only as good as they chose to make it, an outage that is yours to explain and theirs to fix, and a compliance conversation that starts with "where is the data" and does not end with "in our project".
You are also, quietly, renting the right to leave. Every month of accumulated state raises the cost of that decision.
You pay Google directly for resources in a project you already own, with a bill you can read by service and a budget you set yourself. The software is Apache-2.0 and free. State is encrypted at rest in your buckets and your Firestore, under keys in your KMS.
The number is less predictable — that is the honest trade, and it is why this page has no headline figure. In exchange there is no counterparty: nobody to change terms on you, nobody holding your history, nobody whose downtime is your incident, no export request to file. Deleting the project is a complete and immediate exit.
And if you decide tomorrow that this whole approach is wrong, uninstall.sh removes
both services and you are left holding your own data in your own project. That is the version of
"no lock-in" that survives contact with a lawyer.
Free software with a metered cloud bill is not cheaper than a subscription in every case. It is yours in every case. Decide which of those you are actually buying.