Two Accounts, One Terminal: Teaching Antigravity to Switch Brains on the Fly

At 03:45 AM, during high-velocity vibe coding sessions across complex agent workflows, you hit the inevitable boundary: rate limits. If you have two subscription accounts—say, davaytiyada@gmail.com and yusufakcakaya@gmail.com—the logical move is simple: flip to the second account and keep building without breaking the cognitive flow.

Except in terminal-native agent harnesses, identity is rarely designed for on-the-fly hot-swapping.

Most CLI tools assume a singular, static user identity. Switching accounts traditionally meant opening an interactive browser auth flow, blowing away credential caches, and hoping in-flight tokens wouldn’t get corrupted.

Tonight in Yusuf’s workshop, we engineered a clean, zero-friction solution: agy-auth, a multi-account profile switcher and automated keepalive daemon built directly into the Antigravity tooling stack.

The Three Silent Traps of CLI OAuth

Building an identity switcher for an autonomous AI CLI sounds like simple file copying. In practice, terminal-based OAuth contains three subtle traps that will silently destroy your sessions if you treat tokens as static files:

1. In-Flight Token Renewal Desynchronization

When agy runs long queries or background subagents, Google OAuth access tokens expire after 60 minutes. The CLI runtime automatically uses the refresh_token to fetch a new access_token and writes it back to ~/.gemini/antigravity-cli/antigravity-oauth-token.

If a switcher simply overwrites files from a static snapshot folder when swapping profiles, it will destroy the newly minted access token and revert to an expired one.

The Fix: The switcher must always execute a pre-switch sync:

def sync_active_to_current_profile() -> None:
    """Save runtime tokens back to the active profile before switching.
    Guarantees that background token renewals are never lost."""
    curr = get_current_profile_name()
    if not curr:
        return
    prof_dir = PROFILES_DIR / curr
    # Verify account identity matches before persisting
    runtime_info = extract_account_info(ACTIVE_AGY_TOKEN, ACTIVE_OAUTH_CREDS, ACTIVE_GOOGLE_ACCOUNTS)
    if runtime_info.get("email") not in ("Unknown", saved_email):
        return
    for src, dst_name in [(ACTIVE_AGY_TOKEN, "antigravity-oauth-token"), ...]:
        shutil.copy2(src, prof_dir / dst_name)

2. The Legacy Identity Illusion

In early exploration, inspecting ~/.gemini/google_accounts.json and ~/.gemini/oauth_creds.json showed yusufakcakaya@gmail.com from a login back in June. But the actual bearer token inside antigravity-oauth-token was driving live queries as davaytiyada@gmail.com.

Relying on local config files for identity truth is a mistake. The only source of truth is the live authorization server:

def fetch_google_userinfo(access_token: str) -> Dict[str, Any]:
    """Query Google UserInfo API directly with the live bearer token."""
    req = urllib.request.Request("https://www.googleapis.com/oauth2/v3/userinfo")
    req.add_header("Authorization", f"Bearer {access_token}")
    with urllib.request.urlopen(req, timeout=3) as resp:
        return json.loads(resp.read().decode("utf-8"))

By querying https://www.googleapis.com/oauth2/v3/userinfo, the switcher verifies the exact Google profile and avatar tied to the active token with zero guesswork.

3. Refresh Token Rot

If an account sits idle in a backup directory for weeks without active requests, its OAuth refresh token can rot or be revoked during security rotations. When you finally switch to it during a midnight coding sprint, the token is dead and demands interactive browser login.

The 08:00 AM Keepalive Daemon

To make sure both subscriptions stay permanently active, we built an autonomous systemd timer: agy-auth-keepalive.timer.

Every morning at 08:00 AM, a headless daemon wakes up:

1. Records the developer’s currently active profile.
2. Iterates through all saved profiles (davaytiyada, yusufakcakaya, etc.).
3. Swaps credentials into the active runtime and sends a lightweight 1-token probe:

   agy -p "echo keepalive" --effort low --disable-slash-commands

4. Captures the refreshed access token and updates the profile’s timestamp metadata.
5. Restores the developer’s original profile so their active workspace is untouched.

[Unit]
Description=Daily Token Keepalive for Antigravity (agy) Accounts
After=network-online.target

[Timer]
OnCalendar=*-*-* 08:00:00
OnBootSec=10min
RandomizedDelaySec=600
Persistent=true

[Install]
WantedBy=timers.target

Seamless Statusline & Single-Key Toggle

Good engineering is invisible. When working inside the terminal, you shouldn’t have to remember which account is driving your agent.

We integrated profile awareness directly into statusline.sh:

● READY ╱ 👤 davaytiyada ╱ Flash (High) ╱ main*
ctx █·············· 8.2% · artifacts 0 · subagents 0 · tasks 0 · sandbox ON

And switching accounts on the fly is a single command:

# Toggle between Profile 1 and Profile 2
agy-auth toggle

# Output:
# ✓ Switched to profile: yusufakcakaya (yusufakcakaya@gmail.com)

Behind the scenes, agy-auth automatically reloads the local OpenAI proxy bridge (agy-proxy.service) and flushes stale quota caches.

The Takeaway

Developer tools should never punish you for having multiple accounts. By treating identity state as dynamic living contracts—synchronizing in-flight renewals, querying authoritative identity endpoints, and maintaining automated keepalive cycles—we turned a frustrating friction point into a seamless zero-downtime toggle.

Two accounts, one terminal, zero cognitive overhead.