Four Layers of the Agent Stack Just Got a Neutral Home

On October 22, 2026, at AGNTCon + MCPCon North America in San Jose, the Agentic AI Foundation announced four new projects: Agent Skills contributed by Anthropic, Open Responses contributed by OpenAI, OpenEnv contributed by Hugging Face, and OpenSandbox contributed by Alibaba. Those donations take AAIF from three hosted projects to ten inside its first year. Each one sits on a different layer of the agent stack: how agents gain new capabilities, how applications talk to models across providers, how agents are trained and evaluated, and where agent code runs safely. The four contributors are also competitors, which is the more interesting part. This post is not a standards cheer. It answers three questions: what each layer solves, whether your code should change today, and how to verify vendor-neutral governance in engineering terms rather than in press releases.

Four layers, four contributors, one neutral home

1. What Was Actually Announced

The announcement is specific: AAIF added four hosted projects, contributed by Anthropic, OpenAI, Hugging Face and Alibaba, bringing it to ten hosted projects in its first year, up from three launch projects in December 2025. They join the Agent2Agent (A2A) protocol, Agent Router, agentgateway, AGENTS.md, goose and the Model Context Protocol as AAIF projects, all operating under its open, vendor-neutral governance. The venue was named too: AGNTCon + MCPCon North America, October 22 to 23 at the San Jose McEnery Convention Center. Manik Surtani, CTO and co-founder of AAIF, framed it as a bet that paid: a year ago they launched with three projects and the belief that agentic AI needed a neutral home to thrive, and now four different companies have chosen to contribute to neutral governance.

# 1) Agent Skills: a skill is a folder, not a prompt.
#    Instructions, scripts and resources ship together and load on demand.
deploy-helper/
  SKILL.md                 # name, description, when to use it
  scripts/rollback.sh
  references/runbook.md
# SKILL.md front matter (shape of the open format):
#   name: deploy-helper
#   description: Promote or roll back a staging deploy. Use for deploy questions.
# Body: the steps, the guardrails, and what to do when a check fails.
# Keep it short. The agent reads this every time the skill triggers.

2. The Four Layers, One by One

The first layer is capability. Agent Skills is an open format for giving agents new capabilities and domain expertise, packaging instructions, scripts and resources into reusable units that an agent loads on demand, so specialized know-how becomes portable across products and platforms. Note the positioning: not a prompt template, but a loadable directory that can carry executable scripts alongside prose. The second layer is the model interface. Open Responses is an open specification for multi-provider, interoperable LLM interfaces, based on OpenAI's Responses API, defining a shared schema, consistent streaming events and extensible tooling so a developer describes a request once and runs it across providers with minimal translation. The third is training and evaluation. OpenEnv is an open framework and community hub for creating reinforcement learning environments, built around a containerized service exposing an agent interface, MCP and the Gym training protocol; its documented contract is Gymnasium-style reset, step and state. The fourth is execution. OpenSandbox is an execution environment for agents that need to run untrusted code safely, isolating code, file operations, package installs and network access from the host and from sibling sandboxes; it is Apache 2.0 and was already public before this donation.

// 2) Open Responses: one request shape, many providers.
//    Wrap the call once so streaming events and tool calls stop being
//    provider-specific at every call site.
type ResponsesRequest = {
  model: string;
  input: Array<{ role: "user" | "assistant"; content: string }>;
  stream: boolean;
};

async function send(baseUrl: string, apiKey: string, body: ResponsesRequest) {
  const res = await fetch(baseUrl + "/v1/responses", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: "Bearer " + apiKey,
    },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(baseUrl + " returned " + res.status);
  return res;
}

// The point is not abstraction for its own sake. It is that a second
// provider becomes a baseUrl change instead of a second implementation.

3. Why the Contributors Matter More Than the Host

Hosting in a foundation is not new. What is interesting is that the four contributions close a loop: Anthropic handed over the packaging format for agent capabilities, OpenAI handed over the model call specification, Hugging Face handed over the training environment, and Alibaba handed over the execution sandbox. None of the four can gain a decisive advantage by unilaterally controlling these standards, which is exactly why neutral governance is the rational move, and MCP already showed the path. David Soria Parra, co-creator and lead maintainer of MCP at Anthropic, put it plainly in the announcement: without the right context even the most intelligent agents fall short, and donating Agent Skills to AAIF means anyone building with skills can shape what comes next. OpenAI's Steve Coffey emphasized simple, clean, unified interfaces. The practical meaning for developers is narrower than the press release: these layers are turning from implementation details into specifications you can cite in a design document, so the migration budget you hold back can shrink a little, but only after you check whether the implementations you depend on actually track the spec.

