28. From Raw LLM APIs to Antigravity Plugins: The Evolution of Agentic Engineering

While I worked at Google during the publishing of this post / video, the views expressed here are my own and may not reflect those of my employer. Only publicly available material is used to put together the content of this article and video. The website and the Youtube videos are NOT monetized.

It’s fascinating to trace how quickly AI application development has evolved over the past two years. Not long ago, building with LLMs meant writing raw API calls and wrestling with prompt strings. Today, we install modular Antigravity Plugins into an agent harness and have a fully autonomous, production-ready workflow running in minutes.

How did we get here? Let’s trace the journey.

The Evolution: Raising the Programming Boundary

The programming boundary hasn’t disappeared; it has moved upward. Instead of repeatedly writing lower-level execution loops, the agent runtime (the harness) has absorbed the plumbing.

The Core Epiphany: Programming the Environment

We are no longer programming agents from scratch. We are programming the environment in which general-purpose agents operate.

Think of modern agent architectures like an operating system:

• The Harness (Antigravity App / CLI / IDE / VS Code Extension): The operating system kernel. It handles context windows, tool routing, subagent lifecycles, and permissions.
• The Agent: The cognitive decision maker running inside the harness.
• The Plugin: The installable application package.

                       ANTIGRAVITY PLUGIN
                               │
        ┌────────────────────────┼────────────────────────┐
        ▼                      ▼                      ▼
    KNOWLEDGE              BEHAVIOR                 TOOLS
   (The Brain)            (The Persona)          (The Hands)
        │                      │                      │
  skills/ & rules/       agents/, commands/,      mcp_config.json
                         & hooks.json

A plugin is not just a prompt. As documented in the Antigravity Plugin Specification, it bundles everything an agent needs in a domain:

1. Skills (skills/*/SKILL.md): Reusable domain SOPs and procedural workflows.
2. MCP Servers (mcp_config.json): Live tool integrations over HTTP, SSE, or stdio.
3. Subagents (agents/*.md): Specialized persona delegations (e.g., QA vs. Project Manager).
4. Commands (commands/): User-facing slash shortcuts (e.g., /tasktracker:triage).
5. Rules (rules/AGENTS.md): Workspace constraints and guardrails.
6. Hooks (hooks.json): Deterministic lifecycle checks (e.g., pre-tool safety gates).

All-in-One Reference Implementation: agy-plugin

To illustrate this end-to-end, we bundled everything into a single repository — the target application, the MCP server, and the complete Antigravity plugin — in agy-plugin:

• 🌐 1. Web Application (app/): A clean Flask TaskTracker CRUD app with JWT and API-key authentication.
• 🛠️ 2. FastMCP Server (mcp/): Exposes the application’s REST APIs as standardized MCP tools over Streamable HTTP and SSE.
• 📦 3. Antigravity Plugin (plugin/): Packages the runbook skills, triage subagents, slash commands, audit hooks, and MCP configuration into one unit.

Cross-Surface Compatibility

One of the best design features of Antigravity plugins is universal surface portability. The exact same plugin works seamlessly across:

• Antigravity CLI (agy): For terminal power-users and shell scripting.
• Antigravity IDE & App: Loaded natively via the Customizations tab or workspace .agents/plugins/.
• Antigravity VS Code Extension: Automatically discovered in your project workspace.

Quick Start: Testing & Validation

Clone the reference repository first, then run the services and validate the plugin directly from within the cloned directory:

# 1. Clone the reference repository & navigate into it
git clone https://github.com/nikhilpurwant/agy-plugin.git
cd agy-plugin

# 2. Start the TaskTracker Web App (Terminal 1)
cd app && uv run app.py

# 3. Start the FastMCP Server over HTTP (Terminal 2)
cd mcp && uv run server.py --transport http --port 8080

# 4. From the agy-plugin root, validate the plugin structure (Terminal 3)
agy plugin validate ./plugin

When validating, agy parses and verifies every component in your plugin bundle:

  [ok]    ./plugin
          ✔ skills      : 2 processed
          ✔ agents      : 2 processed
          ✔ commands    : 1 processed (converted to skills)
          ✔ mcpServers  : 1 processed
          ✔ hooks       : 4 processed

To install and activate the plugin from the repository root:

# Option A: Install globally via Antigravity CLI
agy plugin install ./plugin

# Option B: Declarative workspace discovery (zero tooling needed)
# Simply copy the plugin folder into your target project's .agents/plugins/ directory
mkdir -p /path/to/your/project/.agents/plugins
cp -r ./plugin /path/to/your/project/.agents/plugins/tasktracker

Once installed, simply ask the agent in natural language:

“Triage our critical unassigned issues and run the system health check."

The harness dynamically resolves the intent, lazy-loads the triage skill, delegates to the QA subagent, queries the FastMCP server, and enforces your workspace rules — all without writing a single line of agent loop code.

Demo Video

Please watch in full screen or on youtube directly

For complete specs and guides, check out the official Antigravity Plugins Documentation.

Thank you for reading! Feel free to explore the code in agy-plugin and share your thoughts.

— Nikhil