All Articles
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.
Pin Your Agent's Output With Golden Snapshots Before Switching Models
When Antigravity's engine moves to Gemini 3.5 Flash, an agent's output can drift silently. This walks through a golden-snapshot regression gate that catches the drift, with the actual test code and a migration-day checklist.
When Your Agent Automation Breaks: How Many Minutes to Recovery?
As Antigravity 2.0 adds desktop, CLI, and SDK surfaces, the things you must restore after a failure multiply too. As an indie developer running several sites on autopilot, I lay out a three-layer recovery design covering credentials, definitions, and state, plus a monthly restore drill.
Turning a throwaway prompt into a reusable sub-agent
When a one-off prompt to an Antigravity 2.0 dynamic sub-agent works beautifully, it usually vanishes into your chat history. Here is how to capture it as a reusable definition, with the actual file layout and the distillation steps.
Before a Major Update Silently Breaks Your Overnight Automation — Designing a Staged-Adoption Canary Gate
After a major update dropped my unattended run success rate from about 98% to 63% overnight, I built a staged-adoption gate that freezes the working setup, verifies a new version against a golden output in an isolated profile, and only then adopts it. Here is the design with bash and Python.
Before a Stray Instruction in a Fetched Page Drives Your Unattended Agent — Tainting Inputs to Downgrade Capabilities
So an unattended agent that reads external pages or PDFs can't be hijacked by an instruction hidden inside them: track the taint of every input and automatically downgrade side-effecting tools. With working Python and real operational numbers.
Your Antigravity Custom Tools Don't Break by Design — They Break on Re-execution: Field Notes on Idempotency and Error Contracts
Once you add a custom tool to an Antigravity agent, the real production problem is re-execution and duplicated side effects. Here are the idempotency keys, error contracts, health gates, and tool-sprawl checks that actually held up in practice.
Stop Hard-Coding Your Agent Concurrency: Let It Tune Itself From What It Observes
When you run several Antigravity 2.0 agents in parallel, a single fixed concurrency number is wrong twice: it stalls at 429s during the day and idles capacity at night. Here is an adaptive design borrowed from TCP congestion control — additive increase, multiplicative decrease — that moves your concurrency from observed signals, with working Python and field notes.
Taking Stock of the Dependencies Your Agent Added — A Design for Keeping License and Provenance Traceable
A few months of letting agents work, and your package.json quietly grows dependencies you don't remember adding. Here is a design for taking stock — recovering what was added, when, and why, in a form you can still trace later.
Letting a Background Agent Work Overnight Without Regretting It by Morning — Guardrails for Unattended Runs
When you hand overnight refactoring to Antigravity's Background Agent, the morning brings as much anxiety as convenience. From three angles — blast radius, completion criteria, and detecting silent regressions — here are the guardrails that let me run unattended jobs with confidence.
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.
When a Timed-Out Unattended Agent Leaves a Half-Written File Behind
When a scheduled agent gets killed on timeout, it can leave a half-written file that silently poisons the next stage. Here is the atomic write, stale-temp cleanup, and post-write content assertion I use to keep unattended pipelines from breaking.