Portable agent skills: production contracts
Google Cloud brought composable skills to HPC operations with deterministic tools, preflight validation, and human approval. This guide translates that development into seven contracts for reusing procedures across agents without inheriting privileges, paths, or implicit trust.
- Published
- min read
- 6 min read
- Categoría
- AI Systems
On this page
7 chapters- 01How do you make an agent skill portable without transferring trust?
- 02Which seven contracts must a portable skill satisfy?
- 03Skill, tool, and permission are different layers
- 04Hypothetical example: one deployment skill across three agents
- 05How do you prevent multi-agent packaging drift?
- 06What should you evaluate before promoting a skill?
- 07The decision: standardize knowledge, localize authority

Chapter 01
How do you make an agent skill portable without transferring trust?
Port the procedure, but bind tools, permissions, approvals, and tests again in every runtime.
An agent skill is portable when it preserves intent and procedure across hosts, not when it blindly runs the same command everywhere. The package needs a versioned source, must declare when it applies, load references only when needed, and describe capabilities without assuming paths, credentials, or tools. Each runtime must resolve those capabilities against its actual inventory, deny what is missing, run deterministic preflight checks, and request approval before mutation. A cross-host evaluation matrix must then verify outcomes and invariants; telemetry must record the skill, version, tools, and approver; and deployment must be reversible. These seven contracts separate reusable knowledge from local authority. Without that separation, moving a SKILL.md merely copies instructions: it does not prove compatibility, security, or operational reliability.
On November 13, 2026, Google Cloud announced composable skills for operating HPC workloads through Cluster Toolkit. The proposal is more concrete than a prompt library: it checks quotas and capacity, selects validated blueprints, waits for human approval before deployment, operates within IAM and budget boundaries, and retains provenance in Cloud Logging. The news is three America/Lima calendar days old when this article is published. Google does not present these properties as a universal benchmark or proof that every skill works in every agent; they are architecture choices for that environment.
Chapter 02
Which seven contracts must a portable skill satisfy?
The unit of portability is not an isolated file: it is a package, a host adapter, and repeatable evidence.
The source contract establishes an owner, license, review, and immutable version. The activation contract precisely defines which requests should load the skill and which should be rejected or routed elsewhere. The capability contract maps domain verbs—inspect quota, validate blueprint, deploy—to actual host tools without hiding dependencies. The authority contract keeps credentials and policies outside the package and requires explicit approval for consequential actions. These four contracts prevent portability from meaning copied authority or out-of-context activation.
The remaining three close the loop. Evaluation compares the same fixtures and invariants across every supported host. Observability records the skill version, relevant inputs, resolved tool, policy decision, approval, and outcome while minimizing sensitive data. Reversibility makes it possible to disable a version, restore the preceding one, and identify affected runs. A README can explain these principles; CI and the runtime must enforce them.
| Contract | Minimum evidence | Block when |
|---|---|---|
| 1. Source | Owner, review, license, and version | Origin or review cannot be verified |
| 2. Activation | Use cases, exclusions, and routing examples | The same request triggers incompatible skills |
| 3. Capabilities | Explicit intent-to-tool mapping | A dependency is resolved by assumption |
| 4. Authority | Local policy, least privilege, and approval | The package expands host permissions |
| 5. Evaluation | Fixtures, invariants, and host matrix | A host skips a gate or changes the outcome |
| 6. Observability | Skill, version, tool call, decision, and outcome | An action cannot be reconstructed |
| 7. Reversibility | Pin, gradual rollout, kill switch, and rollback | No tested return to a safe version exists |
Chapter 03
Skill, tool, and permission are different layers
The open Agent Skills specification defines a folder with a required SKILL.md and optional resources such as scripts, references, and assets. The agent first discovers the name and description, loads instructions when the task matches, and only then consults resources or executes code. This progressive disclosure reduces unnecessary context, but it neither creates a sandbox nor grants access. The package teaches how to proceed; the host decides which tools exist; policy decides whether they may be used; and the identity system determines their scope.
That is why a skill saying “deploy the cluster” should not embed credentials, assume a global binary, or reinterpret tool availability as authorization. Declare the deploy-cluster capability and its preconditions. The runtime adapter may resolve it to a structured tool, a reviewed script, or a flow ending in an approval request. If it cannot establish quota, region, blueprint, identity, and plan, it should return a blocked state and missing evidence rather than improvise a more privileged path.
Chapter 04
Hypothetical example: one deployment skill across three agents
Imagine, hypothetically, a company maintaining a skill that prepares a simulation cluster. The canonical source defines the order: inspect quotas, check regional capacity with a canary, select an approved blueprint, generate a plan, request approval, and deploy. In agent A, quota-check and capacity-canary are native tools. In agent B, a reviewed script emits the same JSON schema. In agent C, capacity-canary does not exist. The skill remains portable across A and B because both satisfy the capability contract; in C it must stop before planning. Copying the text does not turn a missing dependency into compatibility.
All three hosts receive the same fixture: a region without capacity and sufficient quota. The expectation is not identical prose, but that none reaches deploy, that both compatible hosts emit capacity_unavailable, and that the event includes version, queried region, and canary evidence. Another fixture changes the blueprint after approval; approval must become invalid. A third simulates a deployment timeout; the agent queries state with an idempotent identifier instead of repeating the mutation. This suite tests semantics and safety, not response style.
Chapter 05
How do you prevent multi-agent packaging drift?
On November 12, GitHub published a guide that keeps skills/*/SKILL.md as the source and generates client-specific artifacts for Claude Code, Cursor, and GitHub Copilot. The important point is not the client list but the direction of flow: one source produces adapters; adapters are not edited as independent copies. A CI check mode regenerates outputs and fails when the repository contains stale artifacts. Changing a gate at the source therefore forces review of every package that materializes it.
Generation still does not prove equivalence. A packager may preserve instructions while breaking relative paths, environment variables, server framing, or approval syntax. Add static manifest validation, package startup in every supported host, and behavioral evaluations using shared fixtures. Publish a clear matrix: source version, adapter version, tested runtime, and date. If a client lacks a critical capability, mark that combination unsupported; do not hide the gap behind a natural-language instruction.
Chapter 06
What should you evaluate before promoting a skill?
Start with routing: positive, negative, and ambiguous requests must activate the right skill or escalate. Continue with loading behavior: required references loaded, irrelevant references omitted, and no path outside the package. Then evaluate planning against known state. Output must enumerate preconditions, distinguish observation from mutation, and never invent flags. For consequential actions, test denial for missing permission, expired approval, resource changes after approval, redelivery, timeout, and partial outcomes. Require every host to preserve the same invariants even when its tools differ.
Promote in stages: static validation, a credential-free environment, a sandbox with disposable resources, shadow mode against anonymized real requests, and a tightly bounded canary. Compare failures by category rather than only an aggregate rate: incorrect routing, wrong tool, invalid argument, skipped gate, duplicate mutation, and incomplete traceability. Define which signal stops the version before rollout and rehearse rollback. Better happy-path responses do not compensate for losing an approval gate or duplicating an action.
- Every mutation has preflight, current approval, and idempotency.
- Every supported host passes the same invariants using its actual adapters.
- Every run can be attributed to a version and reconstructed without exposing secrets.
- Rollback was tested before it was needed.
Chapter 07
The decision: standardize knowledge, localize authority
Adopt a shared skill when the procedure is stable, repeated, and valuable enough to justify ownership, tests, and versions. Keep credentials, access decisions, and runtime-specific details outside the package. If a workflow still changes every week or depends on undocumented intuition, first turn it into an observable runbook. If it requires a host-exclusive tool, declare that dependency instead of claiming nominal portability. The goal is to reduce procedural divergence without creating false security equivalence.
Google Cloud's development matters because it shows skills operating near expensive infrastructure with explicit validation, approval, and traceability. The lesson for a CTO is not to install more prompt folders. It is to treat each skill as a production dependency: verifiable source, resolved capabilities, local authority, cross-host evaluation, observability, and rollback. Wasyra can help design that layer for custom agents without confusing the implementation service with the Agents product.
Written by
Wasyra Lab
AI systems and operations architecture
Wasyra Lab publishes practical frameworks for designing AI agents, automations, and operating flows that survive production.
Series
AI systems that actually reach production
A series on agents, copilots, and guardrails for bringing AI into real work without breaking trust or operations.
Posts in this seriesMore from this author
More from this author
AI Systems
Agent hooks: 7 tests before tools execute
AgentCore's new lifecycle hooks expose four control boundaries. This guide turns them into seven tests for authorization, failure, and auditability.
ArticleAI Systems
Scientific post-training: 7 evidence gates
Nemotron for Science opens scientific post-training. These seven gates prevent proxy optimization, test leakage, and false improvements.
ArticleKeep reading
Keep reading
AI Systems
Agent hooks: 7 tests before tools execute
AgentCore's new lifecycle hooks expose four control boundaries. This guide turns them into seven tests for authorization, failure, and auditability.
ArticleAI Systems
Scientific post-training: 7 evidence gates
Nemotron for Science opens scientific post-training. These seven gates prevent proxy optimization, test leakage, and false improvements.
ArticleAI Systems
Agentic RL: how to read MLPerf Training 6.1
MLPerf now measures agent post-training. Learn how to read time to quality, workload limits, and useful infrastructure decision signals.
Article