# We Built an Agent Commerce API. Google I/O 2026 Changed Our 3-Month Roadmap in 24 Hours. > Source: > Published: 2026-05-23 06:54:05+00:00 # 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](https://agentshare.dev/agent.json) - **MCP:**[https://agentshare.dev/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](https://agentshare.dev/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):** - **Skill:**`agentshare-price-intelligence` - **Manifest:**[https://agentshare.dev/.well-known/antigravity-skills.json](https://agentshare.dev/.well-known/antigravity-skills.json) - **Published skill:**[https://agentshare.dev/integrations/antigravity/agentshare-price-intelligence/SKILL.md](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](https://agentshare.dev/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](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](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](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: | 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: [https://agentshare.dev/agent.json](https://agentshare.dev/agent.json)[https://agentshare.dev/.well-known/discovery.json](https://agentshare.dev/.well-known/discovery.json)- [https://agentshare.dev/for-agents](https://agentshare.dev/for-agents)— header:`Accept: application/json` [https://agentshare.dev/api/v1/examples?template=managed-agent](https://agentshare.dev/api/v1/examples?template=managed-agent)- [https://agentshare.dev/mcp](https://agentshare.dev/mcp)— tools:`search_products` ,`best_offer` ,`best_offer_under_budget` ,`product_detail` ,`commerce_quote` ,`service_meta` [https://raw.githubusercontent.com/anhmtk/agentshare-mcp/main/AI_DISCOVERY.json](https://raw.githubusercontent.com/anhmtk/agentshare-mcp/main/AI_DISCOVERY.json) **Free tier API key (no card):** [https://agentshare.dev/signup](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](https://agentshare.dev) · [For Agents](https://agentshare.dev/for-agents) · [GitHub](https://github.com/anhmtk/agentshare-mcp) ([public MCP face](https://agentshare.dev/mcp))