AIFF Standards - The Foundation

You've built a Digital Sales Development Representative (SDR) 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 Digital FTEs 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 Digital FTEs 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 Digital SDR needs CRM access. Your Digital Accountant needs database connections. Your Digital Legal Assistant needs document repositories. Before MCP, you'd write custom integration code for each combination of agent and tool.

System Specification

Claude → Salesforce:  Custom integration codeChatGPT → Salesforce: Different custom codeGemini → Salesforce:  Yet another custom codeClaude → HubSpot:     Another custom integrationChatGPT → HubSpot:    Another different custom code

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. Without MCP, your Digital FTE 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 Digital 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 Digital FTE. 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

System Specification

┌──────────────────────────────────────┐
│             HOST                      ││  (Claude Desktop, ChatGPT, your app)  ││   ┌─────────────────────────────┐    ││   │          CLIENT             │    ││   │  (Manages MCP connections)   │    ││   └─────────────┬───────────────┘    │
└─────────────────┼────────────────────┘                  │ MCP Protocol (JSON-RPC)┌─────────────────▼────────────────────┐
│             SERVER                    ││  (Your CRM connector, database, API)  ││   Resources │ Tools │ Prompts         │
└──────────────────────────────────────┘

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 Digital FTE 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:

System Specification

## 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:

System Specification

company/├── AGENTS.md                    ← Root: company-wide rules├── packages/│   ├── frontend/│   │   ├── AGENTS.md            ← Frontend-specific rules (React, hooks)│   │   └── src/components/Button.tsx│   └── backend/│       ├── AGENTS.md            ← Backend-specific rules (Express, Prisma)│       └── src/routes/users.ts

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 Agent Maturity Model: General Agents like Claude Code and goose serve as Incubator-stage tools where you explore and prototype. Custom Agents (built with SDKs) emerge in the Specialist stage when requirements crystallize for production. goose is an Incubator-stage agent, but it's open source, making it your blueprint for understanding how to build Specialists.

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:

Local-First Execution: Your code and data stay local. For enterprise clients with sensitive IP, this isn't optional—it's required.
MCP-Native Design: Adding capabilities means connecting MCP servers. No custom integration code. Every capability follows the same pattern.
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

AGENTS.md Support

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:

System Specification

---name: financial-analysisdescription: 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 Execute1. Gather the relevant financial documents2. Extract key metrics (revenue, margins, growth rates)3. Compare against industry benchmarks4. 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.

System Specification

Level 1: Agent Startup (~100 tokens per skill)├── Name: "financial-analysis"└── Description: "Analyze financial statements..."Level 2: When Skill Activated (< 5K tokens)└── Full SKILL.md content (when-to-use, execution steps, output format)Level 3: When Actually Needed└── Supporting resources (templates, examples, scripts)

80-98% token reduction. This means your Digital FTE 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:

System Specification

Text Only → Structured Output → Interactive Components  
  ↓
            
  ↓
                  
  ↓
  Chat         Markdown/Code      Buttons, Forms,              Formatting          Visualizations

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

System Specification

┌─────────────────────────────────────────────┐
│           MCP Host Application              ││  ┌─────────────────┐  ┌──────────────────┐  ││  │    AI Model     │◄─►│  Sandboxed UI   │  ││  │                 │   │   (iframe)       │  ││  └────────┬────────┘  └────────┬─────────┘  │
└───────────┼────────────────────┼────────────┘            │   JSON-RPC over    │            │   postMessage      │            ▼                    ▼      ┌──────────────────────────────┐      │         MCP Server           │      │  ┌────────┐  ┌────────────┐  │      │  │ Tools  │  │ UI Templates│  │      │  └────────┘  └────────────┘  │      └──────────────────────────────┘

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? 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 Digital FTEs 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 Digital FTE you create.

Try With AI

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

Prompt 1: Standards Mapping Exercise

System Specification

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

System Specification

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 Digital FTEs. You're learning to encode knowledge that scales.

Prompt 3: Skills + MCP Integration Design

System Specification

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 itApply 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 Digital FTEs. 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 Digital FTEs 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 Digital FTE 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

Connections

Builds on: The Five Powers (Lesson 3) especially the "Act" power that MCP enables; the Two Paths Framework (Lesson 1) that goose bridges between General and Custom Agents
Leads to: Digital FTE Business Strategy (Lesson 5) where AAIF standards ensure products are portable and sellable; the practical skills-building work in later chapters where students create MCP servers, AGENTS.md files, and Agent Skills