AIFF Standards - The Foundation

AIFF Standards - The Foundation

You’ve built a Sales Development Representative (SDR) agent that qualifies leads 24/7. It works brilliantly with Claude. Now a client asks: “Does it work with ChatGPT? We’re standardizing on OpenAI.”

What do you say?

Before December 9, 2025, you’d face an uncomfortable choice: rebuild for their platform, or lose the deal. Your expertise—the qualification logic, the CRM integrations, the follow-up workflows—was locked to one vendor.

AAIF changes this equation entirely.

The Agentic AI Foundation is a Linux Foundation initiative announced December 9, 2025. It provides neutral governance for the open standards that power AI agents—ensuring your AI agents are portable investments, not platform prisoners.

On that date, something unprecedented happened: OpenAI, Anthropic, and Block—companies that compete fiercely for AI market share—came together under the Linux Foundation to donate their core technologies to neutral governance. They were joined by Amazon Web Services, Google, Microsoft, Bloomberg, and Cloudflare as platinum members.

As Jim Zemlin, Executive Director of the Linux Foundation, stated:

“We are seeing AI enter a new phase, as conversational systems shift to autonomous agents that can work together. Within just one year, MCP, AGENTS.md and goose have become essential tools for developers building this new class of agentic technologies.”

The insight: infrastructure that everyone needs should belong to everyone. Compete on products built atop shared foundations, not on the foundations themselves.

---

The USB Lesson: Why Standards Win

Before USB became a standard, every device had proprietary connectors. Your phone charger wouldn’t work with your camera. Your printer needed a special cable. Switching devices meant buying new cables and throwing away old ones.

Then USB standardized device connections:

• Any USB device works with any USB port
• Manufacturers compete on device quality, not connector lock-in
• Consumers buy with confidence—their investment is portable

AAIF is the USB Implementers Forum for AI agents.

Just as USB needed a neutral standards body (the USB Implementers Forum) to ensure any device works with any port, AI agents need AAIF to ensure your AI agents work across any platform. AAIF governs the standards; the standards themselves create the actual portability.

Without Open Standards	With AAIF Standards
Rebuild integrations for each AI platform	Write once, deploy everywhere
Skills locked to Claude or ChatGPT	Skills work across all major agents
Custom code for every client’s tools	Universal protocol for tool connectivity
Platform vendor lock-in	Switch providers without rebuilding

The economic logic is identical: standards create larger markets, which benefit everyone more than fragmented proprietary ecosystems.

---

The Five Standards Foundation

AAIF launched with five projects that together form a complete foundation for portable AI agents:

1. Model Context Protocol (MCP) — From Anthropic

The Problem It Solves: Your Sales Agent needs CRM access. Your Accounting Assistant needs database connections. Your Legal Assistant needs document repositories. Before MCP, you’d write custom integration code for each combination of agent and tool.

graph LR
    subgraph MxN ["The M x N Problem"]
    Claude -->|"Custom Code"| Salesforce
    ChatGPT -->|"Custom Code"| Salesforce
    Gemini -->|"Custom Code"| Salesforce
    Claude -->|"Custom Code"| HubSpot
    ChatGPT -->|"Custom Code"| HubSpot
    end
    
    style Claude fill:#e1f5fe
    style ChatGPT fill:#e8f5e9
    style Gemini fill:#fff3e0

Three AI platforms × two CRMs = six custom integrations. Add Pipedrive, Zoho, Freshsales, calendar, email, database? The combinations explode. This is the M×N problem: M different AI models connecting to N different tools requires M×N custom integrations.

What MCP Enables: One standard protocol for all agent-to-tool connections. Write an MCP server once, and any MCP-compatible agent can use it—Claude, ChatGPT, Gemini, goose, or your Custom Agents.

MCP enables the “Act” power from Chapter 1. Without MCP, your AI agent can reason brilliantly about what to do—but it can’t actually do it. It can plan the perfect follow-up email, but it can’t send it. With MCP, your Sales Agent connects to CRM systems, email platforms, calendars, and databases.

Three Universal Primitives:

