Google just shipped an official repository of Agent Skills at Google Cloud Next 2026. It's a quiet announcement, but it points at one of the most persistent unsolved problems in production agentic AI.
The Problem It's Solving
MCP servers were supposed to fix context. Give your agent a live, grounded connection to documentation, and it wouldn't hallucinate outdated APIs or confuse one SDK version with another. And that largely works — Google already runs an MCP server for its developer docs.
But there's a compounding cost. When agents lean heavily on MCP servers, they pull massive amounts of context into their window on every request. The model drowns in raw documentation, token costs spike, and coherence drops. The community calls this "context bloat," and it gets worse the more products an agent is expected to know.
The real gap isn't access to information. It's the absence of condensed, agent-optimized expertise that loads on demand rather than all at once.
How Agent Skills Actually Works
Agent Skills is an open format — originally developed by Anthropic and released as a community standard — for giving agents packaged, structured expertise. At its core, a skill is a folder containing a SKILL.md file with metadata and task-specific instructions. It can also bundle scripts, reference docs, templates, and other assets. Think of it as agent-first documentation: compact, purposeful, and written for a machine that needs to act, not just read.
The mechanism that makes it practical is progressive disclosure. At startup, an agent loads only the name and description of each available skill — just enough to know whether a skill is relevant to the current task. When there's a match, the full instructions are pulled into context. The agent then executes, optionally running bundled scripts or referencing additional files.
Full context only loads when it's actually needed. That's the design decision that separates this from dumping a documentation site into a system prompt.
What Developers Are Actually Using It For
Google's official repository launches at github.com/google/skills with thirteen skills out of the gate. Seven are product-specific: AlloyDB, BigQuery, Cloud Run, Cloud SQL, Firebase, the Gemini API, and GKE. Three map to the Well-Architected Framework pillars — Security, Reliability, and Cost Optimization. And three are "recipe" skills covering onboarding, authentication, and network observability.
Installing them is a single command: npx skills install github.com/google/skills. They work across Antigravity, Gemini CLI, and any third-party agent that implements the Skills spec.
The product-specific skills are the immediately practical ones. An agent working against BigQuery or GKE no longer needs to maintain a live MCP connection to documentation just to get accurate syntax, service limits, or recommended patterns. The skill carries that knowledge, loads it when relevant, and stays out of the way otherwise.
Why This Is a Bigger Deal Than It Looks
The Agent Skills format wasn't built by Google — it was built by Anthropic and open-sourced. Google adopting it as the vehicle for their official documentation layer is a meaningful signal: this is becoming infrastructure, not a framework-specific feature.
For teams building agents on Google Cloud, the practical implication is real. You can now equip an agent with accurate, maintained, Google-authored knowledge about Cloud Run or Firebase without inflating every prompt with raw documentation. The skills are versioned, auditable, and composable — which matters when you're running multi-step workflows across multiple GCP products.
The deeper shift here is architectural. MCP solved access. Agent Skills solves delivery. They're complementary, and the combination starts to look like a serious answer to the context problem that's been quietly breaking production agents for the past year.
Availability and Access
The repository is live now at github.com/google/skills. Google has confirmed additional skills will ship in the coming weeks and months. The Agent Skills format spec is open, meaning any agent platform can implement support, and any team can build and distribute their own skills using the same structure.
Context bloat has been treated like an engineering nuisance. Google just made the case that it's an infrastructure problem — and shipped a solution for it. The question now is how quickly the rest of the ecosystem follows with their own official skills repositories.
Follow for more coverage on MCP, agentic AI, and AI infrastructure.
Top comments (2)
Progressive disclosure is the design decision that makes this work, and it's also the part that's easiest to get wrong. Loading only the skill name and description at startup is elegant in theory, but it means the agent has to correctly decide when a skill is relevant based on a two-line summary. That's a classification problem, and classification problems have error rates. If the agent fails to activate the BigQuery skill during a query that needs it, you get a hallucination. If it activates it unnecessarily, you're back to context bloat, just in smaller increments.
The shift this represents—from MCP's "give the agent a live pipe to everything" to Skills' "give the agent curated expertise, on demand"—feels like watching the same maturation curve that APIs went through. Early REST APIs returned massive JSON blobs because bandwidth was cheap and filtering was hard. Then GraphQL and sparse fieldsets arrived because developers realized that over-fetching creates real problems downstream. MCP is the "return everything" era. Skills is the "ask for what you need" era. Same pattern, different decade.
What I find myself watching is the maintenance question. Google-authored skills for Google products will stay current because Google has an incentive to keep them current. But the Skills format is open. Any team can publish skills. When your agent loads skills from three different sources, who's responsible when one of them drifts out of sync with the actual API? Versioning helps, but versioning is a signal, not a solution. The skill claims it covers Cloud Run circa Q1 2026, but the actual Cloud Run API changed last week. The agent won't know that unless something tells it.
The composability of skills across multiple products is where this gets genuinely interesting for the multi-step workflows you mentioned. An agent working across BigQuery, Cloud Run, and Firebase loads three skills—and the progressive disclosure mechanism means it only has the full context for the ones actually relevant to the current step. The next step, it swaps. That's a much cleaner model than maintaining three MCP connections simultaneously. But it also means the agent's effectiveness depends on how well the skill boundaries map to real task boundaries. How tightly coupled are the Google-authored skills to specific product scopes—could the agent reason across products when a task genuinely spans them, or does it get stuck at the seams?
Thanks Sir !
Loved your Insights!!!