Skip to content

Interoperability

Jump to bottom
TamTunnel edited this page Oct 29, 2025 · 1 revision

Interoperability

AWAS (AI Website Accessibility Standard) is designed with interoperability in mind, providing compatibility with major agent frameworks and protocols. This page outlines AWAS's integration with Model Context Protocol (MCP), Agent2Agent (A2A), and Google Agent Development Kit (ADK).

Overview

AWAS serves as a foundational layer for AI agent interoperability by:

  • Standardizing discovery mechanisms through .well-known endpoints
  • Providing unified schemas for agent capabilities and website accessibility
  • Enabling cross-protocol communication between different agent frameworks
  • Facilitating seamless integration for both agent developers and website implementers

Supported Protocols & Frameworks

Model Context Protocol (MCP)

MCP is an open protocol that enables secure connections between host applications and external data sources. AWAS integrates with MCP by:

  • Providing MCP-compatible manifest files at .well-known/mcp-manifest.json
  • Exposing website capabilities through MCP-standardized schemas
  • Supporting MCP's security model for agent authentication and authorization

Agent2Agent (A2A)

A2A facilitates direct communication between AI agents. AWAS supports A2A through:

  • Dedicated A2A manifest files at .well-known/a2a-manifest.json
  • Agent capability discovery and negotiation protocols
  • Standardized interaction patterns for multi-agent scenarios

Google Agent Development Kit (ADK)

Google's ADK provides tools and frameworks for building AI agents. AWAS compatibility includes:

  • ADK-compatible schema definitions
  • Integration with Google's agent discovery mechanisms
  • Support for ADK's action and capability models

Manifest Files

MCP Manifest (.well-known/mcp-manifest.json)

The MCP manifest provides Model Context Protocol-specific information:

{
  "version": "1.0",
  "protocol": "mcp",
  "capabilities": {
    "forms": {
      "supported": true,
      "schemas": [
        "https://schema.org/ContactForm",
        "https://schema.org/SearchAction"
      ]
    },
    "navigation": {
      "supported": true,
      "sitemap": "/sitemap.xml",
      "breadcrumbs": true
    },
    "content": {
      "structured_data": true,
      "semantic_markup": true,
      "accessibility_features": [
        "aria-labels",
        "landmark-roles",
        "keyboard-navigation"
      ]
    }
  },
  "endpoints": {
    "ai_manifest": "/.well-known/ai-manifest.json",
    "capabilities": "/api/agent-capabilities"
  },
  "security": {
    "authentication_required": false,
    "rate_limiting": {
      "requests_per_minute": 100
    }
  }
}

A2A Manifest (.well-known/a2a-manifest.json)

The A2A manifest focuses on agent-to-agent communication:

{
  "version": "1.0",
  "protocol": "a2a",
  "agent_capabilities": {
    "communication": {
      "supports_delegation": true,
      "message_formats": ["json", "xml"],
      "max_message_size": 1048576
    },
    "discovery": {
      "service_types": [
        "web-interaction",
        "form-processing",
        "content-extraction"
      ]
    }
  },
  "interaction_patterns": {
    "request_response": true,
    "publish_subscribe": false,
    "streaming": true
  },
  "integration": {
    "awas_manifest": "/.well-known/ai-manifest.json",
    "mcp_compatible": true,
    "adk_compatible": true
  }
}

Usage Examples

For Agent Developers

Discovering AWAS Capabilities

import requests
import json

def discover_site_capabilities(domain):
    """Discover AWAS capabilities for a given domain"""
    manifests = {}
    
    # Check for AWAS manifest
    try:
        awas_response = requests.get(f"https://{domain}/.well-known/ai-manifest.json")
        if awas_response.status_code == 200:
            manifests['awas'] = awas_response.json()
    except requests.RequestException:
        pass
    
    # Check for MCP manifest
    try:
        mcp_response = requests.get(f"https://{domain}/.well-known/mcp-manifest.json")
        if mcp_response.status_code == 200:
            manifests['mcp'] = mcp_response.json()
    except requests.RequestException:
        pass
    
    # Check for A2A manifest
    try:
        a2a_response = requests.get(f"https://{domain}/.well-known/a2a-manifest.json")
        if a2a_response.status_code == 200:
            manifests['a2a'] = a2a_response.json()
    except requests.RequestException:
        pass
    
    return manifests

# Example usage
capabilities = discover_site_capabilities("example.com")
if 'awas' in capabilities:
    print("Site supports AWAS")
    print(f"Available actions: {capabilities['awas'].get('actions', [])}")

MCP Integration

from mcp import Client