Primitive	Purpose	Physical Metaphor	Digital SDR Example
Resources	Read-only data	Eyes (see, don’t touch)	Lead data from CRM, email history
Tools	Actions that change state	Hands (make things happen)	Send email, update deal stage, schedule meeting
Prompts	Reusable templates	Playbooks (standard approaches)	Lead qualification checklist, follow-up email structure

Getting this wrong breaks your AI agent. Exposing “send email” as a Resource means your agent can see the option but can’t actually send. Universal standards prevent universal confusion.

Architecture: Host → Client → Server

graph TD
    subgraph HostScope ["HOST Application"]
        Client["CLIENT<br/>Manages MCP connections"]
    end
    
    subgraph ServerScope ["SERVER<br/>CRM, DB, API"]
        Capabilities["Resources | Tools | Prompts"]
    end

    Client <==>|"MCP Protocol<br/>JSON-RPC"| Capabilities
    
    style HostScope fill:#e3f2fd,stroke:#1565c0
    style ServerScope fill:#f3e5f5,stroke:#4a148c
    style Client fill:#bbdefb,stroke:#0d47a1

Adoption Timeline:

Date	Milestone
November 2024	Anthropic releases MCP as open source
Early 2025	Block, Apollo, Replit, Zed, Sourcegraph adopt
March 2025	OpenAI officially adopts MCP across products
April 2025	Google DeepMind confirms MCP support for Gemini
November 2025	MCP specification 2025-11-25 with OAuth 2.1, Streamable HTTP
December 2025	MCP donated to AAIF under Linux Foundation governance

As Mike Krieger, Chief Product Officer at Anthropic, stated:

“When we open sourced it in November 2024, we hoped other developers would find it as useful as we did. A year later, it’s become the industry standard for connecting AI systems to data and tools.”

---

2. AGENTS.md — From OpenAI

The Problem It Solves: You’re deploying your Digital SDR to 100 clients. Each has different coding conventions, different build systems, different security requirements. Does each deployment require custom configuration?

What AGENTS.md Enables: A standard Markdown file that teaches AI agents local rules. Your AI agent reads each client’s AGENTS.md and immediately understands their environment—zero customization needed.

Why AGENTS.md Exists: Humans ≠ Agents

Every developer knows README.md. It tells humans what the project does, how to install it, how to contribute. But AI agents need different information:

Humans Need	Agents Need
Project motivation and goals	Build and test commands
Getting started tutorial	Code style rules
Contribution guidelines	Security constraints
Screenshots and demos	File organization patterns

README.md answers “What is this project?” AGENTS.md answers “How should I behave in this project?”

What Goes in AGENTS.md:

## Build Commands
- `pnpm install` - Install dependencies
- `pnpm run build` - Production build
- `pnpm test` - Run all tests
## Code Style
- Use TypeScript strict mode for all new code
- Maximum function length: 50 lines
- File names: kebab-case (e.g., `user-profile.tsx`)
## Security
- Never hardcode API keys, tokens, or secrets
- Use environment variables for all credentials
- No `eval()` or `Function()` constructors
## Architecture
- All API routes go in `/src/api/`
- Database queries only through `/src/db/` layer

The Hierarchy Rule: The nearest AGENTS.md file takes precedence. This enables monorepo support where different subprojects have different conventions:

graph TD
    Root["company/AGENTS.md<br/>Root: company-wide rules"]
    Pkg["packages/"]
    Frontend["frontend/AGENTS.md<br/>Frontend-specific rules"]
    Backend["backend/AGENTS.md<br/>Backend-specific rules"]
    
    Root --> Pkg
    Pkg --> Frontend
    Pkg --> Backend
    
    style Root fill:#fff9c4,stroke:#fbc02d
    style Frontend fill:#fff9c4,stroke:#fbc02d
    style Backend fill:#fff9c4,stroke:#fbc02d

Adoption: Since OpenAI introduced AGENTS.md in August 2025, it has been adopted by 60,000+ open-source projects and every major AI coding agent: Claude Code, Cursor, GitHub Copilot, Gemini CLI, Devin, goose, and more. OpenAI’s own repository contains 88 AGENTS.md files.

---

3. goose — From Block

The Problem It Solves: MCP tells agents how to connect. AGENTS.md tells them how to behave. But what does a production agent implementing both actually look like?

What goose Enables: A reference architecture for building production agents. Not a demo—the same technology where 75% of Block engineers save 8-10+ hours every week. Apache 2.0 licensed, so you can study the source code.

