Keep an Agent Running on a Nearly Empty Quota — Designing Graceful Degradation
When the monthly quota is almost gone, stopping the agent entirely is not the only option. Here is how to design graceful degradation — dropping capability one tier at a time while still producing valuable output — with policy code.
Spotting Agents That Are Alive but Stuck — Designing a Progress Heartbeat and Watchdog
The process is alive but the work isn't moving — the nastiest state for a background agent. Here is how to switch from liveness to progress monitoring to detect it, and how to stop it safely, with working code.
When Background Agents Run Twice — Stopping Double Execution with Leases and Fencing Tokens
The same scheduled job fires from two machines at once and they overwrite each other's output. Here is how to stop that failure mode at the root in Antigravity 2.0 background agents, using leases and fencing tokens, with working code.
Treating Built-in Guide Skills as Design Assets, Not Throwaway Prompts
Antigravity v2.2.1 added built-in Guide skills. Here is a concrete structure and set of judgment calls for running them as version-controlled, shared design assets instead of one-off instructions.
Keep a Tamper-Evident Audit Log of Your Autonomous Agent's Actions
To record the decisions and actions an Antigravity agent takes autonomously in a form you can trace and verify later, design an append-only audit log whose hash chain detects tampering. Includes the implementation.
Keeping Unattended Agent Run Logs Long Enough to Debug — Without Filling the Disk
A scheduled agent is only fixable if you can reconstruct why it failed. Here is how to keep run logs around without filling the disk — tiered retention, schema-versioned records, and a compaction job — drawn from running four sites on autopilot as an indie developer.
Agent Config Drifts Quietly Across Environments: Detection and Correction
Across two Macs and an automation host, agent settings slowly diverge and only one side fails. Here is how to surface that config drift with normalized hashing and a correction workflow, from an indie developer's setup.
Accounting for Which Agent Spent What: A Cost Attribution Design by Task
Your month-end bill is one number, but running multiple agents on Gemini 3.5 Flash hides which task ate the cost. Separate from a budget guard, I share a cost-attribution accounting design that maps usage to per-task and per-site cost, with a solo-operator implementation and numbers.
Tracing Parallel Agents After the Fact: Observability with Structured Logs and Spans
Running multiple agents in parallel on the Antigravity 2.0 desktop makes it impossible to tell which one is doing what. I share an observability design that drops tangled print debugging for run_ids and spans you can trace afterward, with a solo-operator implementation and numbers.
Making Managed Agent Batches Safe to Re-run: Idempotency and Checkpoints
Running overnight batches on the Antigravity 2.0 Managed Agents API makes recovery from partial failure unavoidable. Starting from a duplicate-post incident, I share the implementation of idempotency keys, a checkpoint store, and resume logic, with real numbers from solo operations.
Collecting Guardrails Across Projects Into One Place — A Thin Wrapper Around the Antigravity SDK
When you copy the same safeguards into every project, you eventually fix one and leave the other stale. Here is a design that builds a single thin wrapper around the Antigravity SDK to centralize cost caps, allowed tools, and output validation — from someone running several apps in parallel.
When a Cloud Nightly Batch Drifts From Yesterday's Result — An Input Contract and Snapshot Design for Reproducibility
When you push a batch to a cloud ephemeral worker via the Managed Agents API, the environment assumptions you took for granted locally vanish. Here is a three-layer design — environment snapshot, input contract, seed pinning — that keeps the same input producing the same result.