Publish AI Agents on Gemini Enterprise & Google Cloud Marketplace

The SaaS pond is evolving into AaaS—Agents-as-a-Service. Instead of isolated apps, developers are crafting AI agents that chat using open protocols like Agent2Agent (A2A) and get orchestrated on platforms like Gemini Enterprise. If you’re building high-quality agents that combine autonomy with reliable multi-step workflows, this guide is your map to publishing and selling them on Google Cloud Marketplace and deploying them to the Gemini Enterprise app.

Step 1: Design Your Agent Architecture

Your end-state architecture bridges Google Cloud Marketplace billing, identity provider security, and the Gemini Enterprise Agent Platform. Here’s what you need:

• Customer project: Where users discover agents via the dedicated Agent Marketplace category and interact through the Gemini Enterprise app.
• Partner project: Hosts your agent and the marketplace handler for procurement logic and Dynamic Client Registration (DCR).
• Partner Marketplace project: Manages the Partner Procurement API and Pub/Sub topics for events like account creation or entitlement approvals.

Step 2: Meet Organizational Requirements

Before diving in, make sure your capybara den is in order:

• Join the Google Cloud Partner Network.
• Review the listing requirements for Agent-as-a-Service.
• Accept the Marketplace Vendor Agreement (MVA).
• Nominate your agent by contacting your Google Cloud representative.

All agents must also comply with these agent-specific mandates:

1. Define your agent use case: Target high-value enterprise functions that solve tangible pain points.
2. A2A protocol adherence: Comply with the A2A spec, including A2UI for rich interfaces.
3. A2A Agent Card: Create a JSON file declaring capabilities, authentication, and endpoints.
4. Authentication: Support public access or OAuth 2.0 Authorization Code Grant Flow.
5. Marketplace integration: Integrate with Procurement APIs and Pub/Sub for entitlement lifecycle.

Step 3: Technical Requirements

A2A Protocol

Follow the A2A protocol documentation for interaction patterns like streaming or async tasks. Use A2UI to leverage advanced UX controls—dynamic charts and modern interaction models—so your agent feels premium inside the Gemini Enterprise app.

A2A Agent Card

Your Agent Card is a JSON file that declares skills, authentication methods, and endpoints. The Gemini Enterprise app uses it to display metadata, locate DCR endpoints, discover entry points, and determine auth methods. Here’s a sample structure:

{
    "name": "AI Agent Example",
    "protocolVersion": "1.0",
    "description": "Marketplace agent example.",
    "url": $AGENT_APP_URL,
    "preferredTransport": "JSONRPC",
    "provider": {
        "organization": $AGENT_PROVIDER_ORGANIZATION,
        "url": $AGENT_PROVIDER_URL
    },
    "version": "1.0.0",
    "capabilities": {
        "streaming": false,
        "pushNotifications": false,
        "extensions": [
            {
                "uri": "https://cloud.google.com/marketplace/docs/partners/ai-agents/setup-dcr",
                "params": {
                    "target_url": $AGENT_DCR_URL
                }
            }
        ]
    },
    "defaultInputModes": ["application/json"],
    "defaultOutputModes": ["application/json"],
    "skills": [
        {
            "id": "current_time_generation",
            "name": "Current time generation",
            "description": "Generates a current time.",
            "tags": ["time"],
            "examples": ["What time is it?"]
        }
    ],
    "supportsAuthenticatedExtendedCard": false,
    "iconUrl": $AGENT_ICON_URL,
    "security": [
        {"oauth2": [$AUTH_SCOPE]}
    ],
    "securitySchemes": {
        "oauth2": {
            "type": "oauth2",
            "flows": {
                "authorizationCode": {
                    "authorizationUrl": $AUTHZ_URL,
                    "tokenUrl": $TOKEN_URL,
                    "refreshUrl": $REFRESH_URL,
                    "scopes": {
                        $AUTH_SCOPE: $AUTH_SCOPE_DESCRIPTION
                    }
                }
            }
        }
    }
}

Replace placeholders like $AGENT_APP_URL with your actual endpoints.

Authentication and Authorization

Implement either public access (no auth, for non-sensitive agents) or OAuth 2.0 Authorization Code Grant Flow. For the latter, use Dynamic Client Registration (DCR) to let Gemini Enterprise programmatically register as an OAuth client. The flow: Gemini reads your Agent Card, sends a JWT-signed request, your backend validates it, and returns a client_id and client_secret. Remember to cross-reference the google.order ID against your database to ensure payment.

Step 4: Publish Your Agent Listing

Head to the Producer Portal in Google Cloud Console:

1. Select Solution Type: Choose “AI Agent as a Service”.
2. Upload Agent Card: Provide the JSON via a GCS bucket.
3. Availability: Choose self-service public pricing or private offers.
4. Pricing: Pick a pricing model.
5. Technical Integration: Configure backend procurement (no frontend needed).
6. Validation: Google reviews functionality, security, and pricing.
7. Publish: Your agent goes live on Marketplace.

Step 5: Manage Transactions and Registrations

The lifecycle involves three personas: Billing Administrator (financial oversight), Discovery Engine Administrator (technical gatekeeper), and Discovery Engine User (end user).

1. Procurement Flow (Async)

1. Trigger: Customer clicks “Subscribe” or accepts a private offer.
2. Notification: Google sends a Pub/Sub notification.
3. Approval: Your handler approves via the Partner Procurement API.
4. Activation: Store the Order ID in a database like Firestore to activate the subscription.

2. Registration Flow (Sync)

1. Redirect: Discovery Engine Admin sees “Go to Gemini Enterprise” on the listing.
2. Project Verification: Admin logs into the Google Cloud project linked to the billing account.
3. DCR Handshake: Your DCR logic validates the JWT’s Order ID against Firestore.
4. Agent Registered: Admin can now grant access to users.

3. End-User Activation Flow

• Discovery: End users browse agents in the Agent Gallery and request access.
• Access: Once granted, users with Discovery Engine User role can invoke the agent.
• Authorization: First interaction prompts OAuth login; after that, they can chat away.

Get Started

Building agents for Gemini Enterprise and Google Cloud Marketplace opens the door to millions of enterprise users. Start with the Agent Development Kit (ADK) and learn more about accelerating your growth in the agentic era. Need help? Contact the Google Cloud Marketplace support team.

Original announcement published on Google Cloud.