Why Reference Implementations Matter: When you build Custom Agents (Part 6), you’ll face questions: How should I structure MCP client connections? How do I handle streaming responses? What’s the right way to manage conversation context? You could solve these from first principles. Or you could study how goose solved them—then adapt those patterns to your needs.

goose in the Two Paths Framework: Remember Chapter 1’s Two Paths? Path A: General Agents (ready-to-use like Claude Code, goose). Path B: Custom Agents (built from SDKs). goose is a Path A agent, but it’s open source—making it your blueprint for Path B.

Learning Path	What You Get
From specs only	Correct but untested patterns
From tutorials	Simplified patterns that break at scale
From goose	Battle-tested patterns from enterprise use

Key Architecture Patterns:

1. Local-First Execution: Your code and data stay local. For enterprise clients with sensitive IP, this isn’t optional—it’s required.
2. MCP-Native Design: Adding capabilities means connecting MCP servers. No custom integration code. Every capability follows the same pattern.
3. Multi-Model Support: Support for Claude, GPT-4, Gemini, Ollama. You can even configure different models for different tasks—cheaper model for simple operations, premium model for complex reasoning.

goose vs Claude Code: Both are General Agents validating the same standards.

Aspect	Claude Code	goose
Creator	Anthropic	Block
License	Proprietary	Open Source (Apache 2.0)
MCP Support	Yes	Yes
AGENTS.md Support	Yes	Yes
Source Code	Closed	Open

Use Claude Code for productivity today. Study goose for building Custom Agents tomorrow.

---

4. Agent Skills — Packaging Expertise

The Problem It Solves: You’ve spent years mastering financial analysis, or legal document review, or sales qualification. That expertise lives in your head—tacit knowledge that makes you valuable but can’t scale. Every time a client asks you to do what you’re expert at, you trade time for money. You’re the bottleneck.

What Skills Enable: Agent Skills let you package that expertise. Remember the Matrix? Trinity needs to fly a helicopter. She doesn’t know how. Tank loads the skill. Seconds later: “Let’s go.” That’s what you’re building. Your domain expertise—years of pattern recognition, decision frameworks, workflow optimization—encoded into portable skills that any AI agent can load when needed.

The SKILL.md Format:

---
name: financial-analysis
description: Analyze financial statements and generate investment reports. Use when reviewing quarterly earnings, comparing company metrics, or preparing investor summaries.
---
# Financial Analysis Skill
## When to Use
- User asks for financial statement analysis
- Quarterly earnings data needs interpretation
- Investment comparison is requested
## How to Execute
1. Gather the relevant financial documents
2. Extract key metrics (revenue, margins, growth rates)
3. Compare against industry benchmarks
4. Generate structured report with recommendations
## Output Format
- Executive summary (3 sentences max)
- Key metrics table
- Year-over-year comparison
- Risk factors
- Recommendation

Progressive Disclosure: The Token Efficiency Secret

Loading everything upfront wastes tokens. If an agent loaded all 50 available skills at startup—full instructions, templates, examples—you’d burn through your context window before doing any actual work.

The solution is progressive disclosure: loading only what’s needed, when it’s needed.

graph TD
    L1["Level 1: Agent Startup<br/>~100 tokens"]
    L2["Level 2: Skill Activated<br/>&lt; 5K tokens"]
    L3["Level 3: Actually Needed"]
    
    L1 -->|"Contains"| Meta["Metadata: Name, Description"]
    L2 -->|"Contains"| Full["Full SKILL.md content"]
    L3 -->|"Contains"| Resources["Templates, Examples, Scripts"]
    
    L1 --> L2 --> L3
    
    style L1 fill:#e8f5e9
    style L2 fill:#fff3e0
    style L3 fill:#ffebee

80-98% token reduction. This means your AI agent can have dozens of capabilities available without bloating its context window.

MCP + Skills: Complementary Standards

Standard	Purpose	Physical Metaphor
MCP	Connectivity — how agents talk to tools	The agent’s hands
Skills	Expertise — what agents know how to do	The agent’s training

Example: Digital SDR Processing Stripe Payments

