DEV Community

anhmtk
anhmtk

Posted on • Originally published at agentshare.dev

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

#googleiochallenge #ai #mcp #agents

Google I/O Writing Challenge Submission

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
Enter fullscreen mode Exit fullscreen mode

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:

I/O 2026 signal What it means in the market Strategic question for AgentShare
Gemini 3.5 Flash — speed + agentic workloads Agents will issue more tool calls per task Can our API + MCP stay low-latency under burst traffic without Postgres/Redis on day one?
Antigravity 2.0 + SDK + CLI Skills become the distribution unit for agent behavior Should we publish an official Antigravity skill that wires our MCP URL + auth?
Managed Agents (Gemini API) One API call → provisioned agent + sandbox Do we offer a copy-paste MCP template so builders do not re-invent config?
MCP in AI Edge Gallery On-device agents call remote MCP over Streamable HTTP Are our MCP tools complete vs our REST/agent.json contract?
AP2 v0.2 + FIDO donation Cryptographic mandates for human-not-present spend Is our credit/billing model compatible with Intent/Cart mandates later — without breaking PayPal/VNPay today?
Vibe coding / AI Studio → Antigravity Developers skip boilerplate integration Is our discovery layer good enough for agents that never read human docs?

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):

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
Enter fullscreen mode Exit fullscreen mode

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:

MCP tool When to use
search_products Compare multiple listings
best_offer Single cheapest in-stock offer
best_offer_under_budget Budget-constrained procurement
product_detail Drill-down after search returns an id
commerce_quote ACP-style agentshare.price.v1 envelope for agent buyers
service_meta Capabilities and limits

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;
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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:

Before I/O After Phase A
MCP + REST, strong agent.json + Antigravity skill + 6‑tool parity
Human‑oriented docs + /for‑agents machine discovery
GitHub repo as side note + AI_DISCOVERY.json / llms.txt as AI anchors
AP2 as news + sandbox schema + integration plan

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.

Built by a solo builder in Vietnam.

AgentShare — price and offer infrastructure for agents that do not get a second chance when an API times out.

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

Top comments (0)