def connect_via_mcp(domain):
    """Connect to a website using MCP protocol"""
    # Discover MCP capabilities
    mcp_manifest = requests.get(f"https://{domain}/.well-known/mcp-manifest.json").json()
    
    # Initialize MCP client
    client = Client()
    
    # Connect using discovered endpoints
    capabilities_endpoint = mcp_manifest['endpoints']['capabilities']
    client.connect(f"https://{domain}{capabilities_endpoint}")
    
    # Query available tools
    tools = client.list_tools()
    return tools

A2A Agent Communication

def delegate_to_specialist_agent(task, target_domain):
    """Delegate a task to a specialist agent on another domain"""
    # Discover A2A capabilities
    a2a_manifest = requests.get(f"https://{target_domain}/.well-known/a2a-manifest.json").json()
    
    if a2a_manifest['agent_capabilities']['communication']['supports_delegation']:
        # Send delegation request
        delegation_request = {
            "task": task,
            "requester": "agent_id_123",
            "timestamp": "2024-01-01T00:00:00Z"
        }
        
        # Post to delegation endpoint
        response = requests.post(
            f"https://{target_domain}/api/agent-delegation",
            json=delegation_request
        )
        
        return response.json()

For Website Implementers

Basic Implementation

// Generate manifest files based on site capabilities
const generateAWASManifests = (siteConfig) => {
  const awasManifest = {
    version: "1.0",
    actions: siteConfig.supportedActions,
    capabilities: siteConfig.capabilities,
    schemas: siteConfig.schemas
  };
  
  const mcpManifest = {
    version: "1.0",
    protocol: "mcp",
    capabilities: {
      forms: {
        supported: siteConfig.capabilities.includes('forms'),
        schemas: siteConfig.formSchemas || []
      },
      navigation: {
        supported: true,
        sitemap: "/sitemap.xml"
      }
    },
    endpoints: {
      ai_manifest: "/.well-known/ai-manifest.json"
    }
  };
  
  const a2aManifest = {
    version: "1.0",
    protocol: "a2a",
    agent_capabilities: {
      communication: {
        supports_delegation: siteConfig.supportsDelegation || false
      }
    },
    integration: {
      awas_manifest: "/.well-known/ai-manifest.json",
      mcp_compatible: true
    }
  };
  
  return { awas: awasManifest, mcp: mcpManifest, a2a: a2aManifest };
};

Serving Manifests

# Nginx configuration for serving manifest files
location /.well-known/ai-manifest.json {
    add_header Access-Control-Allow-Origin *;
    add_header Content-Type application/json;
    try_files $uri =404;
}

location /.well-known/mcp-manifest.json {
    add_header Access-Control-Allow-Origin *;
    add_header Content-Type application/json;
    try_files $uri =404;
}

location /.well-known/a2a-manifest.json {
    add_header Access-Control-Allow-Origin *;
    add_header Content-Type application/json;
    try_files $uri =404;
}

Schema Extensions

AWAS supports extending base schemas for protocol-specific needs:

MCP Extensions

{
  "$schema": "https://awas-spec.org/schemas/mcp-extension.json",
  "extends": "https://awas-spec.org/schemas/base-manifest.json",
  "mcp_specific": {
    "context_providers": [
      {
        "name": "site-content",
        "description": "Provides site content context",
        "endpoint": "/api/mcp/context"
      }
    ]
  }
}

A2A Extensions

{
  "$schema": "https://awas-spec.org/schemas/a2a-extension.json",
  "extends": "https://awas-spec.org/schemas/base-manifest.json",
  "a2a_specific": {
    "delegation_endpoints": {
      "receive": "/api/a2a/delegate",
      "status": "/api/a2a/status",
      "results": "/api/a2a/results"
    }
  }
}

Next Steps

Planned Integrations

  1. Custom Protocol Support: Framework for adding new agent protocols
  2. Enhanced Schema Validation: Real-time validation of manifest files
  3. Dynamic Capability Discovery: Runtime capability negotiation
  4. Cross-Protocol Translation: Automatic translation between protocol formats

Development Roadmap

  • Q1 2024: Extended MCP integration with context providers
  • Q2 2024: A2A multi-agent orchestration features
  • Q3 2024: Google ADK deep integration
  • Q4 2024: Custom protocol extension framework

Contributing

We welcome contributions to improve interoperability:

  1. Protocol Implementations: Add support for new agent frameworks
  2. Schema Extensions: Propose extensions for specific use cases
  3. Integration Examples: Share real-world implementation patterns
  4. Testing Tools: Develop tools for validating interoperability

Related Resources

External Documentation

Repository Files

Clone this wiki locally