• MCP Server (Stripe connector): Connects to Stripe API (create charges, refund, list transactions)
• Skill (Payment processing): Knows how to handle payment scenarios (retry logic, error recovery, customer communication)

The MCP server gives the agent access to Stripe. The skill gives the agent expertise in using Stripe properly. Without MCP: Agent can’t reach Stripe. Without Skill: Agent can reach Stripe but doesn’t know payment best practices. With both: Agent handles payments like an experienced professional.

Adoption Timeline:

Date	Milestone
October 16, 2025	Anthropic launches Agent Skills for Claude Code
December 18, 2025	Anthropic releases Agent Skills as open standard at agentskills.io
December 2025	OpenAI adopts the same SKILL.md format for Codex CLI and ChatGPT

Agent support (December 2025): Claude Code, ChatGPT, Codex CLI, VS Code, GitHub Copilot, Cursor, goose, and more. Partner skills: Canva (design automation), Stripe (payment processing), Notion, Figma, Atlassian, Cloudflare, Ramp, Sentry, Zapier.

---

5. MCP Apps Extension — Agent Interfaces

The Problem It Solves: Your Digital SDR can qualify leads, update CRM, and schedule meetings. But users interact with it through… chat? Chat is powerful, but it has limits: Data visualizations become text descriptions. Forms become one-question-at-a-time conversations. Complex tables become formatting puzzles. Your competitor’s SDR shows buttons, charts, and real-time pipeline views. Yours describes them in paragraphs.

What MCP Apps Extension Enables: On November 21, 2025, the MCP community announced the MCP Apps Extension (SEP-1865)—allowing MCP servers to deliver interactive user interfaces directly to host applications. Buttons, forms, charts, dashboards—not just chat.

The Evolution:

flowchart LR
    A["Text Only<br/>Chat"] --> B["Structured Output<br/>Markdown/Code"]
    B --> C["Interactive Components<br/>Buttons, Forms, Viz"]
    
    style C fill:#f3e5f5,stroke:#7b1fa2

Architecture: Uses ui:// URI scheme for pre-declared UI templates with sandboxed iframe security:

graph TD
    subgraph HostGroup ["MCP Host Application"]
        Model["AI Model"]
        UI["Sandboxed UI<br/>(iframe)"]
        
        Model <-->|"JSON-RPC"| UI
    end
    
    subgraph ServerGroup ["MCP Server"]
        Server["Tools, UI Templates"]
    end
    
    UI <==>|"MCP Protocol<br/>postMessage"| Server
    
    style UI fill:#fff3e0,stroke:#e65100,stroke-dasharray: 5 5

The Collaboration: MCP Apps Extension builds on proven implementations: MCP-UI (open source, demonstrated UI-as-MCP-resources pattern, adopted by Postman, Shopify, Hugging Face) and OpenAI Apps SDK (validated demand for rich UI in ChatGPT, 800M+ users). Anthropic, OpenAI, and MCP-UI creators collaborated to standardize these patterns.

OpenAI Apps SDK: Distribution Today While MCP Apps Extension standardizes the protocol, OpenAI’s Apps SDK provides immediate distribution to 800+ million ChatGPT users.

Aspect	Details
What It Is	MCP tools + Custom UI + ChatGPT integration
Who Gets Access	Business, Enterprise, Edu tiers
What Platform Handles	Billing, discovery, user acquisition

Marketplace Monetization: Remember the four revenue models from Chapter 1? Apps SDK unlocks the Marketplace path: 800M+ ChatGPT users, low customer acquisition cost, platform billing, volume play (many small customers vs few large contracts).

Build Now vs Build Later:

Standard	Status	Recommendation
Apps SDK	Production-ready	Use today for ChatGPT distribution
MCP Apps Extension	Proposed (SEP-1865)	Watch for cross-platform future

The strategy: Build on Apps SDK for distribution today. Follow MCP Apps Extension for portability tomorrow. The foundation (MCP) is stable. The interface layer is standardizing.

---

Who’s Behind AAIF

The platinum membership reads like a who’s-who of technology infrastructure:

Company	What They Bring
Amazon Web Services	Cloud infrastructure
Anthropic	Claude AI, MCP
Block	goose, Square
Bloomberg	Financial data
Cloudflare	Edge computing
Google	Gemini AI
Microsoft	Azure, GitHub
OpenAI	ChatGPT, AGENTS.md

