Agents & Manager Articles
Multi-agent development with Antigravity — Manager Surface leadership, orchestration patterns, loop prevention, and monitoring unattended runs.
Capping Parallel Agents With a Token Budget — Designing a Guard That Stops Runaway Cost
Running many agents in parallel quietly inflates your token bill. This is not about shrinking prompts — it is about a governance layer that meters spend in real time and cuts it off at a budget. Full design and TypeScript implementation, drawn from my own overnight jobs.
Rolling Back a Half-Finished Agent: Compensating Transactions for Partial Failure
When you let an Antigravity agent run work that spans several external systems, a failure in the middle leaves the world half-rewritten. Retrying doesn't fix that. Here is how to fold it back safely with compensating transactions (the Saga pattern), with TypeScript and real operational numbers.
Flow Control for Autonomous Agents: Backpressure and Queues That Keep Production Alive
Run several Antigravity agents at once and the problem stops being how smart they are and becomes how little your downstream can absorb. Here is a flow-control design — bounded queue, semaphore, token bucket, backpressure, dead-letter — with TypeScript and real numbers.
When the Antigravity Agent Says 'command not found' for node or python: Causes and Fixes
It works in your own terminal, but the Antigravity agent hits command not found. Starting from how PATH inheritance works, here are concrete fixes for nvm, pyenv, Homebrew, and WSL setups—plus how to confirm the fix actually took.
Build for the Day the Agent Breaks Something: Keeping Blast Radius Small
Once you let an Antigravity agent touch production, the problem stops being how smart it is and becomes how much it wrecks when it slips. Here is a four-layer containment design that shrinks blast radius, with TypeScript and real numbers.
Designing a Negative Spec for Antigravity Agents — The Forbidden-Territory List I Use Across 50M-Download Apps
Hand your Antigravity agents a list of things they must never touch — not just what they should do. Here is the FORBIDDEN.md template, subagent bootstrap, and reinjection script I run across 6 indie apps and 50M downloads.
Supervising Long-Running Antigravity Agents — Watchdog and Tiered Recovery
Eight weeks of running AdMob revenue optimization on Antigravity background agents revealed three quiet failure modes. Here is the watchdog plus tiered recovery design I landed on.
What Qwen3.7-Max's '35-Hour Autonomous Run' Means in Practice — Design Notes from an Indie Dev Running Both Antigravity and Claude Code
Alibaba's Qwen team published a demo where Qwen3.7-Max ran autonomously for about 35 hours and made over 1,158 tool calls. I walk through what that number means for a one-person shop using both Antigravity and Claude Code, and how to translate the design lessons into a personal evaluation set.
Forensic Audit Trail for Antigravity Background Agent — Cloudflare R2 logging that reconstructs decisions six months later
How to design a decision-log audit trail for long-running Antigravity Background Agents so you can still reconstruct why an agent did what it did six months later — schema, R2 write layer, PII masking, and Polars queries.
Orchestrating Six iOS App Updates in Parallel with Antigravity's Main and Sub Agents
Running six iOS app updates in parallel — new resolutions, Firebase SPM migration, StoreKit 2, and ATT ordering — with Antigravity's Main + 6 Sub agents. The notes on what to parallelize and what to keep serial.
Running 50+ AdMob Mediation Groups Alone: Four Tasks I Handed to an Agent, Four Decisions I Kept
Two wallpaper apps on iOS and Android put me past 50 AdMob mediation groups. Here are the four tasks I handed to an agent, the four decisions I kept, and the sample-size hole I later found in the evaluation code I had published.
Record & Replay for Antigravity Agents
How to deterministically replay a failed Antigravity Agent run offline, drawn from a month of running it across four production sites. Covers boundary recording, R2 + KV storage costs, PII masking, and a working TypeScript harness.
Splitting Pre-release QA Across Four Antigravity Subagents — A Design Note from a Solo Mobile Developer
A design note from a solo indie developer running six iOS / Android apps in parallel, sharing how Antigravity subagents are split into four parallel paths for pre-release QA. Covers the boundary decisions, prompt templates, termination rules, and merge logic with concrete examples.
Why Antigravity's Browser Sub-Agent Reads SPAs as Empty Pages — and Three Wait Strategies That Stuck for Me
When you hand an SPA dashboard to Antigravity's Browser Sub-Agent, get_page_text often returns before the real content is rendered, and the agent reports an empty page. Here is how I diagnose the symptom and the three wait strategies that have stabilized my routine.
Antigravity Multi-Agent State Tiers — A Three-Layer Design with Ephemeral, Journal, and Canonical
Before your Antigravity Background Agents and Sub-agents start mixing up their memory, split agent state into three lifetimes — ephemeral, journal, canonical — and map each to the right Cloudflare store. Includes a TypeScript approval gate for write-back, and what changed when headless runs stopped silently auto-approving.
Implementation Notes: Running AdMob Mediation A/B Tests with Antigravity Parallel Agents
Notes from automating AdMob mediation A/B testing using Antigravity parallel agents across an indie wallpaper-app portfolio with 50M cumulative downloads. Covers joint eCPM + ARPU optimization, the 7-day rotation pipeline, and the rollout design that does not break production.
Cost Attribution for Antigravity Agents — A Showback Architecture That Maps Execution Cost Back to Tenants Across Multi-Product Operations
A multi-tenant Showback architecture for Antigravity agents running across multiple products, with the schema, propagation patterns, and seven months of production numbers from running 4 sites and 6 apps in parallel.
Designing Antigravity Agents That Survive Multi-Hour Batches — A 4-Layer Durability Pattern From the Trenches
Long-running Antigravity batch agents will fail somewhere. After running them against the operations of an indie app business, I distilled four durability layers — checkpoint granularity, persistence choice, idempotent restore, and context summarization — into a single, opinionated design memo with working code and real cost numbers.
Handing Nightly Wallpaper Asset Updates to a Background Agent — Time Budgets, Duplicate Detection, and a Completion Gate
A reproducible account of handing nightly wallpaper asset updates to Antigravity's Background Agent. Covers how to write the task definition, perceptual-hash duplicate detection, one-pass resizing across 12 device profiles, a morning report you can review in five minutes, and the time-budget and completion-gate design that makes unattended runs safe.
Designing a 4-Tier Fallback Architecture for Antigravity Agents — Catching Model Degradation, API Outages, and Cost Overruns Across Layers
How to design a 4-tier fallback hierarchy for production AI agents on Antigravity, drawn from 24 months of running 11 agents across 6 indie apps. Includes the decision logic, code, and real demotion statistics.
Designing Knowledge Freshness for Antigravity AI Agents — A Runtime Architecture for Model Cutoffs, Corpus Staleness, and Real-World Time Drift
Antigravity agents have to juggle three independent time axes — model cutoff, RAG corpus update, real-world clock — or they will confidently cite six-month-old documentation. Here is the runtime architecture I use, with working TypeScript code and the TTL thresholds I run in production.
Letting Antigravity Background Agent Watch the First 72 Hours After Release: A Monitoring Pipeline Forged Across Six Wallpaper Apps
Drawing on twelve years of indie iOS and Android development and six wallpaper apps released in parallel, this article shares a release-monitoring workflow built on Antigravity Background Agent. It covers how to collapse Firebase Analytics, Crashlytics, and AdMob into one Markdown report, with the actual queries and thresholds used in production.
Prompt Caching and Context Strategy for Antigravity Agents — Cutting 60-80% Off Monthly API Costs in Long-Running Production
The longer you keep agents running, the more the monthly invoice quietly piles up. Running Antigravity agents alongside an AdMob-monetized indie app business (50M cumulative downloads), I managed to cut API costs by 60-80% by rebuilding prompt caching and context strategy. This article shares the three-layer cache, context compression, and TTL design I now run in production — with the code and numbers behind them.
Designing an HITL Approval Pipeline That Survives Production — Routing Probabilistic Actions Safely With Antigravity Agent
How I run a Human-in-the-Loop approval pipeline for Antigravity Agent in production — risk tiers, confidence-based routing, queue schema, audit logs, and the graduation criteria that move actions toward automation, drawn from six months of indie-app operations.
Splitting Daily Crashlytics Triage Across Five Antigravity Sub-Agents
Running six indie iOS and Android apps, the morning Crashlytics triage was draining me. I split the workflow across five Antigravity sub-agents (Fetcher, Classifier, Repro, Patch, PR) and locked their input and output to JSON schemas. Two weeks of production data shows where the human review boundary belongs.
Integrating Antigravity Agents into My Android Release Workflow — 3 Months of Honest Findings
Three months of running Antigravity Agents inside my Android release flow: where crash diagnosis landed, where it missed, how I turned staged-rollout Go/No-Go into a threshold dialog, and the context checklist that decides diagnostic accuracy.
Telling AI Agents 'Why' — 5 Context Design Principles to Prevent Misjudgment
When AI agents write correct code for the wrong job, the root cause is usually that you told them What but not Why. This guide covers 5 intent-context design principles for Antigravity agents, with practical patterns for AGENTS.md, task instructions, and error diagnostics.
What I Delegated to an AI Agent — And What I Should Have Kept
Delegating production work to an Antigravity agent taught me where the line sits between what an agent should own and what I have to decide myself. Here's the framework — and the gate script — I now use before handing off any task.
Tracking AI Agent Decisions in Antigravity: Implementing Decision Logs and Explainability
Learn how to design decision logging systems that capture why your AI agents make specific choices. Includes working Python code examples, Before/After patterns, and a quality improvement cycle for production Antigravity agents.
Canary Deployment with Auto-Rollback for AI Agents — Protecting Production with Antigravity and Burn-Rate SLOs
A practical playbook for shipping new AI agent versions through canary deployment on Antigravity, with automatic rollback driven by burn-rate SLOs. Includes a lightweight setup that solo developers can sustain.
Defining 'Done' with Antigravity Agents: Writing Acceptance Criteria into Your Prompts
When Antigravity returns code that is only halfway working, the usual cause is a missing Definition of Done. Here is the three-layer fix.
Resolving AGENTS.md Precedence Conflicts in Antigravity Monorepos
When you place AGENTS.md in both the repo root and a subfolder, Antigravity merges them — but the agent often follows the wrong one. Here is how the precedence actually works, with concrete patterns to remove the conflict.
Giving Your Antigravity AI Agents a 'Time Budget' — A Production Scheduling Design That Unifies Timeouts, Priorities, and Deadlines
Your AI agent's response time creeps up, users drop off, and unexpected costs pile on. Here is how I give Antigravity agents a single 'Time Budget' object that unifies timeouts, priority, and deadlines, plus the traps I hit after half a year in production.
Why Antigravity Agents Can't Read Your .env File — Three Propagation Paths to Check First
When an Antigravity agent fails with Missing API_KEY but the same build works in your terminal, the cause is one of three env propagation paths. Diagnose each.
Designing Confidence Scores for Antigravity Agent Outputs: Auto-Approve the Certain, Escalate the Ambiguous
Reviewing every Antigravity Agent output by hand does not scale. Attach a confidence score to each output, auto-approve the certain ones, and only escalate the ambiguous to humans. This guide walks through implementation and threshold calibration end to end.
The Self-Critique Architecture for AI Agents — Four Reflection Patterns That Make Antigravity Outputs Trustworthy
Four production-tested patterns for adding self-critique loops to Antigravity agents, with implementation code, stopping conditions, confidence calibration, and cost-control strategies.
Replay-Driven Agent Design — Time-Travel Debugging for Production AI Agents
Reproduce one-off agent failures from production on your laptop. A practical three-layer replay design — event, state, and decision — built on top of Antigravity's Manager Surface, with TypeScript code you can drop into your own stack.
Giving AI Agents an Aesthetic Sense — Building a UI Quality Evaluation Pipeline with Antigravity × Gemini Vision
Explore how to encode the vague judgment of 'is this UI good or bad' into code. Combines Antigravity with Gemini Vision to implement a complete pipeline — from screenshot capture to AI evaluation, improvement suggestions, automated fixes, and CI/CD integration.
Enterprise Multi-Agent Skill Management with gh skill — Profiles, CI Validation, and Cross-Agent Consistency
A complete architecture for managing SKILL.md across multi-agent teams. Covers role-based skill profiles, three-layer agent compatibility design, GitHub Actions CI validation, and automated release notifications.
gh skill: Sharing AI Agent Knowledge Across Claude Code, Copilot, Cursor, and Gemini CLI
The gh skill GitHub CLI extension lets you package SKILL.md definitions and distribute them across 30+ AI coding agents. Here's how it works and how to get started.