Your Company Might Have Just Bought You an AI Agent

If your organization uses Google's enterprise suite, you may now have access to an autonomous coding agent without a new procurement cycle. Google recently bundled its Antigravity agent into Gemini Enterprise subscriptions at no additional cost. This is a quiet but significant move to make agentic workflows a default part of the enterprise developer toolkit, shifting the barrier from budget approval to practical implementation.

what just changed

The core update is simple: Google's autonomous coding agent, Antigravity, is now included with Gemini Enterprise Standard and Plus subscriptions. For developers at companies with these plans, an administrator can now enable access to the agent directly within the tools you already use, including VS Code and JetBrains IDEs.

This removes the primary friction that has kept agentic tools in the experimental phase for many teams: the need for a separate budget, security review, and procurement process. Instead of being an optional add-on, it's now part of the core enterprise AI subscription. The tool is likely already there, and the main hurdle is learning how to use it effectively.

this is not another copilot

It is important to distinguish this from line-by-line code completion. Antigravity is positioned as an autonomous agent, designed for multi-step reasoning and workflow orchestration. This is about offloading entire tasks, not just suggesting the next few tokens. The system is designed to generate code, debug issues, and manage complex workflows that span multiple steps and tools.

Google appears to be building this around a concept of "agentic skills"—packaged sets of instructions and resources that teach an AI how to complete a specialized task. The goal is to move beyond simple code generation and toward repeatable, auditable, autonomous operations. For a builder, this means focusing more on high-level design and problem-solving, while the agent handles the boilerplate and implementation details.

the enterprise guardrails are the real story

The most significant part of this announcement for professional engineers is not the agent itself, but the governance framework surrounding it. Shipping autonomous agents in an enterprise environment without strict controls is a non-starter. Google is bundling the tooling with a suite of security and governance features designed for corporate oversight.

These controls are what make agentic AI viable in a production setting. They include features like:

• Agent Identity: Essentially, non-human IAM roles with cryptographic IDs to create an auditable trail of all actions and reasoning.
• Agent Registry: A centralized place to manage approved agents, skills, and tools, preventing the use of unauthorized integrations.
• Agent Gateway: A proxy to enforce security policies and actively block potentially destructive actions.

These features signal a maturity in the deployment of agentic systems. The controls exist because real incidents have justified their need. A developer using these tools can operate with more freedom, knowing that a safety net is in place. A conceptual policy for such an agent might look something like this:

# A conceptual policy for an Antigravity agent.
# This is illustrative, not a real API configuration.
agentPolicy:
  version: 1
  agentId: "prod-release-validator-v3"
  iamRole: "arn:gcp:iam::project-id:serviceAccount/agent-runner"
  allowedTools:
    - "gcr-image-scanner"
    - "jira-ticket-updater"
    - "github-status-check-api"
  deniedSystemCalls:
    - "network.socket.create"
    - "filesystem.write_unrestricted"
  resourceLimits:
    maxTokensPerRun: 4000000
    maxRunDuration: "60m"
  auditLog:
    destination: "gcp:logging:prod-security-audits"
    level: "FULL_REASONING_TRACE"

This is the infrastructure that allows agents to move from personal productivity tools to integrated components of a team's software development lifecycle.

what this means for you

The bundling of autonomous agents into core enterprise software subscriptions marks an inflection point. The discussion is no longer about whether to trial these tools, but how to build systematic capability around them. The most effective teams will be those that establish clear policies for agent access, logging requirements, and processes for critically reviewing agent output.

The era of AI agents as experimental, separately-billed tools is ending. They are becoming a standard, bundled component of the developer platform. The challenge is no longer gaining access to the technology, but developing the skills and discipline to wield it effectively.

Sources

• Google Cloud Blog