Google Is Turning Documentation Into Agent Distribution
Google is quietly changing what platform documentation is for. The Android team now publishes modular skills that AI agents can load, along with command line tools that let those agents create, build, test, and manage Android projects. Its October update added device streaming support and again emphasized that the tools work with any AI agent. The important part is not Android development itself. Google is converting platform knowledge from pages written for humans into instructions and tools that software agents can actually use.
I think this is the beginning of a new distribution layer. For years, a platform won developers by having good documentation, familiar libraries, and a large community. Agents change that equation. A platform now also needs to explain itself in a form a machine can retrieve at the right moment, understand, and execute without guessing. The platform that does this well becomes easier for every agent to build on. That can matter more than which model happens to top a coding benchmark this month.
Documentation is becoming executable context
Android skills are modular Markdown instructions with metadata that helps an agent decide when to load them. They cover specific workflows and bring in reference material only when it is relevant. The Android team describes them as a way to ground models in current platform practices, especially where general models tend to produce outdated code or miss a complicated migration path.
That is a meaningful break from the old documentation model. A web page waits for a person to find it, interpret it, and translate it into action. A skill sits inside the work loop. It can tell an agent which pattern to use, which tool to call, and what success should look like. Documentation stops being a library beside the product and starts behaving like part of the product.
The distinction matters because agents are often wrong in boring, expensive ways. They remember an old interface, imitate a deprecated pattern, or produce something plausible that does not fit the current platform. A newer foundation model may reduce those errors, but it cannot permanently solve a knowledge problem on a platform that keeps changing. Maintained skills can.
This makes the model more replaceable
The obvious reading is that Google is making its own AI tools better. The more interesting reading is that Google is making the underlying model less important. If the platform knowledge lives in portable instructions and the actions live in a stable command line interface, then several agents can use the same operating knowledge. Google explicitly says the Android tools can support any agent, not only its own.
That is good news for open models and local inference. Smaller models do not need to memorize every current Android convention if they can load a focused skill at the moment it is needed. A local agent can keep private source code on a machine while using official platform instructions instead of relying on whatever the model absorbed during training. Capability becomes a combination of model, skills, tools, and evaluation, rather than a contest over model size alone.
This is also why I expect the frontier premium to keep narrowing for practical agent work. A closed model can still be better at planning or difficult reasoning. But a large share of real work depends on knowing the local rules and using the right tool correctly. Once those rules are packaged outside the model, switching models becomes easier. Better context can turn a merely good model into the better system for a specific job.
Open agent standards can deepen platform power
There is a useful tension here. Portable skills reduce dependence on one agent vendor, but they can increase dependence on the platform publishing the skills. Google does not need to force every developer into a Google model if it can make every model unusually effective on Android. The skill format can be open while the ecosystem advantage still accrues to Android.
That is not sinister. It is smart platform strategy. The winner does not have to own the intelligence if it owns the best path from intelligence to useful action. Microsoft, Amazon, Stripe, Shopify, and other platform companies have the same opportunity. Their documentation is already a distribution asset for human developers. Converting it into tested agent skills could make it a distribution asset for autonomous software as well.
The competitive gap will not come from publishing a folder of prompts. It will come from maintaining those instructions as the platform changes, connecting them to reliable tools, and measuring whether agents complete real tasks correctly. A stale skill can be more dangerous than a stale web page because an agent may execute it at scale. Versioning, provenance, permissions, and tests become part of documentation quality.
The durable value moves into workflow knowledge
For founders, the broader signal is that prompts are not the durable layer. Neither is loyalty to one model. The useful asset is the accumulated knowledge that tells an agent how work is actually done, plus the tools and evaluations that make the result dependable. Google can publish Android knowledge because wider Android adoption is the goal. A company can keep its own operating knowledge private because that knowledge is part of its advantage.
This is where local agents become more interesting to me. Running weights locally provides control over data and cost, but weights alone are not a working system. The system becomes valuable when it can retrieve the right instructions, use approved tools, remember the relevant state, and prove that the task was completed. Google is showing how one part of that stack can be packaged in a model independent way.
My test for an agent system is getting simpler: keep the skills, tools, and evaluations fixed, then swap the model. If the workflow survives, the architecture owns its knowledge. If everything breaks, the model vendor still owns more of the product than it appears. Run that swap before calling any agent system portable.