# 3) OpenEnv: the training and evaluation layer.
#    Gymnasium-style contract - reset, step, state - so a run is replayable.
#    Import names are a sketch; check the project docs for the real API.
from openenv import Client

env = Client("https://huggingface.co/spaces/you/calendar-admin")
obs = env.reset()

done = False
while not done:
    action = your_policy(obs)            # your agent, unchanged
    obs, reward, done, info = env.step(action)

print(env.state())                       # inspect the end state, not a vibe

# Same env, same seed, same reward function, two model checkpoints:
# that is the only way an eval number means anything.

4. What It Changes for Ordinary Developers

A little cold water first: a standard existing does not mean an ecosystem exists. AAIF now hosts ten projects and your stack probably uses none of them, which is fine. The mistake is reading neutral governance as a quality guarantee. A specification lives or dies on implementation count: how many providers implement Open Responses, how many environments land in the OpenEnv hub, how many runtimes embed OpenSandbox. Those numbers, not the announcement, decide whether switching vendors costs a config change or a rewrite. So the move today is three small things. Draw the four layers on your architecture diagram and label who currently occupies each. Write one sentence per layer on who you would switch to if that vendor raised prices or shut the product down. And if you are building an agent product, make the capability layer a loadable directory first, because it is both the easiest to migrate and the easiest to turn into technical debt. Whether to move the model layer onto Open Responses is a pain question: one provider means do nothing; three or four providers and streaming event formats that disagree means it is worth it.

# 4) OpenSandbox: the execution layer - untrusted code in, artifacts out.
#    Someone else's generated code never runs on your host.
import asyncio
from opensandbox import Sandbox

async def run_generated_code(code: str):
    box = await Sandbox.create("python:3.12-slim")
    try:
        await box.files.write("/tmp/task.py", code)
        result = await box.commands.run("python /tmp/task.py")
        return result.logs.stdout, result.exit_code
    finally:
        await box.destroy()      # never leave a sandbox running

asyncio.run(run_generated_code("print(sum(range(10)))"))

5. Code: One Minimal Example per Layer

The first snippet is the shape of a skill: a folder, a SKILL.md carrying a name and a description, plus scripts and references. The craft is not writing more, it is writing a description that tells the agent exactly when to load it, because that description is the trigger condition. The second is a thin wrapper over an Open Responses call: a fixed request shape where the provider appears only as a baseUrl and a key, so a second provider is a config change rather than a second implementation. The third is the OpenEnv loop: reset, step, state, because the same environment with the same seed and the same reward function across two checkpoints is the only way an eval number means anything. The fourth wraps execution in OpenSandbox: write the code into the box, run it there, and destroy the box in a finally block. Never leave a sandbox running; that is the most common mistake at the execution layer. The fifth is not code but a review rule: every dependency in these four layers must document how it would be replaced. If that cannot be written, it does not merge.

# 5) Neutral governance only exists if you can actually swap pieces.
#    Track which layer each dependency occupies, and require an exit plan.
layers:
  skills:       [agent-skills]
  model_api:    [open-responses]
  environments: [openenv]
  execution:    [opensandbox]

review_rule: |
  A new dependency in these layers must document how it would be replaced
  by a different implementation. No exit plan, no merge. A standard you
  cannot swap out of is just a vendor with better marketing.

6. How to Tell in a Year Whether This Won

Four signals, none of them press releases. First, implementation count: when a third or fourth independent implementation shows up on the same layer, a single-vendor spec becomes an actual standard; until then it is product documentation. Second, migration cost: moving a real agent between two sandbox runtimes, or two model providers, measured in hours or weeks. Third, governance behavior: whether the technical committee actually rejects proposals or just stamps them, and OpenEnv's public committee list, spanning Meta-PyTorch, Reflection, Unsloth, Modal, Prime Intellect, Nvidia, Mercor, Fleet AI and Hugging Face, is at least structured so that a rejection is possible. Fourth, your own architecture: in a year, is your capability layer a directory, your execution layer a sandbox, and your model layer a swappable wrapper. The first three are not up to you. The fourth is entirely up to you. Standards hand you an opening, not a guarantee.