Combining All Four Antigravity Surfaces in One Project — Up to Running Your Own SDK Agent

Run a minimal custom agent with the SDK

The SDK sits at the center of the automate phase. The official Antigravity SDK is a Python library; you write an agent locally and run it on the same shared harness. I recommend starting from the smallest thing that just asks "what files are in the current directory?"

import asyncio
from google.antigravity import Agent, LocalAgentConfig
 
async def main():
    config = LocalAgentConfig(
        system_instructions="You are an expert assistant for codebase navigation.",
        # api_key="your_api_key_here",
    )
    async with Agent(config) as agent:
        response = await agent.chat("What files are in the current directory?")
        print(await response.text())
 
if __name__ == "__main__":
    asyncio.run(main())

The point is wrapping the agent lifecycle in async with. An agent holds background sessions and file handles, so a context manager guarantees cleanup the moment the work ends. I recommend keeping your first one in exactly this shape.

Grow it toward your own routine

Once the minimal version runs, bend system_instructions toward your repeated work. In my case, I grew it into an agent that checks whether the code examples in an article actually run. The idea is to replace generic instructions with concrete checklist items.

INSTRUCTIONS = """\
You are a code-example reviewer for a technical blog. Follow these steps.
1. Extract the code blocks and detect the language
2. Confirm the syntax holds together
3. Flag clearly broken dependencies or undefined variables
4. Propose a fix as the smallest possible diff
Reply as a bulleted list, avoid over-asserting, and give your reasoning.
"""
 
async def review_snippet(code: str) -> str:
    config = LocalAgentConfig(system_instructions=INSTRUCTIONS)
    async with Agent(config) as agent:
        response = await agent.chat(f"Please review the following code:\n\n{code}")
        return await response.text()

Even a wrapper this thin automates one step I used to do by hand every time. I folded it into my pre-publish check and cut the per-article review time roughly in half by feel. The realistic on-ramp is not to chase a grand autonomous agent, but to offload exactly one small chore you already do daily.

Stop an async agent safely

The thing people stumble on most with the SDK is stopping the agent. When you cut a long-running async task short, neglecting cleanup leaves the session dangling. Alongside async with, keep explicit cancellation and a timeout on hand.

async def review_with_timeout(code: str, timeout: float = 30.0) -> str:
    try:
        return await asyncio.wait_for(review_snippet(code), timeout=timeout)
    except asyncio.TimeoutError:
        return "Review timed out. Split the code and retry."
    except Exception as e:
        return f"An error occurred during review: {e}"

Wrapping with asyncio.wait_for avoids the case where no response comes back and the process locks up. If you fold this into a production pipeline, the guarantee that it always returns in finite time is non-negotiable.

Three pitfalls that bite on production deploy

Moving a locally working agent straight to production, here are the three I actually hit.

First, API key handling. Always switch the commented-out api_key from the sample to reading an environment variable in production. Pushing it hardcoded trips secret scanning and invites accidents. I keep keys in environment variables and leave only placeholders in the repo.

Second, concurrency control. Throwing many snippets at once opens too many agent sessions in parallel and hits rate limits. Capping concurrency with asyncio.Semaphore is the practical workaround.

Third, failure fallbacks. Assume the agent's response may be empty or malformed, and prepare hold-and-retry paths. In my setup, if a review returns an error, I stop the article and route it to manual review — the safe side. I consider automation production-grade only when it is designed not to cause damage when it stops.

Where to start building

Trying to master all four surfaces at once will, paradoxically, stall you. My recommended order: run your daily work as a round trip between 2.0 and the IDE, add the CLI when server checks appear, and once a daily-repeated step comes into view, automate exactly one of them with the SDK.

I myself tried to build a grand agent platform up front, failed, and rebuilt from "delete one small daily chore." The strength of sharing a harness is precisely how easy this incremental growth becomes. Picture the one step you find most tedious today, and start building there.