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.
Claude → Salesforce: Custom integration code
ChatGPT → Salesforce: Different custom code
Gemini → Salesforce: Yet another custom code
Claude → HubSpot: Another custom integration
ChatGPT → 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 from Chapter 1. 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
┌──────────────────────────────────────┐
│ 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:
## 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:
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 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:
-
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 | 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.
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:
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:
┌─────────────────────────────────────────────┐
│ 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 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 |
| 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
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 Digital FTEs. 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 Digital FTEs. You're learning to design systems where separate components combine to create intelligence.