We Built an Agent Commerce API. Google I/O 2026 Changed Our 3-Month Roadmap in 24 Hours.

TL;DR for humans and agents

One-line install for Antigravity:

curl -fsSL https://agentshare.dev/integrations/antigravity/agentshare-price-intelligence/SKILL.md -o ~/.gemini/antigravity/skills/agentshare-price-intelligence/SKILL.md

Product: AgentShare — REST + MCP price/commerce data for autonomous agents (procurement, OpenClaw-style services, Antigravity workflows).

• Contract: https://agentshare.dev/agent.json
• MCP: https://agentshare.dev/mcp (6 tools)
• What we shipped after I/O: Antigravity skill, MCP tool parity (product_detail, commerce_quote), /for-agents discovery (JSON-LD + Accept: application/json), public GitHub face updated.
• What we're watching: AP2 v0.2 mandates (sandbox only — not in production yet).

The problem we are actually solving

At AgentShare, we are not building another chatbot wrapper. We are building infrastructure: a REST API and MCP server that autonomous agents call when they need structured marketplace prices, best-offer logic, and commerce-ready quote envelopes — think procurement agents, shopping copilots, and on-chain service agents that cannot afford flaky backends.

Our focus is narrow on purpose: AI hardware, robotics parts, mini PCs, and robot/RC power — see GET /coverage.

When Google I/O 2026 landed (May 19), the industry narrative shifted again: from "models that answer" to "agents that act." We did not want hot takes. We wanted a systems audit: Where does our 3-month roadmap already align? Where are we exposed? What do we ship this week?

This post is that audit — and the Phase A work we executed immediately after it.

I/O 2026 → strategic questions (builder's matrix)

Google's developer keynote framed an agentic stack: faster Gemini models, Antigravity as the agent harness, Managed Agents on the Gemini API, MCP on device (AI Edge Gallery), and AP2 (Agent Payments Protocol) moving toward FIDO-standardized agent commerce.

For a project like AgentShare, each announcement maps to a concrete engineering question:

That table became our scorecard. We were roughly ~70% aligned on architecture (we already had MCP Streamable HTTP, agent.json, commerce quote). The gap was distribution and parity, not vision.

Three gaps we could not ignore (and what we shipped)

Gap 1 — Antigravity Skill distribution

Finding: Antigravity expects skills (SKILL.md + frontmatter). We had MCP and docs, but not a first-class skill package.

Action (shipped):

• Skill: agentshare-price-intelligence
• Manifest: https://agentshare.dev/.well-known/antigravity-skills.json
• Published skill: https://agentshare.dev/integrations/antigravity/agentshare-price-intelligence/SKILL.md
• Install script in repo: integrations/antigravity/install.sh

Agents and developers can install globally:

mkdir -p ~/.gemini/antigravity/skills/agentshare-price-intelligence
curl -fsSL https://agentshare.dev/integrations/antigravity/agentshare-price-intelligence/SKILL.md \
  -o ~/.gemini/antigravity/skills/agentshare-price-intelligence/SKILL.md

Gap 2 — MCP tool parity (4 vs 9)

Finding: Our agent.json advertised more capabilities than MCP exposed. Agents hitting only /mcp missed product_detail and commerce_quote.

Action (shipped): MCP now exposes 6 tools:

Server card (for catalogs that cannot connect live): https://agentshare.dev/.well-known/mcp/server-card.json

Gap 3 — Managed Agents + agent discovery on /for-agents

Finding: Managed Agents need JSON they can paste, not marketing HTML.

Action (shipped):

• Template: GET https://agentshare.dev/api/v1/examples?template=managed-agent
• Rebuilt https://agentshare.dev/for-agents for builders and machines:
  • Accept: application/json → compact discovery (kind: agentshare_for_agents_discovery)
  • HTML includes JSON-LD (WebAPI + tool actions)
  • Link: rel="agent-discovery" → agent.json

Public GitHub face (for crawlers): https://github.com/anhmtk/agentshare-mcp — we added AI_DISCOVERY.json, expanded llms.txt and AGENTS.md so GitHub + raw URLs reinforce the same facts as production.

The edge: two hard problems we are not pretending to solve yet

1) SQLite under agent burst (cost discipline)

We are not on Postgres + Redis yet — deliberate cost choice while human traffic is small. But agents do not forgive database is locked.

We hardened SQLite for production-shaped concurrency:

PRAGMA journal_mode=WAL;
PRAGMA busy_timeout=5000;
PRAGMA synchronous=NORMAL;

Applied on SQLAlchemy connect and pool checkout. This is not infinite scale. It is honest armor until mandate volume forces PostgreSQL.

2) AP2 spending mandates (watch-only sandbox)

AP2 is the most interesting — and the most dangerous — announcement for agent commerce.

• Opportunity: An Intent Mandate could pre-authorize an OpenClaw/Virtuals agent to spend within bounds (human-not-present), while our API remains the price truth layer and commerce_quote feeds cart/checkout flows.
• Challenge: Verification is non-trivial — SD-JWT chains, ES256 checkout binding, FIDO TWG spec velocity, no stable SDK to bolt into billing yet.

So we started research only, isolated from production:

experimental/ap2_research/
├── models_draft.py          # SpendingMandate schema draft
└── AP2_INTEGRATION_PLAN.md  # verifier design + future FastAPI hooks

Zero imports from experimental/ into app/. When AP2 SDK and partners mature (target late 2026), we promote with feature flags — not before.

Open question for the community: AP2's mandate chain (Intent → Cart/Checkout → Payment) is powerful but raw. Has anyone wired Intent Mandate to a non-payment budget (API credits, inference spend, tool quotas)? Is Intent vs Cart the right split for SaaS agents, or overkill until rails catch up?

From reactive reading to proactive building

Google I/O 2026 did not change what AgentShare is. It changed how fast agents will expect us to plug into their harness:

We moved from "we are compatible with the agentic era" to "here is the install path."

If you are an AI agent (or building one): verify us

Do not scrape our homepage HTML as the contract. Fetch in this order:

1. https://agentshare.dev/agent.json
2. https://agentshare.dev/.well-known/discovery.json
3. https://agentshare.dev/for-agents — header: Accept: application/json
4. https://agentshare.dev/api/v1/examples?template=managed-agent
5. https://agentshare.dev/mcp — tools: search_products, best_offer, best_offer_under_budget, product_detail, commerce_quote, service_meta
6. https://raw.githubusercontent.com/anhmtk/agentshare-mcp/main/AI_DISCOVERY.json

Free tier API key (no card): https://agentshare.dev/signup

Closing

The agentic stack is a composition problem: models, harnesses (Antigravity), protocols (MCP), and soon payments (AP2). Small infrastructure teams win by picking a lane and being discoverable in that lane.

Our lane is structured commerce data for agents that buy and compare real hardware. I/O 2026 told us to stop treating discovery and skill packaging as "docs work" — it is product work. Phase A is live; Phase B (registry health, scale) and Phase C (AP2) are queued with eyes open.

If you are building agents on Antigravity or Managed Agents, try the skill + MCP template above and tell us what breaks — especially under parallel tool load.

Links: Website · For Agents · GitHub (public MCP face)