Orbital / Agent Skills joins AAIF: a business portability test

Agent Skills joins AAIF: a business portability test.

Anthropic donated Agent Skills to the Linux Foundation’s AAIF. Use this practical test before packaging business workflows for multiple AI agents.

Open standards · Business workflow evaluation

By Orbital Content Team · Published October 22, 2026

AI-assisted research and drafting with editorial review. Reported governance, adoption, format and roadmap statements were checked against Anthropic, Agent Skills and project-repository materials on October 22. The evaluation framework and business implications are Orbital analysis. Orbital did not install a third-party skill, verify adoption counts, compare agent implementations, audit the foundation or reproduce security behavior.

Anthropic announced on October 22 that it is donating Agent Skills—the open format for packaging instructions, scripts and reference material for AI agents—to the Agentic AI Foundation under the Linux Foundation. The company says the donation includes the name, logo, GitHub organization and agentskills.io domain, with engineers from Anthropic, Google, OpenAI and other companies maintaining the standard as individuals.

For a business, the important question is not whether an open standard sounds promising. It is whether one useful workflow can be captured, reviewed, versioned and moved between compatible tools without quietly changing permissions, results or accountability. A shared folder format can reduce rewriting. It does not make different agents equivalent or make an untrusted workflow safe.

What changed on October 22

Anthropic says Agent Skills now has a neutral institutional home in the Agentic AI Foundation, a directed fund under the Linux Foundation. According to the announcement, Anthropic donated the standard’s identity and project assets, while participation remains open to people and companies that do not join the foundation. Anthropic also proposed a roadmap that starts with versioned releases, a formal proposal process and security guidance.

The underlying format remains deliberately small. A skill is a directory with a required SKILL.md file. That file contains YAML metadata and Markdown instructions. A skill may also contain scripts, reference documents, templates and other assets. Compatible agents first load brief metadata, then read the full instructions when a task matches, and load other resources as needed.

Anthropic reports that more than 70 agent platforms have integrated Agent Skills, that one million skills have been published and that nearly 280 million have been installed since the standard was published in December 2025. Those are Anthropic’s reported counts; the announcement does not publish the counting method or an independently audited dataset. The project repository is public and identifies an Apache 2.0 license for code and CC BY 4.0 for documentation.

This governance move can improve the probability that the format evolves beyond one vendor’s product priorities. It does not guarantee implementation parity, backwards compatibility, security review, vendor support or continued adoption. Those still require published releases, conformance behavior and evidence from the products a business actually uses.

Separate the announcement from the business conclusion

What is documented and what remains to be verified
AreaDocumented on October 22Evidence a buyer still needs
StewardshipAnthropic says the standard and related project assets are being donated to AAIF under the Linux Foundation.Published governance rules, release authority, conflict process and how future decisions are recorded.
MaintainersAnthropic names lead maintainers and says engineers from several companies will maintain the standard as individuals.Maintainer roster, decision rights, succession, review requirements and response expectations.
FormatA required SKILL.md with optional scripts, references and assets.Which parts each selected agent supports and how unsupported fields or files are handled.
PortabilityThe project describes cross-product reuse as a goal.Results from the same versioned skill, test cases and permissions in every target product.
SecuritySecurity guidance is proposed as roadmap work; an allowed-tools field exists but is experimental.Current product controls, code scanning, origin verification, sandboxing, approvals, logs and incident response.
AdoptionAnthropic reports more than 70 integrated platforms, one million published skills and nearly 280 million installations.Counting definitions, active use, version distribution, duplicate handling and relevance to the buyer’s tools.
CompatibilityThe specification defines file and metadata conventions.Model behavior, tool syntax, operating system, package dependencies, network rules and output fidelity.

The practical conclusion is narrower than “write once, run everywhere.” A standard can make the workflow package recognizable. The runtime still determines how instructions are interpreted, which tools exist, what permissions are enforced and how failures appear.

