← Back to blog
AI News#open-standards

Four New AI Agent Standards Explained: Agent Skills, Open Responses, OpenEnv, and OpenSandbox

What the Agentic AI Foundation's four new projects do, where each fits in an agent stack, how to try each one, and what to check before you adopt any of them.

11 min readby the editors
Four New AI Agent Standards Explained: Agent Skills, Open Responses, OpenEnv, and OpenSandbox cover illustration

On October 22, 2026, the Agentic AI Foundation (AAIF), hosted by the Linux Foundation, took on four new AI agent standards and tools: Agent Skills from Anthropic, Open Responses from OpenAI, OpenEnv from Hugging Face, and OpenSandbox from Alibaba. They do not compete. Each covers a different layer of an agent: Agent Skills packages reusable instructions, Open Responses gives you one request format for many model providers, OpenEnv gives you repeatable environments for training and evaluating agents, and OpenSandbox gives you an isolated place to run agent-generated code. This guide explains each one in plain terms, shows the first command or file for each, and lists what to check before you build on any of them. A neutral foundation home is good news for portability. It does not make every implementation compatible, mature, or production-ready, so each project still needs its own evaluation.

Before you start

System requirements

Who this is for

Developers building or evaluating AI agents

You should know what a tool call and a model API request are. You do not need to have used any of the four projects.

Agent Skills

A text editor and a skills-compatible agent

A skill is a folder with a SKILL.md file. It works on Windows, macOS, and Linux. Whether bundled scripts can run depends on the agent you load it into.

OpenEnv

Python and pip

Install with pip install openenv. Each environment is a Docker image, so Docker is needed to run environments locally. Hosted Hugging Face Spaces work without it.

OpenSandbox

Docker and Python 3.10 or newer

The README lists Docker for local execution and Python 3.10+ for the local runtime and examples. Kubernetes is needed only for cluster deployments.

Open Responses

An API that implements the spec

Open Responses is a specification, not a package. You call a provider or local server that implements it. The project site lists implementations including OpenAI, Ollama, vLLM, OpenRouter, Hugging Face, and LM Studio.

Cost

Free and open source

OpenSandbox is Apache 2.0 and OpenEnv is BSD 3-Clause. Model tokens, cloud compute, and hosted sandboxes cost whatever your provider charges.

01

What is the Agentic AI Foundation, and what changed?

A Linux Foundation home for open agent standards. It now hosts 10 projects, up from three at launch in December 2025.

The AAIF gives open agent protocols and infrastructure a vendor-neutral home, so no single company controls their direction. Before this announcement it already hosted the Model Context Protocol (MCP), Agent2Agent (A2A), AGENTS.md, goose, Agent Router, and agentgateway.

The October 22 announcement added Agent Skills (contributed by Anthropic), Open Responses (OpenAI), OpenEnv (Hugging Face), and OpenSandbox (Alibaba), bringing the total to 10.

Foundation hosting is about governance: who owns the name, the repository, and the decision process. It says nothing on its own about maturity. OpenEnv's own docs say it is in early development and its APIs may change. Check each project's release status, licence, and maintainers before you depend on it.

02

Agent Skills: package reusable expertise in a folder

A skill is a directory with a SKILL.md file: a name and description up top, instructions below, and optional scripts and reference files.

Problem it solves: teams rewrite the same task instructions for every agent and every project. A skill packages that procedure once. Say your company wants every generated report to follow an internal template, use approved terms, and pass a validation step. That becomes one versioned folder that any skills-compatible agent can load.

The format is small. SKILL.md needs YAML frontmatter with name (up to 64 lowercase letters, numbers, and hyphens, matching the folder name) and description (up to 1024 characters, saying what the skill does and when to use it). Optional folders hold scripts/, references/, and assets/.

Agents load skills through progressive disclosure. At startup they read only each skill's name and description, about 100 tokens. When a task matches, they load the full SKILL.md body. Bundled files load only when the instructions call for them. That keeps many skills available without filling the context window.

