Agents & Manager Articles
Multi-agent development with Antigravity — Manager Surface leadership, orchestration patterns, loop prevention, and monitoring unattended runs.
Turning Gut-Feeling Judgments into Rules an Agent Can Actually Follow
A small, repeatable way to turn the judgment calls that live only in your head into written rules an Antigravity agent can apply, with a quick check against past cases.
Stopping One Sub-Agent Without Taking the Other Seven Down With It
One of eight parallel sub-agents went wrong and I wanted to stop only that one. Here is how Antigravity, Claude Code, and Gemini CLI differ in what a stop actually stops, and the per-child output layout plus merge script that keeps a halted child's partial files out of the rest.
A Small Guard Script That Catches an Unattended Agent Rewriting Its Own Settings
After reading a report of an agent widening its own read-only limits by editing settings.json, I wrapped my overnight headless runs in an outside guard. Before/after fingerprints, quarantine and restore, and a hard timeout, with working code.
When an Antigravity Scheduled Task Never Runs: Check sidecar.json, Then enabled, Then the Logs
A checking order for Antigravity 2.0 Scheduled Tasks that quietly do nothing: where sidecar.json lives, how the directory name becomes the ID, the enabled flag in config.json, and the logs under sidecar_data.
Before I accept what /boost says it verified, I count what its throwaway worktree never saw
Antigravity's /boost runs its tests inside an ephemeral isolated worktree. If your build reaches for files git never tracked, that verification passed on a different tree than yours. Here is how I measure the gap first.
I count the posts three times before flipping a WordPress host migration
The copy-complete notice from a shared host is a snapshot taken when the copy started, not when it finished. Here is the full enumeration I run before the cutover, and where I stop delegating.
With scheduled agents, I now look for runs that never happened before I look for failures
My run ledger showed a 100% success rate while the evening slot had not fired for two weeks. Here is the reconciliation I now run against an expected-fire table, with measured notes on cron expansion, exit codes, and how the ledger itself gets written.
A Custom Tool That Says any_of Loses Its Constraint Without Ever Erroring
I tested ten spelling variants in custom tool parameter definitions to see which ones fail loudly and which slip through unnoticed, then measured how argument validation shifts once normalization lands.
Snapshot Your Agents' Effective Scope So You Notice the Day a Default Changes
Antigravity 1.1.25 made Markdown-defined custom agents inherit the surrounding skills, rules, and subagents by default. Here is the snapshot-and-diff routine I now use to check whether an agent I meant to keep narrow quietly got wider after an update.
Write Hundreds of Files in One Burst, or Space Them Out?
When an agent generates hundreds of files, the slowness usually is not the writing. It is the rescans on the watcher side. I measured four write patterns so you can decide where to batch.
What @ Includes Actually Shrink When You Split Agent Rule Files
I split my rule files using Antigravity 2.11.0's @path/to/file includes and measured the before and after across four real repositories. Maintenance surface dropped 62 percent. What a session actually reads dropped 1.7 percent. Here is why, plus the code that catches the silent failure mode.
Git Tracks the File, but Your Agent Can't See It. Here's Where It Drops Out
An agent's code search returned two files. git grep returned six. I traced the three paths that quietly drop tracked files out of search, measured them on a synthetic repo and a production one, and worked out how to spot the gap in a single line.
Why I Check Description Overlap Before Turning On inheritCustomizations
CLI 1.1.14 collapsed markdown agent inheritance into a single inheritCustomizations switch. Here is what happened when I actually inventoried the 47 skills in my workspace and decided the switch on description overlap rather than on context size.
When a Subagent Never Finishes, Look at the Parent's Unapproved Artifacts First
A subagent that runs all night and never returns is usually not the one that is stuck. Here is how I separate a blocked parent from a blocked child using a short log-scanning script, where the new always proceeds mode helps, and where I stop letting approvals happen automatically.
Android 17 Went Canary-Only, So I Gave My Agent the Silence Rules First
Android 17 dropped Developer Previews in favour of rolling Canary builds, which moved the verification deadline onto my side of the table. Here is how I handed the tracking job to an Antigravity agent by designing when it stays quiet, not when it reports.
I Asked the Agent to Pick Tests From My Diff and It Said "None" Nine Times Out of Ten
Change-based test selection returned zero tests for most edits. Measuring how far an import graph actually reaches across three repositories, and rebuilding the selection contract around it.
Reading the Same History in 38 Seconds — or 0.4: Handing a Read-Only .git to Your Agent
Antigravity CLI 1.1.10 lets the sandbox read .git without write access. I built a per-session history summary two ways, measured a roughly 100x speed gap, traced it to process spawn cost, and added a guard for shallow clones that silently corrupt the numbers.
A Typo in agent.md Quietly Widened My Permissions — Writing a Strict Frontmatter Lint
Misspelled keys in agent.md frontmatter do not raise errors. They fall back to defaults, and for permission fields that fallback points the wrong way. Here is the failure I hit, the lint I wrote to catch it, and what the measurements showed.
The night my agent shipped nothing: giving generation agents an abstain outcome
When you score a background generation agent by how much it produces, the quality gate quietly loosens over time. Here is a three-valued ACCEPT / ABSTAIN / REJECT design that counts a zero-artifact run as a success, with the code and the measurements from running it.
Leasing Runtime Environments to Parallel Agents: Port Ranges, DB Schemas, and Dev Servers, One Per Agent
When Antigravity 2.0 runs agents truly in parallel, they collide on the same port, database, and dev server. Here is a lease-based design that hands each agent its own isolated environment, with implementation and measured numbers.
The Morning It Wrote Outside the Working Folder: Vetting Every Write Path in One Function
Antigravity CLI 1.1.3 closed a bug where always-proceed mode silently auto-approved writes outside the workspace. Here is a small guard that vets every write path with nothing but path canonicalization and a containment check, plus an escape-attempt test suite.
Treating Code Search as a Contract: Measuring the /codesearch Regex Default
Antigravity CLI 1.1.3 interprets /codesearch queries as regular expressions by default. I measured the gap between regex and literal matching across a 979-article repository and turned the results into three query rules and a drift harness.
Three Quarters of My Reference Notes Never Reached the Agent: Measuring What head Cuts Away
I fed reference notes to a scheduled agent with cat and head, and the lines that mattered were quietly cut. Here is the measurement, and how I replaced a line count with a section-level contract.
The More I Wrote in AGENTS.md, the Less Got Followed — Measuring Adherence and Cutting Rules
The rules in my AGENTS.md were being ignored — not from precedence conflicts or load failures, just plain ignored. Here is how I turned rules into checkable predicates, measured adherence over three weeks, and cut the file in half.
When to Hand Your Agent the Next Instruction: Waiting, Interrupting, and Queuing, Measured
Antigravity v2.3.0 added message queuing and Send Now. I measured waiting, interrupting, and queuing against the same yardstick, found that 41% of queued instructions arrive stale, and cut rework from 22% to 9% with a twenty-line stamp.
When Your Agent Commits a .bak File: Why Fix-Tool Artifacts End Up in Git
Backup files like .bak and .orig slip into commits after an agent runs a --fix tool. Here are the reproduction conditions, the real root cause, and three fixes: narrowing the staged scope, wrapping the fixer, and adding a pre-commit extension gate.
The File Is Right There in ls, and Your Agent Still Can't Open It
The agent says the file does not exist. Your terminal says it does. After three days of blaming cloud sync, the answer turned out to be that one voiced consonant mark was never a single character. Detection script and a three-layer gate included.
I Changed One Line in AGENTS.md and Broke the Agent — Regression-Testing the Instructions Themselves
Every time you edit the instructions you hand an agent — AGENTS.md, skill text — some other task quietly breaks. Here is a regression harness whose subject is the instructions, not the code: fixed tasks, deterministic assertions, and a way to wire it into unattended runs.
Passing API Keys to Agents Safely: Runtime Env Injection and Log Redaction
How to hand secrets to an Antigravity agent without leaving them in your repo or your logs, using runtime environment injection and output masking.
What to Delegate to an Antigravity Agent and What to Keep by Hand, After Two Weeks
After two weeks of handing my daily solo-dev tasks to Antigravity agents, a clear line emerged between the work I was glad to delegate and the work I had to pull back. A retrospective with the operational log.
The Scarier Permission Was Reach, Not Write: Locking an Agent's Outbound Traffic to an Allowlist
When I hand real work to an agent, the thing I guard most isn't file edits, it's where it connects. Here is an 80-line deny-by-default egress gate, plus what 21 nights of unattended runs revealed about the traffic I never saw.
Clock Design for Agents: Separating Monotonic and Wall Time to Protect Long Runs
In scheduled and overnight agent runs, computing timeouts, retry backoff, and rate-limit windows from the wall clock breaks in quiet, hard-to-debug ways. This piece walks through a small Clock abstraction that splits monotonic from wall time, with a decision table and testable code.
When A2A Tasks Sat Stuck in 'working' — Field Notes on Tracing State Transitions to Detect Stalls
Antigravity's A2A coordination fails less by crashing and more by sitting in 'working' without progress. This walks through recording state transitions as one timeline and naming a stalled task down to which agent and which edge froze, along with what running agents daily has taught me.
Tracing Why an Agent Wrote That Line Six Months Ago — Commit Granularity and Provenance Trailers
When an agent packs 14 files and 800 lines into a single commit, git blame tells you nothing six months later. Here is how I split commits at intent boundaries, recorded provenance as machine-readable Git trailers, and built a one-command path from a blamed line back to the design decision behind it.
When Your Agent's Files Vanish Into .gitignore — A Pre-Commit Detection Gate
When an agent writes files that match .gitignore, the diff review looks perfect but nothing lands in the commit. Here is a gate script that catches ignored build output before you push, plus the tuning it needs.
Measuring the Rework Rate of What You Delegate to Agents: Drawing Delegation Boundaries with Numbers, Not Instinct
How much should you hand to an agent? I drew that line by instinct for a long time. Here is a practical way to compute a per-category rework rate from your git history and redraw the delegation boundary with numbers, with working code.
When Parallel Agents Ran the Same Task Twice and Quietly Doubled the Bill — Field Notes on Measuring and Stopping Duplicates
The bill for our parallel agents came in about 1.9x higher than expected — because multiple workers were running the same task twice. These are field notes on measuring the duplication, stopping it with idempotency keys, and attributing cost per task.
Never Miss a Managed Agent Completion: Pairing a Serverless Receiver with Polling Reconciliation
A cloud Managed Agent can finish while you are not watching, and the webhook that should tell you can quietly fail. Here is a serverless receiver on Cloudflare Workers paired with polling reconciliation, and a state machine that recovers every completion within minutes.
Protecting Your Agent Stack's Known-Good State with a Single Lockfile — Change-Budget Design for an Era of Simultaneously Moving Parts
When the IDE build, CLI, model, and dependencies all move at once, you can no longer tell which one caused a regression. Here is a change-budget design that pins your known-good state to one lockfile, with working code and operational logs.
Make the Self-Debugging Agent Walk the Logged-In and Post-Paywall Screens
By default, Antigravity 2.0's real-browser self-debug only sees the logged-out free view and reports success. To catch billing regressions, inject an authenticated session and paid state into the agent's browser and force coverage with assertions.