What can be portable—and what usually is not

A well-designed skill can carry a substantial part of a business procedure between compatible agents:

  • the trigger and purpose of the workflow;
  • required inputs and the expected output structure;
  • step-by-step instructions and decision rules;
  • approved templates, terminology and reference material;
  • edge cases, stop conditions and escalation rules;
  • validation scripts or formatting helpers; and
  • examples that distinguish acceptable from unacceptable results.

Other parts are commonly environment-specific:

  • authentication and secrets;
  • available connectors and tool names;
  • filesystem, browser, network and package access;
  • approval interfaces and human-review states;
  • model selection, context limits and reasoning behavior;
  • logging, retention and data-location controls;
  • rate limits, pricing and background execution; and
  • the legal and contractual terms governing each platform.

Keep those boundaries explicit. Put business procedure in the portable core. Put credentials, tenant identifiers, endpoints and provider-specific permissions in controlled configuration outside the skill. Use thin adapters for tool names and request formats. If a platform cannot enforce a required approval or data boundary, treat that platform as incompatible with the workflow even if it can read the folder.

This is the same separation Orbital recommends in a tech stack audit: define the business outcome first, then map systems, owners, data and handoffs. Portability is useful only when it preserves that operating model.

Choose the right first workflow

Do not start by converting the most complicated process in the company. Choose a workflow that is repeated often enough to matter, stable enough to document and safe enough to test without creating customer harm.

First-skill candidate test
QuestionGood candidateWarning signal
Is the outcome clear?A defined artifact, checklist, classification or draft.Success depends on undocumented judgment or a vague sense of quality.
Can the rules be stated?A current procedure with owners, examples and exceptions.Each employee uses a different unwritten process.
Can the result be reviewed?A human checks the output before it affects another person or system.The first version publishes, pays, deletes, promises or changes records automatically.
Can test data be controlled?Synthetic, public or approved low-sensitivity material.Credentials, regulated data or complete customer records are required to see whether it works.
Can failure be reversed?The output is a draft and the manual process remains available.A mistake creates an irreversible transaction or missed obligation.
Does portability matter?The business expects to compare tools, support multiple teams or retain an exit path.The workflow is permanently tied to one proprietary interface and has no reuse case.

Reasonable first candidates include turning approved notes into a standardized internal brief, checking a draft against a documented content checklist, formatting a recurring analysis or assembling public-source research for review. Customer communication, payments, account access, hiring decisions, legal conclusions and destructive system changes should not be the first portability test.

Use Orbital’s AI automation readiness checklist to define the trigger, owner, data boundary, approval and fallback before packaging a process.

Build a business-ready skill, not a long prompt

The specification requires only a name, description and instruction body, but a production-minded business package needs more discipline. Keep the standard files valid while documenting the following operational elements:

  1. Purpose and trigger. State when the skill should run and when it should not.
  2. Inputs. List required fields, accepted formats, source authority and prohibited data.
  3. Procedure. Use observable steps, not adjectives such as “professional” or “high quality” without criteria.
  4. Decision rules. Define what the agent may decide, what needs approval and what must be escalated.
  5. Output contract. Specify structure, required evidence, labels for uncertainty and validation rules.
  6. Tool boundary. Identify read, draft and write operations separately. Grant only what the workflow needs.
  7. Failure behavior. Stop on missing evidence, conflicting instructions, failed validation or an unavailable system.
  8. Examples. Include accepted, rejected and edge-case examples using safe data.
  9. Ownership. Name the business owner, technical maintainer, reviewer and incident contact in the surrounding governance record.
  10. Version and change notes. Record what changed, why, who approved it and which tests passed.

The specification says instructions load when a skill activates and resources load as needed. That progressive disclosure can reduce context use, but it also makes activation metadata important. A broad description can trigger a skill in the wrong situation; a narrow one can hide it when needed. Test both intended activation and false activation.