Gold members include Salesforce, Shopify, Snowflake, IBM, Oracle, JetBrains, Docker, and 20+ others.

This isn’t a startup’s wishful thinking. These are infrastructure decisions by companies that move slowly and carefully. When they agree on a foundation, you’re watching genuine standardization.

---

What This Means for Your Agent Factory

Remember the $650 million CoCounsel acquisition from the preface? Thomson Reuters didn’t pay for technology locked to one platform. They paid for encoded legal expertise that could scale across their entire operation.

Your AI agents need the same portability. AAIF makes it possible:

Your Asset	AAIF Standard	Monetization Impact
Tool integrations	MCP	Connect once, sell to any client
Domain expertise	Agent Skills	License to clients on any platform
Client adaptability	AGENTS.md	Deploy without per-client customization
Architecture confidence	goose	Production patterns from enterprise scale
Interface reach	MCP Apps + Apps SDK	Distribute to 800M+ ChatGPT users, cross-platform tomorrow

This is infrastructure that scales revenue.

When you sell a Digital SDR subscription for $1,500/month, AAIF standards ensure:

• It connects to any CRM (not just Salesforce) via MCP
• It works with any AI platform (not just Claude) via portable standards
• It adapts to any client’s workflow (not just yours) via AGENTS.md
• It shows rich interfaces (not just chat) via MCP Apps
• You can distribute widely (800M+ ChatGPT users) via Apps SDK

That’s the difference between a demo you can show and a product you can sell.

---

The Investment Case

Learning these standards isn’t optional if you’re serious about the Agent Factory vision:

Without AAIF knowledge:

• You build agents that work only with your preferred platform
• Each new client means potential rebuilding
• Your expertise is trapped, not portable
• Switching AI providers means starting over

With AAIF knowledge:

• Your integrations work across all major platforms
• Client diversity becomes a strength, not a burden
• Your expertise compounds across every agent you build
• Provider switches are configuration changes, not rewrites

The skills you develop in this lesson—understanding MCP, AGENTS.md, goose, Skills, and how they fit together—pay dividends across every AI agent you create.

---

Try With AI

Use your AI companion (Claude, ChatGPT, Gemini, or similar) to deepen your understanding:

Prompt 1: Standards Mapping Exercise

“I’m building a Digital [your role] that needs to work across multiple AI platforms and client environments. For each capability I need, tell me:

1. Which AAIF standard applies? (MCP / AGENTS.md / Skills / goose patterns / MCP Apps)
2. Why that standard?
3. What would happen if I tried to build it WITHOUT that standard?

My capabilities:

• Connect to [tool 1, e.g., Salesforce CRM]
• Connect to [tool 2, e.g., Gmail for email]
• Know the best practices for [domain expertise]
• Adapt to each client’s coding conventions
• Show [specific UI, e.g., pipeline dashboard with charts]
• Handle payment processing via Stripe”

What you’re learning: Architectural decision-making. The ability to map requirements to the right standard prevents over-engineering and under-delivering. You’re learning to think like a systems architect.

Prompt 2: AGENTS.md Design

“I’m setting up a project for [your domain] with these characteristics:

• [Tech stack 1, e.g., TypeScript with strict mode]
• [Testing framework, e.g., Jest not Mocha]
• [Build system, e.g., pnpm workspaces]
• [Specific conventions, e.g., conventional commits, no console.log]

Help me create an AGENTS.md that covers:

1. Build and test commands (the exact commands)
2. Code style guidelines (specific rules, not vague principles)
3. Security considerations (what to never do)
4. Architecture patterns (where code goes)

Make it specific enough that an AI agent could follow it precisely without asking clarifying questions.”

What you’re learning: Specification writing. Good AGENTS.md files are precise and actionable—skills that transfer to writing specs for AI agents. You’re learning to encode knowledge that scales.

Prompt 3: Skills + MCP Integration Design

“I have expertise in [your domain]. I want to build a Skill that an agent can load, but it needs to connect to external tools.

Help me think through:

1. What goes in the SKILL.md? (The expertise: when to use, how to execute, output format)
2. What MCP servers would the skill need? (The connectivity: what tools to call)
3. How do they work together? (The integration: skill orchestrates MCP tools)

