OpenAI, Anthropic and Google Found Agentic AI Foundation: What This Changes

Hello HaWkers, something historic happened in December 2025: OpenAI, Anthropic and Block co-founded the Agentic AI Foundation (AAIF) under the Linux Foundation. Google, Microsoft, AWS, Bloomberg and Cloudflare are also members.

These intense rivals decided to collaborate to create open standards for AI agents. This could fundamentally change how we develop with artificial intelligence.

What Is the Agentic AI Foundation

The AAIF is a non-profit organization dedicated to standardizing how AI agents interact with systems.

Founders and Members

Participating companies:

Category	Companies
Co-founders	OpenAI, Anthropic, Block
Core Members	Google, Microsoft, AWS
Members	Bloomberg, Cloudflare
Governance	Linux Foundation

Donated Technologies

Each founder donated key technology:

Contributions:

Anthropic: MCP Protocol
OpenAI: Agents.md Specification
Block: Goose Framework

Why This Matters

AI agents are everywhere, but each speaks a different language:

The Current Problem

Market fragmentation:

Claude uses MCP
ChatGPT uses proprietary plugins
Gemini has its own API
Each agent is an island

The Proposed Solution

Open standards mean:

Benefits:

Agents from different companies communicate
Tools work with any LLM
Developers write once
Users choose freely

Anthropic's MCP Protocol

The Model Context Protocol is the foundation's base:

What Is MCP

MCP defines how agents interact with external tools:

// MCP server example
// Defines tools that agents can use

const mcpServer = {
  name: "database-tools",
  version: "1.0.0",
  tools: [
    {
      name: "query_database",
      description: "Executes SQL queries",
      parameters: {
        query: { type: "string", required: true }
      },
      handler: async ({ query }) => {
        const result = await db.execute(query);
        return { rows: result };
      }
    },
    {
      name: "list_tables",
      description: "Lists available tables",
      handler: async () => {
        return { tables: await db.getTables() };
      }
    }
  ]
};

How It Works

Communication flow:

Agent discovers available tools
Agent calls tool with parameters
Server executes and returns result
Agent uses result to continue

MCP Advantages

Why it was chosen:

Protocol already in production
Supported by Claude
Active community
Extensible

OpenAI's Agents.md

The specification that describes codebases for agents:

The Concept

Agents.md is a file that explains your project to AI agents:

# Agents.md

## Project Overview
This is an e-commerce in Next.js 14 with Prisma and PostgreSQL.

## Architecture
- `/app` - App Router pages
- `/components` - React components
- `/lib` - Utilities and helpers
- `/prisma` - Schema and migrations

## Key Commands
- `npm run dev` - Development server
- `npm run build` - Production build
- `npm run test` - Run tests

## Important Context
- We use Tailwind for styling
- Auth via NextAuth with Google provider
- Payments via Stripe

## Coding Standards
- TypeScript strict mode
- Functional components with hooks
- Tests with Jest and Testing Library

Why It's Important

Benefits for agents:

Understand the project quickly
Fewer questions for the user
More consistent code
Standardized context

Block's Goose Framework

The open source framework for building agents:

What Is Goose

Goose is a framework for creating AI agents that execute tasks:

# Simplified Goose agent example
from goose import Agent, Tool

class FileSearchTool(Tool):
    name = "search_files"
    description = "Search files in the project"

    def run(self, pattern: str) -> list:
        return glob.glob(pattern, recursive=True)

class CodeEditTool(Tool):
    name = "edit_code"
    description = "Edit code files"

    def run(self, filepath: str, changes: dict) -> bool:
        # Apply changes to file
        return apply_changes(filepath, changes)

# Creating agent with tools
agent = Agent(
    tools=[FileSearchTool(), CodeEditTool()],
    model="claude-3-opus"
)

# Agent executes task
result = agent.run("Refactor the auth system to use JWT")

Goose Differentiators

Features:

Fully open source
Multiple models supported
Plugin system
Integrated security

Impact For Developers

What changes in practice:

1. Interoperability

Tools that work anywhere:

// MCP tool compatible with all agents
const universalTool = {
  // Works with Claude, ChatGPT, Gemini, etc
  name: "deploy_app",
  description: "Deploy application to production",
  parameters: {
    environment: { type: "string", enum: ["staging", "production"] }
  },
  handler: async ({ environment }) => {
    return await deployPipeline(environment);
  }
};

2. Less Vendor Lock-in

Switch LLMs without rewriting:

Before scenario:

Claude: specific code
ChatGPT: proprietary plugins
Gemini: different API

After scenario:

One integration
Works with all
Free choice

3. Unified Ecosystem

Community tools grow:

Possible developments:

MCP tools marketplace
Standardized libraries
Reusable templates
Native IDE integration

The Competitive Landscape

Why are rivals collaborating?

Common Interest

Everyone wins with standards:

Motivations:

Larger market for everyone
Lower development costs
Faster adoption
Less fragmentation

What Remains Competitive

Standards don't eliminate competition:

Areas of differentiation:

Base model quality
Performance and latency
Pricing
Exclusive features

Success History

Open standards have worked before:

Examples:

HTTP created the web
USB standardized connections
OpenAPI for REST APIs
GraphQL for queries

The Role of Linux Foundation

Why LF was chosen:

Credibility

Track record:

Linux kernel
Kubernetes
Node.js
GraphQL Foundation

Neutral Governance

Structure:

No company controls
Consensus decisions
Transparency
Open community

How to Prepare

What to do now as a developer:

1. Learn MCP

Start experimenting:

# Install MCP SDK
npm install @anthropic/mcp-sdk

# Or clone examples
git clone https://github.com/anthropics/mcp-examples

2. Add Agents.md

Document your projects:

Recommended structure:

Project overview
Architecture
Important commands
Code patterns
Relevant context

3. Experiment with Agents

Practice with current tools:

Options:

Claude Code
GitHub Copilot Agent Mode
Cursor Composer
Goose framework

4. Follow the Foundation

Stay updated:

Sources:

Linux Foundation blog
Official repositories
Company announcements
Developer communities

Outlook For 2026

What to expect:

Short Term

Coming months:

Version 1.0 of unified standard
More companies joining
Initial tools
Expanded documentation

Medium Term

Next year:

Mainstream adoption
Tools marketplace
IDE integration
Advanced use cases

Long Term

2027+:

Industry standard
Truly interoperable agents
Enterprise automation
New development paradigm

Final Thoughts

The creation of the Agentic AI Foundation is a historic moment. For the first time, the biggest AI players are collaborating on open standards.

For developers, this means less fragmentation and more options. Tools you build will work with any agent. Skills you develop will be transferable.

The most important thing is to start experimenting now. MCP is already in production, Agents.md is simple to add, and Goose is open source. The sooner you familiarize yourself, the better positioned you'll be when these standards become mainstream.

If you want to understand the context of competition between these companies, I recommend: Anthropic Acquires Bun: What This Means For JavaScript where I analyze Anthropic's strategic acquisition.

Let's go! 🦅

📚 Want to Deepen Your JavaScript Knowledge?

With AI agents increasingly integrated into development, mastering JavaScript remains essential. It's the language that connects everything.

Complete Study Material

If you want to master JavaScript from basics to advanced, I've prepared a complete guide:

Investment options:

1x of $4.90 on card
or $4.90 at sight

👉 Learn About JavaScript Guide

💡 Material updated with industry best practices