Keep the main instruction file concise and move detailed policies or examples into focused references. The specification recommends a SKILL.md under 500 lines and instructions under roughly 5,000 tokens. Those are format recommendations, not proof that shorter instructions produce reliable outcomes.

Treat every skill as governed software

A skill can include executable scripts and instructions that influence which tools an agent uses. That makes origin, review and permissions as important as the wording. The current specification lists allowed-tools as experimental and says support may vary. Do not treat that field as a universal security boundary.

Minimum control register for a business skill
ControlDecisionEvidence
OriginWho authored the skill and where the approved source lives.Repository, owner, license, reviewed commit and checksum or signed release when available.
Code reviewWho reviews instructions, scripts, dependencies and changes.Dated approval tied to the exact version.
PermissionsWhich files, websites, systems and actions are allowed.Runtime-enforced allowlist and denied-action tests.
SecretsHow credentials are provided, rotated and revoked.No secrets in the skill; scoped secret store and access log.
DataAllowed, masked and prohibited classes.Test set, input controls, retention rule and escalation path.
External contentHow email, pages and documents are treated as untrusted input.Prompt-injection cases and a rule that content cannot grant new authority.
ActionsWhich consequences require a human decision.Visible approval state, named reviewer and cancellation path.
DependenciesPackages, scripts and remote services the skill relies on.Pinned versions, license review, vulnerability process and offline behavior.
LoggingWhat is recorded without copying unnecessary sensitive content.Trace from trigger to output, tool calls, approvals and errors.
ResponseHow to disable, roll back and investigate the skill.Kill switch, previous version, owner and tested recovery steps.

Never install a public skill only because it is popular or appears in a marketplace. Read the full instructions and every executable file, inspect dependency and network requirements, confirm the license and test in an isolated environment with synthetic data. A folder standard makes distribution easier for helpful and harmful instructions alike.

Review third-party skills like a software supplier

A reusable skill may come from a vendor, consultant, employee or public repository. Before adoption, record:

  • the canonical source and exact commit or release;
  • author and maintainer identity, update history and issue process;
  • software and documentation licenses;
  • included code, binaries, templates and dependencies;
  • required network, file and tool permissions;
  • data sent to outside services and the terms governing those services;
  • known limitations, unsupported platforms and rollback path;
  • how updates are reviewed instead of automatically trusted; and
  • the internal owner accountable for continued use.

Forking a skill can give a business control over changes, but it also creates maintenance responsibility. Tracking the upstream version without auto-merging is often a safer starting point. Compare changes, rerun tests and approve a new internal version deliberately.

If the skill is central to a customer or regulated workflow, ask whether the supplier provides security documentation, a vulnerability contact, change notices and support commitments. The AAIF donation may improve standards governance; it does not turn every package using the format into vetted software.

Test the same workflow across agent products

Portability should be measured with the same versioned skill and test set in each intended environment. Record the model, agent product, operating system or cloud runtime, enabled tools, permissions and configuration for every run.

Cross-agent validation matrix
MeasureHow to test
ActivationExpected tasks invoke the skill; adjacent tasks do not.
Instruction fidelityRequired steps, source priorities and stop conditions are followed.
Output contractSchema, required fields, citations and uncertainty labels validate.
Tool mappingEquivalent read, draft and write operations use the intended adapters.
Permission enforcementUnauthorized tools, paths, domains and actions are denied by the runtime.
Adversarial inputExternal content cannot override the workflow, reveal secrets or expand authority.
Error behaviorMissing files, unavailable systems and invalid outputs stop or fall back safely.
Human approvalThe same consequential boundaries remain visible and mandatory.
QualityReviewers apply one rubric to identical cases and track critical errors separately.
Cost and timeTotal runtime, model usage, retries and reviewer effort are measured per accepted output.

Do not hide differences behind an average score. A product that is slightly faster but occasionally bypasses a stop condition is not interchangeable for that workflow. Set minimum pass criteria before running the comparison. If a platform lacks a required control, document the incompatibility instead of weakening the business procedure.