Anthropic's donation moved the standard, the Agent Skills name and logo, the GitHub organization, and the agentskills.io domain to the AAIF. Engineers from several companies maintain it as individuals.

Watch out: an open format does not make a skill safe. Instructions steer the agent, and bundled scripts can run wherever the agent is allowed to execute code. Treat third-party skills like third-party code: read them, inspect the scripts, control who can change your skill repository, and limit what the agent may execute.

How Agent Skills load. A skill folder named code-review holds a required SKILL.md plus optional scripts, references, and assets folders, and the name must match the folder. Stage one, discovery at startup: only the name and description of every skill load, about 100 tokens each. Stage two, activation when a task matches: the full SKILL.md instructions enter context, under 5000 tokens recommended. Stage three, execution as needed: scripts run and reference files load only when the instructions call for them, so review scripts like any third-party code. Footer: many skills installed, little context used; keep SKILL.md under 500 lines.
Discovery costs about 100 tokens per skill. The full instructions and scripts load only when a task needs them.Open full size →
skills/code-review/SKILL.md
---
name: code-review
description: Reviews a code change for correctness, security, and
  maintainability issues and reports findings in a fixed format.
  Use when asked to review a diff, pull request, or patch.
license: Apache-2.0
---

# Code review

1. Read the diff and the files it touches.
2. Look for correctness, security, and maintainability problems.
3. Run the checks in scripts/run-checks.sh.
4. Report each finding as: file:line, severity, problem, evidence.
5. Follow references/style-guide.md for naming rules.
macOS / Linux: create a skill folder
mkdir -p skills/code-review/scripts skills/code-review/references
touch skills/code-review/SKILL.md
Windows PowerShell: create a skill folder
New-Item -ItemType Directory -Force skills\code-review\scripts, skills\code-review\references
New-Item -ItemType File skills\code-review\SKILL.md

Tip
The spec points to the skills-ref reference library for validation: skills-ref validate ./skills/code-review checks the frontmatter and naming rules before you share the skill.

03

Open Responses: one request format for many model providers

An open specification for calling language models, based on the OpenAI Responses API, so application code is less tied to one provider.

Problem it solves: an app built on one provider's API depends on that provider's request fields, streaming events, and tool-call shapes. Adding a second provider means translation code and more testing for request building, streamed output, tool-call parsing, errors, and response normalization.

Open Responses describes requests and outputs once. The core unit is the item: a message, a reasoning item, a function_call from the model, or a function_call_output that you send back, matched by call_id. Streaming events and tool invocation follow the same patterns across implementations. Provider-specific extras use a prefixed type such as openai:web_search_call, so they do not fragment the core.

The project publishes a spec, an OpenAPI reference, and acceptance tests for checking whether an API conforms. It lists implementations from OpenAI, NVIDIA, Vercel, OpenRouter, Hugging Face, LM Studio, Databricks, Red Hat, AWS, Ollama, vLLM, and Llama Stack.

Watch out: a shared format does not mean identical behavior. Providers still differ in tool support, multimodal input, context limits, error semantics, reasoning features, latency, and price. Test the exact features you rely on with each provider instead of assuming they are interchangeable.

An Open Responses tool-call round trip between your app and any provider that implements /v1/responses, such as OpenAI, Ollama, vLLM, OpenRouter, or Hugging Face. One: the app sends a message item from the user. Two: the provider returns a function_call item with call_id, name, and arguments. Three: the app runs the tool locally and sends a function_call_output item with the same call_id. Four: the provider returns an assistant message item. Footer: the shape is the same everywhere, but the model is not; extras use prefixed types such as openai:web_search_call, and tool support, limits, and price still differ by provider.
The same four items work against every implementation. Provider behavior behind them still differs.Open full size →
Minimal request to an Open Responses endpoint (/v1/responses)
{
  "model": "your-model-id",
  "input": [
    {
      "type": "message",
      "role": "user",
      "content": "Find the bug in fizz_buzz()."
    }
  ]
}