Example: For a “payment processing” skill:

• SKILL.md: Knows retry logic, error recovery, when to refund
• MCP: Stripe connector (create charges, list transactions, refund)
• Together: Skill decides WHAT to do, MCP provides HOW to do it

Apply this pattern to my domain.”

What you’re learning: System integration. Understanding the distinction between expertise (Skills) and connectivity (MCP) is the key to architecting capable AI agents. You’re learning to design systems where separate components combine to create intelligence.

Core Concept

The Agentic AI Foundation (AAIF), a Linux Foundation initiative announced December 9, 2025, provides neutral governance for five open standards (MCP, AGENTS.md, goose, Agent Skills, MCP Apps Extension) that make Digital FTEs portable across AI platforms rather than locked to a single vendor. These standards solve the M*N integration problem and enable “write once, deploy everywhere” agent architecture.

Key Mental Models

• USB Implementers Forum Analogy: Just as USB standardized device connections so any device works with any port, AAIF standardizes agent connections so AI agents work across any AI platform. AAIF is the governance body; the standards create actual portability.
• MCP’s Three Primitives: Resources (read-only data — eyes), Tools (actions that change state — hands), and Prompts (reusable templates — playbooks). Getting the classification wrong breaks your agent.
• Skills vs MCP Complementarity: MCP provides connectivity (the agent’s hands — how to reach tools). Skills provide expertise (the agent’s training — what to do with tools). Without MCP, agents can’t reach systems. Without Skills, agents don’t know best practices.
• Progressive Disclosure for Token Efficiency: Skills load in three levels: Level 1 at startup (~100 tokens: name and description), Level 2 when activated (<5K tokens: full instructions), Level 3 when needed (supporting resources). This achieves 80-98% token reduction.
• AGENTS.md as Agent-Readable Context: README.md tells humans what a project is; AGENTS.md tells AI agents how to behave (build commands, code style, security constraints, architecture patterns). The nearest AGENTS.md file takes precedence (hierarchy rule).

Key Facts

• AAIF announced: December 9, 2025, under Linux Foundation governance
• Founding members: OpenAI, Anthropic, Block (donated core technologies); AWS, Google, Microsoft, Bloomberg, Cloudflare as platinum members
• MCP timeline: Open-sourced November 2024 by Anthropic; OpenAI adopted March 2025; Google April 2025; MCP spec 2025-11-25 with OAuth 2.1; donated to AAIF December 2025
• AGENTS.md adoption: 60,000+ open-source projects since OpenAI introduced it August 2025; adopted by Claude Code, Cursor, GitHub Copilot, Gemini CLI, Devin, goose
• Agent Skills timeline: Launched by Anthropic October 16, 2025; released as open standard December 18, 2025 at agentskills.io; OpenAI adopted same SKILL.md format
• goose stats: 75% of Block engineers save 8-10+ hours weekly using it; Apache 2.0 licensed
• MCP Apps Extension (SEP-1865): Announced November 21, 2025 for interactive UI via MCP servers
• OpenAI Apps SDK: Distribution to 800M+ ChatGPT users

Critical Patterns

• The five standards map to AI Agent capabilities: MCP (tool connectivity), AGENTS.md (client adaptability), Skills (domain expertise), goose (architecture patterns), MCP Apps (interface reach)
• MCP Host -> Client -> Server architecture uses JSON-RPC protocol for communication between AI applications and tool integrations
• goose serves dual purpose: Path A General Agent for productivity today, AND open-source blueprint for studying Path B Custom Agent patterns
• Build strategy: Use Apps SDK for ChatGPT distribution today; watch MCP Apps Extension for cross-platform portability tomorrow

Common Mistakes

• Confusing AAIF (the governance body) with the standards themselves (AAIF governs the standards; the standards create the portability)
• Misclassifying MCP primitives — exposing “send email” as a Resource instead of a Tool means the agent can see the option but cannot execute it
• Thinking goose and Claude Code compete when they validate the same standards from different angles (Claude Code for productivity; goose for learning Custom Agent architecture)
• Ignoring AGENTS.md hierarchy — not understanding that the nearest file takes precedence enables monorepo support where different subprojects have different conventions