Measure maintenance and value, not installation counts

The business case for a skill is reduced repeated instruction, more consistent output and a clearer process asset. Calculate value per accepted outcome, not per generated response.

Include:

  • time to document the current process and resolve conflicting rules;
  • authoring, script development, reference cleanup and testing;
  • security, privacy, legal and licensing review where applicable;
  • agent and model usage across every supported environment;
  • human review, correction, escalation and exception handling;
  • maintenance after policies, tools, models or the standard change;
  • regression testing for each supported platform;
  • monitoring, incident response and rollback; and
  • the manual fallback that remains necessary for outages or edge cases.

Then compare the approved skill with the baseline process on cycle time, rework, critical errors, reviewer effort and accepted outputs. A portable package can be more expensive than a provider-specific workflow if each environment needs substantial adapters and separate testing. Portability has value when it creates real negotiating leverage, resilience or reuse—not when it is only a claim in an architecture diagram.

A bounded four-week portability pilot

  1. Week 1 — select and document. Choose one internal, reversible workflow. Map its trigger, inputs, data, owner, decision rules, approval and fallback. Capture a representative synthetic or approved low-sensitivity test set.
  2. Week 2 — package and review. Build one standards-valid skill with a portable core and thin environment adapters. Review every instruction, script, dependency and permission. Pin the exact version and record the approval.
  3. Week 3 — compare. Run the same cases in two compatible agent environments, first with read-only or no external tools. Measure activation, task acceptance, critical errors, tool behavior, latency, cost and reviewer effort. Test prompt injection, missing inputs and denied permissions.
  4. Week 4 — controlled use. Let a small internal group use the skill for drafts only. Keep the manual process available, review every result, reconcile logs and measure accepted outcomes. Test rollback before expanding.

End with one decision: stop, revise, retain on one platform or support multiple platforms. Expansion should change one boundary at a time—user group, data class, connected system or action permission—followed by regression testing. Do not let an open format become an excuse for broad credentials or automatic customer-facing actions.

Orbital’s business take

Moving Agent Skills into a Linux Foundation project is strategically useful because business procedures should not have to be rewritten from scratch every time an organization tests a new AI agent. Neutral governance, formal releases and a proposal process can make the format easier to plan around if the foundation follows through with transparent specifications and security guidance.

The standard is a container for workflow knowledge, not a guarantee of outcomes. Different models and runtimes can interpret the same instruction differently, expose different tools and enforce different permissions. The business asset is therefore the versioned process plus its tests, approvals and adapters—not the SKILL.md file alone.

The right near-term move is to standardize one well-understood internal workflow, test it in two controlled environments and keep consequences behind human approval. That produces evidence about portability while improving the procedure even if the business ultimately keeps one provider.

Explore Orbital’s AI automation services, tech stack consulting, connected-business planning, business consulting and service-business planning. A 60-minute consultation can turn one candidate workflow into a testable automation brief; implementation, software, model usage, security, privacy, legal review and ongoing support are separately scoped.

Sources and editorial limits

Primary sources were checked October 22, 2026. Anthropic published the Agent Skills donation announcement on October 22. Governance, maintainer, roadmap and adoption statements are reported from Anthropic and were not independently audited by Orbital. The Agent Skills overview, specification and repository document the current format, progressive-disclosure pattern, experimental allowed-tools field, validation library and project licenses. The AAIF background comes from Anthropic’s December 9, 2025 announcement establishing the foundation under the Linux Foundation. Orbital did not install or execute a third-party skill, verify publication or installation counts, compare compatible agents, audit maintainers, inspect foundation records, test security controls or confirm future roadmap delivery. This article is business analysis, not security, legal, privacy, compliance, procurement or investment advice. It does not guarantee portability, compatibility, safety, savings or business results.

Primary source links

Your next chapter.
Let’s give it lift.

Start a conversation