// A tool call comes back as an item:
// { "type": "function_call", "name": "...", "call_id": "...", "arguments": "{...}" }
// You reply with { "type": "function_call_output", "call_id": "...", ... }
04

OpenEnv: repeatable environments for training and evaluating agents

A framework for agent environments with a Gymnasium-style API: reset(), step(), and state(), served over a WebSocket from a Docker image.

Problem it solves: to train or evaluate an agent, you need a place where it can take actions, see the results, and get scored, under the same conditions every run. Building those environments by hand for each project is slow and hard to share.

Each OpenEnv environment is a Docker image that runs locally, on a cloud sandbox, or as a Hugging Face Space. Clients call reset() to start an episode, step() to take an action and get an observation and reward, and state() to inspect the episode. Calls can be sync or async.

The catalog lists more than 40 environments, including games, coding sandboxes, browsers, finance tasks, and simulators. Training integrations named in the docs include TRL, Unsloth, SkyRL, ART, Oumi, and torchforge. A Harbor environment runs coding agents such as Claude Code, Codex, and OpenCode and captures their tokens for reinforcement learning.

Example: to train a coding agent, an environment provides the repository, exposes the allowed actions, applies the agent's changes, runs the tests, and returns the result as an observation and reward. Every agent you compare faces the same repository and the same tests.

Watch out: a shared interface does not make a benchmark meaningful. Scores depend on task choice, scoring method, data quality, and how close the environment is to real use. Document your conditions, and do not compare scores across different environments as if they were the same test.

The OpenEnv loop. On the left, your agent or a training framework such as TRL, Unsloth, SkyRL, ART, or Oumi, using a sync or async client. On the right, an environment packaged as a Docker image, for example a coding task with a repository, allowed actions, and a test runner that produces the reward; it runs on local Docker, a cloud sandbox, or a Hugging Face Space. Between them, three calls over a WebSocket: reset() starts an episode and returns the first observation, step(a) applies an action and returns an observation, reward, and done flag, and state() inspects the episode. The loop repeats until done. Footer: same task and same tests for every agent you compare, but a shared interface does not make a score meaningful.
Three calls over a WebSocket. The environment image is what keeps every run comparable.Open full size →
First episode against the hosted echo environment (Python)
import asyncio
from echo_env import CallToolAction, EchoEnv

async def main():
    async with EchoEnv(base_url="https://openenv-echo-env.hf.space") as client:
        result = await client.reset()
        print(result.observation.metadata["message"])

        result = await client.step(
            CallToolAction(
                tool_name="echo_message",
                arguments={"message": "Hello, World!"},
            )
        )
        print(result.observation.result["data"])
        print(result.reward)

asyncio.run(main())
Install OpenEnv and the echo environment client (all platforms)
pip install openenv
pip install git+https://huggingface.co/spaces/openenv/echo_env

Tip
The docs include a five-part getting started series that needs no GPU. Run it before you plan a training pipeline around OpenEnv.

05

OpenSandbox: an isolated place to run agent-generated code

A sandbox platform for AI applications with SDKs in several languages, one sandbox API, and Docker or Kubernetes runtimes.

Problem it solves: agents need to run code, inspect repositories, drive browsers, and execute multi-step workflows. Doing that on a developer laptop or an application server gives generated code the same access as everything else on that machine.

OpenSandbox runs that work in an isolated environment behind a single API. SDKs exist for Python, Java and Kotlin, TypeScript and JavaScript, C# and .NET, and Go, plus a CLI (osb) and an MCP server. Docker handles local execution, Kubernetes handles cluster deployment, and a faster runtime uses Firecracker microVMs on Kubernetes. It is Apache 2.0 licensed.

Example: an agent needs to analyze a CSV with Python. Instead of running generated code on your server, the app creates a sandbox, gives it only that file, runs the code, and returns only the permitted output.

