GTA 6 Economics 1: The Vault Is Safe Because It Is Slow
Finding Solved Games in Moving Castles.
Five from the pre-launch wave, each read through one question: which pool should hold this money, and what is it exposed to there?
- The money splits three ways, a bank balance, cash on the person, and loot in a duffel, the bank app named "BuckMe" in HUD footage (TweakTown via Handheld Guru, handheld.guru/gta-6-robbery-tiers-money-mechanics-rockstar; WikiGTAVI, wikigtavi.com/guides/gta-6-money-economy). Verdict PASS on the structure, qualitative only: no rates attached.
- Carried cash is reported lost on death while banked money is safe (GTA Intel, 28 August 2026, gtaintel.com/news/gta-6-money-system-explained, citing sanctioned Rockstar North previews). Verdict PASS for death; whether arrest costs the same is hedged by one account, verdict INCONCLUSIVE.
- One creator reports you can deposit only at a physical ATM, not from your phone as in GTA Online (The Gaming Gorilla, relayed by GTA Intel). Verdict INCONCLUSIVE, single-sourced. If it holds, a deposit is a detour with a real cost, the one assumption the trade-off needs.
- Rockstar's Rob Nelson says main-story progress is gated behind cash goals (via TweakTown, relayed by Handheld Guru, 1 September 2026; WikiGTAVI). Verdict PASS that gates exist; the amounts are unpublished, verdict INCONCLUSIVE, with a single-sourced claim that gates count banked deposits, not earnings.
- Loot is not spendable until sold to a type-specific fence, usually at a discount, and a job counts as done only once fenced (GTA Intel; Handheld Guru; WikiGTAVI). Verdict PASS on the fence step; the discount rate is unpublished, verdict INCONCLUSIVE.
Both tools follow The Read. carry_gate.py, free and runnable below, turns the three-pool trade-off into one bank-or-carry decision. The Hazard Ledger, the paid flagship below the cut, measures the risk the free tool can only ask you to guess.
The Read: the vault is safe because it is slow
A money system is a mechanism in the technical sense: rules a designer picks so that self-interested players, left to their own ends, behave the way the designer wants. That is the subject Leonid Hurwicz founded in his 1973 lecture on the design of mechanisms, and a game economy is one of the purest cases, because the designer writes every rule and the player has nowhere to appeal. When Rockstar makes cash on your person lost on death but banked cash safe, it installs an incentive: choose, over and over, between access and safety, and let the careless choice cost you.
So the player's job is not to memorise a number the game is hiding. It is to solve the trade-off the designer built. Cash can be spent the instant an opportunity appears, but one bad encounter wipes it. Banked money is untouchable by death or arrest, but you cannot reach it without a trip, and if the trip means a physical ATM, the minutes spent walking are minutes you are not earning.
This is liquidity preference, and it has had an arithmetic for seventy years. Baumol in 1952 and Tobin in 1956 modelled how often a rational person should move money from a safe account into spendable cash when each trip costs a fixed amount and cash earns no interest while it sits. They made it an inventory problem: you restock in lumps, and the optimal lump balances trip cost against holding cost. The GTA 6 version swaps one term. Cash in your pocket does not forgo interest; it carries a hazard, a probability p of losing all of it before you can bank. Put a number on p and the decision collapses to one line.
Carrying C in cash through the next risky leg has an expected cost of p times C: the fraction of the time you lose it, times what you lose. A banking trip costs T, the detour priced in forgone earnings. Bank the moment the first exceeds the second: bank when p times C is at least T.
Rearrange it for a threshold you can hold in your head. The two costs are equal at C* = T / p. Below it, keep playing; the next job is cheaper than the walk to the ATM. At or above it, deposit before the next risk. Suppose a store job has a one-in-five chance of a wipe, so p is 0.2, and the nearest ATM is a three-minute detour off a run paying roughly a thousand a minute, so T is about 3,000. The threshold is 3,000 divided by 0.2, which is 15,000. Carry more than that and, on your own estimate, you hold more risk than the trip would cost.
Every term in that line is yours, not Rockstar's. The game has published no p and no T; the mechanism-design reading gives you the shape, not the numbers. The rule holds whatever the values, and it tells you which number to watch for: the first review reporting how often a store job goes wrong gives you p, timing the ATM walk against your earnings gives you T. The threshold does the rest.
The twenty-minute version
Before you play, decide one thing: your walk-away cash. Pick a rough p for the crime you expect to run and a rough T for a banking detour, divide, and write the number down as a hard stop. When carried cash crosses it, the next thing you do is bank, not one more job. Three honest guesses buys the discipline that separates a bankroll that compounds from one that resets every time you get unlucky.
The bank is safe because it is slow. The game is betting you will treat slow as safe to ignore.
The Tool: carry_gate.py
The free, from-scratch tool this week. Give it your cash, your estimate of the wipe probability on the next leg, and what a banking trip costs in forgone earnings; it says bank or carry on and prints the threshold. Exit 0 carry on, 1 bank now, 2 bad input. Standard library only.
#!/usr/bin/env python3
"""carry_gate.py - decide whether to bank the cash on your person before the
next risky job, by comparing the expected loss of carrying it against the cost
of the banking trip.
GTA 6 (launch 19 November 2026) splits a player's money into three pools with
different exposure: a bank balance (safe), cash on the person (reported lost on
death, and on arrest), and loot in a duffel (sold to a fence for clean money).
No official rate, probability or threshold has been published; every figure
below is the PLAYER'S OWN estimate, and the tool is built to take estimates and
stay honest that they are estimates.
The one decision this models is the recurring one: you are holding C in cash and
about to take another risky leg (a store job, a drive through hostile ground)
that carries some probability p of a wipe event (death or arrest) before you can
next reach an ATM. A banking trip is not free: it costs a detour you could have
spent earning, worth T in-game dollars. Carry, and you expose C to the wipe.
Bank, and you pay T for certain.
expected loss of carrying one more leg = p * C
bank when p * C >= T
carry when p * C < T
indifference threshold C* = T / p (carry below it, bank at or above it)
This is the inventory-theoretic money-demand trade-off (Baumol 1952, Tobin 1956)
with the holding cost switched from forgone interest to an expected-loss hazard:
you hold cash for access, but every unit held through a risky leg has an
expected cost p per leg, so you bank in lumps rather than after every dollar.
When you give a session's planned cash take Y and the per-leg wipe probability p,
the tool also reports the Baumol-Tobin optimal amount to let build up between
banking trips, M* = sqrt(2 * T * Y / p), the lump that balances trip cost against
hazard across the session.
USAGE:
carry_gate.py --cash C --death-prob P --trip-cost T [--session-earnings Y]
--cash cash on the person right now, in-game dollars.
--death-prob your estimate of the probability (0..1) of a wipe event
on the next risky leg before you can bank. Rockstar has
published none; this is your read of the job and the heat.
--trip-cost the banking trip's opportunity cost in dollars: minutes of
detour times your dollars-per-minute earning rate.
--session-earnings optional: cash you plan to take this session before you can
bank again. If given, prints the Baumol-Tobin lump M*.
carry_gate.py --self-test
run built-in checks of the decision rule and exit.
EXIT: 0 CARRY ON (expected loss below the trip cost). 1 BANK NOW (expected loss
at or above the trip cost). 2 a bad input (probability outside 0..1, negative
money, un-runnable).
"""
from __future__ import annotations
import argparse
import math
import sys
def threshold(trip_cost, death_prob):
"""Cash level at which expected loss equals the trip cost: C* = T / p.
p == 0 means no hazard, so no finite threshold: never worth a trip."""
if death_prob == 0:
return math.inf
return trip_cost / death_prob
def decide(cash, death_prob, trip_cost):
"""Return (bank, expected_loss, c_star). bank is True when p*C >= T."""
expected_loss = death_prob * cash
c_star = threshold(trip_cost, death_prob)
return (expected_loss >= trip_cost, expected_loss, c_star)
def baumol_tobin_lump(trip_cost, session_earnings, death_prob):
"""Optimal cash to let accumulate between banking trips over a session:
M* = sqrt(2 * T * Y / p). Holding cost per unit is the per-leg wipe
probability p, standing in for the interest rate in Baumol-Tobin."""
if death_prob == 0:
return math.inf
return math.sqrt(2.0 * trip_cost * session_earnings / death_prob)
def render(cash, death_prob, trip_cost, session_earnings):
bank, expected_loss, c_star = decide(cash, death_prob, trip_cost)
lines = ["CARRY GATE", ""]
lines.append(" cash on person : $%s" % format(int(round(cash)), ","))
lines.append(" wipe probability (est): %.0f%% (your estimate; no official figure exists)"
% (death_prob * 100))
lines.append(" banking trip cost : $%s" % format(int(round(trip_cost)), ","))
lines.append("")
lines.append(" expected loss if you carry one more leg : $%s (%.0f%% of $%s)"
% (format(int(round(expected_loss)), ","), death_prob * 100,
format(int(round(cash)), ",")))
c_star_str = "no finite threshold (zero hazard)" if math.isinf(c_star) \
else "$%s" % format(int(round(c_star)), ",")
lines.append(" bank-now threshold C* = T / p : %s" % c_star_str)
lines.append("")
if bank:
lines.append("VERDICT: BANK NOW. The cash you are carrying is more exposed than the")
lines.append(" trip costs: expected loss $%s >= trip cost $%s."
% (format(int(round(expected_loss)), ","),
format(int(round(trip_cost)), ",")))
lines.append(" Deposit before the next risky leg.")
else:
lines.append("VERDICT: CARRY ON. The trip is not yet worth it: expected loss $%s <"
% format(int(round(expected_loss)), ","))
lines.append(" trip cost $%s. You can take on cash up to $%s before the"
% (format(int(round(trip_cost)), ","),
"the infinite" if math.isinf(c_star) else format(int(round(c_star)), ",")))
lines.append(" trip pays for itself.")
if session_earnings is not None:
m = baumol_tobin_lump(trip_cost, session_earnings, death_prob)
m_str = "unbounded (zero hazard)" if math.isinf(m) else "$%s" % format(int(round(m)), ",")
lines.append("")
lines.append(" Baumol-Tobin lump between trips, M* = sqrt(2*T*Y/p) : %s" % m_str)
lines.append(" (with a planned session take of $%s, let cash build to about"
% format(int(round(session_earnings)), ","))
lines.append(" this much before each banking trip, not more.)")
return "\n".join(lines)
SELF_TESTS = [
# (cash, p, trip_cost, expect_bank)
(25000, 0.20, 3000, True), # p*C = 5000 >= 3000 -> bank
(8000, 0.20, 3000, False), # p*C = 1600 < 3000 -> carry
(15000, 0.20, 3000, True), # p*C = 3000 == 3000 -> bank at the boundary
(100000, 0.0, 3000, False), # no hazard -> never worth a trip
(5000, 1.0, 3000, True), # certain wipe -> always bank anything above the cost
]
def self_test():
passed = 0
for i, (cash, p, trip, exp_bank) in enumerate(SELF_TESTS):
bank, _loss, _cstar = decide(cash, p, trip)
ok = bank == exp_bank
passed += ok
print(" %-4s case %-2d cash=$%-8s p=%-4s trip=$%-6s -> %-8s (expected %s)"
% ("PASS" if ok else "FAIL", i, format(cash, ","), p, format(trip, ","),
"BANK" if bank else "CARRY", "BANK" if exp_bank else "CARRY"))
total = len(SELF_TESTS)
print()
print("SELF-TEST: %d/%d checks passed" % (passed, total))
return 0 if passed == total else 1
def main():
ap = argparse.ArgumentParser(
description="Bank-or-carry decision for GTA 6 cash under a wipe hazard.")
ap.add_argument("--cash", type=float, help="cash on the person now, dollars")
ap.add_argument("--death-prob", type=float,
help="estimated probability (0..1) of a wipe on the next risky leg")
ap.add_argument("--trip-cost", type=float,
help="opportunity cost of a banking trip, dollars")
ap.add_argument("--session-earnings", type=float, default=None,
help="optional: planned cash take this session, for the Baumol-Tobin lump")
ap.add_argument("--self-test", action="store_true", help="run built-in checks and exit")
args = ap.parse_args()
if args.self_test:
return self_test()
missing = [n for n in ("cash", "death_prob", "trip_cost") if getattr(args, n) is None]
if missing:
ap.error("missing required argument(s): %s"
% ", ".join("--" + m.replace("_", "-") for m in missing))
if not (0.0 <= args.death_prob <= 1.0):
print("death-prob must be between 0 and 1, got %s" % args.death_prob, file=sys.stderr)
return 2
if args.cash < 0 or args.trip_cost < 0 or (args.session_earnings is not None
and args.session_earnings < 0):
print("money amounts must not be negative", file=sys.stderr)
return 2
print(render(args.cash, args.death_prob, args.trip_cost, args.session_earnings))
bank, _loss, _cstar = decide(args.cash, args.death_prob, args.trip_cost)
return 1 if bank else 0
if __name__ == "__main__":
sys.exit(main())
The worked example is the first real decision of a session. You carry 25,000, reckon the next store job has about a one-in-five chance of ending in death or arrest before you can bank, and put the ATM detour at about 3,000 in forgone earnings. All three numbers are yours.
CARRY GATE
cash on person : $25,000
wipe probability (est): 20% (your estimate; no official figure exists)
banking trip cost : $3,000
expected loss if you carry one more leg : $5,000 (20% of $25,000)
bank-now threshold C* = T / p : $15,000
VERDICT: BANK NOW. The cash you are carrying is more exposed than the
trip costs: expected loss $5,000 >= trip cost $3,000.
Deposit before the next risky leg.
Baumol-Tobin lump between trips, M* = sqrt(2*T*Y/p) : $42,426
(with a planned session take of $60,000, let cash build to about
this much before each banking trip, not more.)
Exit one. At 25,000 you are past the 15,000 threshold, so the 5,000 expected loss from carrying beats the 3,000 trip and the tool says bank. Drop to 8,000 on the same estimates and the expected loss is 1,600, so it says carry on. --self-test checks five cases, including the boundary where the costs are equal and the zero-hazard case where no trip is worth making.
Founder offer
If you plan to run a criminal economy for sixty hours, decide your walk-away cash before the first job, not after the first bad loss. The tool above sets it in three numbers.
Pro is $15 a month or $250 a year: the Brief, the paid flagship tool, the paid Feed payload, and the archive. Founder is $300 a year, capped at one hundred seats, with a founders-only MCP server built once the hundredth seat sells. Terms at nonxerosum.studio/mcp.
No pitch beyond that. The bank-or-carry threshold is the argument.
