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:
| 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 -
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:
| 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
Rebuilthttps://agentshare.dev/for-agentsfor 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 andcommerce_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.jsonhttps://agentshare.dev/.well-known/discovery.json-
https://agentshare.dev/for-agents— header:Accept: application/json
https://agentshare.dev/api/v1/examples?template=managed-agent-
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
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)