Watch out: containers alone do not make a sandbox secure. Isolation depends on configuration, runtime hardening, network policy, credential handling, host protections, and the permissions you grant the workload. Keep secrets out of the sandbox, set resource limits and network rules, and test that the boundary holds before you route real data through it.

Running agent-generated code with and without OpenSandbox. Without a sandbox, the app server runs analyze.py, which can reach app secrets and environment variables, the production database, every file on disk, and the open internet: the same access as your application. With OpenSandbox, the app keeps its secrets, database, and files, and calls the sandbox through an SDK in Python, TypeScript, Java, C#, or Go. It sends only data.csv into the sandbox, which holds analyze.py and the CSV only, no secrets, limited network, and CPU and memory limits, and gets back only the result. Runtimes are Docker locally or Kubernetes in a cluster, under Apache 2.0. Footer: a container is not a boundary until you configure and test it.
The sandbox gets the one file it needs and nothing else. Configuration decides how strong that boundary is.Open full size →
macOS / Linux: start a local OpenSandbox server on Docker
uvx opensandbox-server init-config ~/.sandbox.toml --example docker
uvx opensandbox-server
Windows PowerShell: start a local OpenSandbox server on Docker
uvx opensandbox-server init-config "$HOME\.sandbox.toml" --example docker
uvx opensandbox-server
Install an SDK or the CLI
pip install opensandbox            # Python SDK
npm install @alibaba-group/opensandbox  # TypeScript SDK
pip install opensandbox-cli        # osb command

Tip
The README lists Docker and Python 3.10+ as requirements without naming operating systems. On Windows, Docker Desktop with WSL 2 is the path we would try first. That is our suggestion, not a documented requirement.

06

How do the four projects fit together?

They sit at different layers. Use one, several, or none, depending on the problem you have now.

Picture a coding assistant built from all four. Agent Skills holds the team's code-review and testing procedures. Open Responses is how the app talks to whichever model provider it uses. OpenEnv provides repeatable repository tasks for evaluating or training the agent. OpenSandbox runs the code the agent writes, away from your servers.

In that design, a task arrives, the agent loads the matching skill, calls the model through one interface, tests its work in an isolated environment, and returns the result.

This is an illustration, not a claim that the four integrate out of the box. Each has its own release cycle, and any integration between specific versions is work you have to do and verify.

Where the four AAIF projects sit in an AI coding assistant. Agent Skills, from Anthropic, is the knowledge layer: SKILL.md procedures loaded on demand. Open Responses, from OpenAI, is the model interface layer: one request and item format across providers. OpenSandbox, from Alibaba, is the execution layer: isolated runtimes on Docker or Kubernetes for generated code. OpenEnv, from Hugging Face, sits beside the runtime path as the training and evaluation layer: reset, step, and state environments for repeatable tasks. A footer notes that the layers are complementary, not interchangeable, and that integration between them must be verified.
Four layers, four contributors. Pick the layer where you feel the pain today.Open full size →
07

What to check before you adopt any of them

Run a small, representative workload against your current setup before you commit, and test the security boundary first.

Compatibility: does it support your language, framework, and deployment target? Is the feature you need implemented in the version you would ship? Does it fit your model and tool stack?

Security: how are permissions enforced and secrets handled? Can untrusted content influence what runs? What isolation and network controls exist? How are vulnerabilities reported and fixed?

Governance and licence: which licence covers the spec, the code, and supporting assets? Who maintains it, how are changes approved, and is there a versioning and compatibility policy?

Operational readiness: are install and deploy docs complete? Are there tests, examples, and troubleshooting guides? Can you monitor failures and recover an interrupted workflow?

Evaluation: pick a small workload, measure your current implementation as a baseline, then measure compatibility, correctness, latency, reliability, and cost with the new project. Adopt one piece at a time and write down the gaps you find.

The four projects at a glance

Project and contributorWhat it is for
Agent Skills (Anthropic)Package reusable instructions, scripts, and reference files that agents load on demand.
Open Responses (OpenAI)One open request and response format for calling many model providers.
OpenEnv (Hugging Face)Interoperable environments for agent training, reinforcement learning, and evaluation.
OpenSandbox (Alibaba)Isolated runtimes for executing agent-generated code and workflows.

Which one should you look at first?

  • Agent Skills: your agents keep getting the same procedure wrong, or you paste the same long instructions into every project.
  • Open Responses: you support more than one model provider, or expect to, and the adapter code is growing.
  • OpenEnv: you are building training pipelines, reinforcement learning workflows, or repeatable evaluation tasks.
  • OpenSandbox: your app runs generated code, and today that code runs with the same access as your application.
  • None of them: if none of those problems is real for you yet, wait. You do not need all four to benefit from open agent infrastructure.

What to watch next

The announcement establishes that the projects were contributed. It does not show that all four are equally mature or that their roadmaps are settled.

  • Specification releases and breaking changes.
  • Maintainer lists and governance documents.
  • Security advisories and how quickly they are handled.
  • Independent implementations and interoperability test results.
  • Production use backed by technical write-ups, not press quotes.

The trade-offs worth knowing

  • Early projects move. OpenEnv says its APIs may still change, so pin versions and expect migration work.
  • A common format adds a layer. Open Responses can hide useful provider features behind a lowest common denominator unless you use the prefixed extensions.
  • Skills spread instructions and scripts across teams. That is the point, and it also means a bad or malicious skill spreads the same way.
  • A sandbox platform is infrastructure you now run and patch. A misconfigured sandbox can give false confidence.
  • Benchmarks built on shared environments are easy to publish and easy to over-read.

Our verdict

Agent Skills is the easiest to adopt today: it is a folder of Markdown, the spec is short, and many agents already load it. Open Responses is worth adopting if you already juggle providers. OpenEnv and OpenSandbox solve real problems but ask for more infrastructure and more testing before production use.

Foundation hosting is a good sign for long-term neutrality. Judge each project on its code, docs, and security record, not on the logo above it.

Personal verdict

My verdict: start with Agent Skills for any workflow you repeat, move to Open Responses when a second model provider shows up, and bring in OpenSandbox before you let an agent run generated code anywhere near real data. Try OpenEnv when you are ready to measure agents, not before.

Frequently asked questions

What is the Agentic AI Foundation?+

A Linux Foundation project that provides a vendor-neutral home for open AI agent standards and tools. It hosts MCP, A2A, AGENTS.md, goose, Agent Router, agentgateway, and since October 22, 2026, Agent Skills, Open Responses, OpenEnv, and OpenSandbox.

Do I need all four projects?+

No. They solve different problems at different layers. Adopt the one that matches a problem you have now, and ignore the rest until you need them.

Does Open Responses make all model providers behave the same?+

No. It standardizes the request and response format. Providers still differ in tool support, context limits, multimodal input, error behavior, latency, and price, so test each feature you depend on.

Are Agent Skills safe to download and use?+

Not automatically. A skill can steer the agent and include scripts it may run. Review third-party skills like any other code, and limit what your agent is allowed to execute.

Is OpenEnv only for reinforcement learning?+

No. It was built for RL, but the same reset, step, and state environments are useful for repeatable evaluation of any agent, and MCP environments can serve tools to agents.

Does OpenSandbox work on Windows?+

The README requires Docker and Python 3.10+ and does not list operating systems. Docker Desktop with WSL 2 is the likely path on Windows, but test it before relying on it.

Does moving to a foundation mean these projects are production-ready?+

No. Foundation hosting covers governance and neutrality. Maturity, compatibility, and security still have to be checked project by project and version by version.

Sources & further reading

Sources and further reading

More practical field notes from Agent Builders HQ are on the way.

Stay tuned →