Agent and AI Ecosystem Protocols

Interoperability contracts between agents, models, tools, and infrastructure. Distinct from frameworks (SDKs/orchestrators) — protocols are the "USB-C" of this ecosystem.

Coverage: tool calling · agent-to-agent · inference (model serving) · delegated payments · observability · identity. For SDKs and orchestrators that consume these protocols, see agents.md.

Layer Map

Tool Calling

MCP — Model Context Protocol

• Origin: Anthropic (Nov2024); donated to the Linux Foundation's Agentic AI Foundation (Dec2025)
• Role: Standard protocol for LLMs to access external tools (and context sources, prompts, resources)
• Wire: JSON-RPC 2.0; stdio, HTTP/SSE, Streamable HTTP transports
• Available servers: filesystem, git, GitHub, databases, browsers, Slack, Notion, Linear, etc. (hundreds)
• Adoption: Claude (native), OpenAI (Sep/2025), Gemini, Cursor, Windsurf, VSCode Copilot, Zed, Sourcegraph
• Spec: modelcontextprotocol.io
• For Kode: the tool-calling standard; Kruze already consumes MCP in AiChatBridge (KMCP-001 phase 2). Custom MCP servers for the Koder Stack: obvious candidates in engines/sdk/

OpenAI Function Calling / Tool Use

• Origin: OpenAI (Jun2023); evolved into the Responses API (Mar2025)
• Role: Inline tool calling in the chat completion payload
• Format: JSON Schema to define tools; response in a tool_calls block
• Adoption: OpenAI native + all OpenAI-compatible providers (vLLM, Ollama, Mistral, Together, Groq, DeepSeek)
• Difference from MCP: in-band (same wire as inference) vs out-of-band (separate server)
• For Kode: remains dominant in single-provider integrations; Kruze supports both modes via the ai.openai_native_contract flag

Anthropic Tool Use

• Origin: Anthropic (May/2024)
• Role: Native tool calling via tool_use / tool_result blocks in the Messages API
• Differentiator: Supports cache_control for tool definitions (prompt caching)
• Relationship with MCP: MCP is the transport layer between client and servers; Tool Use is the wire layer between Claude and the client

Gemini Function Calling

• Origin: Google (Dec/2023)
• Format: OpenAPI schema (more expressive than pure JSON Schema)
• Differentiator: Supports function calling modes (AUTO, ANY, NONE) and parallel function calling

Microsoft IQ / Web IQ — MCP-native grounding

• Origin: Microsoft, Build 2026 (06022026)
• Role: Microsoft IQ is the intelligence/grounding layer that connects agents to organizational context, exposed in an MCP-native way (among other wires). Four components:
  • Work IQ — semantics of emailsmeetingsdocs/chats within the M365 trust boundary; public APIs in A2A + MCP + REST (GA at Build).
  • Foundry IQ (GA) — knowledge bases that unify Work IQ, Fabric IQ, File Search, and Azure SQL behind a single retrieval endpoint with an SLA; ships with the Foundry IQ MCP server for any MCP-compatible host.
  • Fabric IQ Ontology (preview) — shared semantics (peopledataworkflows).
  • Web IQ (new) — an AI-first, model-agnostic, MCP-native web search stack: discovers, ranks, extracts, and packages fresh passages (webnewsimages/video). Microsoft claims it returns relevant passages at ~2.5× the speed of the second-best option.
• Relationship with MCP: consumes MCP as the transport layer — it is a case of retrieval/grounding exposed as an MCP server, not a new protocol. It reinforces MCP as the single agent↔knowledge integration point.
• For Kode: validates the "grounding as MCP server" pattern — the natural path for the Stack to expose the Koder AI Gateway + codebase RAG (see agents.md "Recommended Stack") as a single unified MCP server that any Koder client (Kruze, Kode) consumes, instead of N ad-hoc integrations. The WorkFabricFoundry/Web split mirrors the sources Koder would need to fuse (internal docs, structured data, web).
• Sources: What's new in Microsoft Foundry — Build 2026 · Foundry IQ — serverless retrieval

Agent-to-Agent

A2A — Agent2Agent Protocol

• Origin: Google (Apr2025); donated to the Linux Foundation (Jun2025); v1.0 (early 2026)
• Role: Standard protocol for communication between agents (not agent ↔ tool)
• Wire: JSON-RPC 2.0 over HTTP + SSE or gRPC
• Auth: API keys, OAuth 2.0, OIDC, mutual TLS
• Agent Card: JSON at /.well-known/agent.json with capabilities, endpoints, auth — automatic discovery and negotiation
• Adoption: 150+ organizations (Microsoft, AWS, Salesforce, SAP, ServiceNow, Atlassian)
• Spec: a2a-protocol.org · github.coma2aprojectA2A
• Relationship with MCP: complementary — MCP connects agent → tool; A2A connects agent → agent

ACP — Agent Communication Protocol

• Origin: IBM + BeeAI under the Linux Foundation (Mar/2025)
• Role: Communication between agents, REST-first, server-side state
• Wire: HTTP REST with long-polling/SSE; focus on multi-modal multi-turn streaming
• Difference from A2A: state lives on the server (stateful sessions) vs A2A stateless by default
• Adoption: IBM watsonx; smaller ecosystem than A2A
• Spec: agentcommunicationprotocol.dev

AGNTCY — Internet of Agents

• Origin: Cisco + Outshift (Apr/2025); backed by LangChain, Galileo, Glean
• Role: Complete stack — directory + identity + messaging + observability
• Components: OASF (schema), Agent Directory, Agent Gateway, Agent Identity
• Difference from A2A/ACP: more ambitious (entire stack), less adopted
• Spec: agntcy.org

NLIP — Natural Language Interaction Protocol

• Origin: ECMA International TC56 (May/2025)
• Role: Standardizes agent ↔ human (not agent ↔ agent)
• Wire: JSON envelope with textaudiovisual parts + control flow
• Adoption: early; complementary to A2A
• Spec: nlip-project.org

Inference (Model Serving)

OpenAI-Compatible API

• Status: the industry de facto standard
• Canonical endpoints: /v1/chat/completions, /v1/completions, /v1/embeddings, /v1/responses
• Implementers: OpenAI, vLLM, Ollama, llama.cpp, SGLang, Mistral, Together, Groq, DeepSeek, Anthropic (via SDK adapter), Gemini (via SDK adapter), LiteLLM (universal proxy)
• For Kode: the target of the Koder AI Gateway (KMCP-001.2 in-progress); any Koder client speaks a single API and the gateway routes

Bedrock Converse API

• Origin: AWS (Nov/2024)
• Role: Unifies calling multiple models hosted on Bedrock (Claude, Llama, Mistral, Titan)
• Wire: REST + streaming SSE; IAM/SigV4 auth
• Tool use: standardized across models (vs native APIs that diverge)

Hugging Face TGI / Inference Endpoints

• Origin: Hugging Face (2023)
• Role: Own protocol (Messages API + Generation API); also exposes OpenAI-compat
• Differentiator: native integration with the Hub (model by ID)

Computer Use

Anthropic Computer Use

• Origin: Anthropic (Oct/2024)
• Role: Claude controls mousekeyboardscreen via the computer tool
• Wire: Tool Use with the computer_20241022, text_editor_20241022, bash_20241022 tools
• Sandbox: the client's responsibility (Docker/VM recommended)
• Adoption: Claude Desktop (Anthropic), Goose (Block), Bytebot

OpenAI Computer Use / Operator

• Origin: OpenAI (Jan/2026, GA)
• Role: the computer-use-preview model operates a GUI via the Responses API
• Wire: the computer_use_preview tool with action: click/type/scroll/...
• Differentiator: dedicated model (not pure GPT-5); runs in OpenAI's cloud environment

browser-use / Playwright MCP

• Origin: browser-use (Oct2024); Playwright MCP server (Feb2025)
• Role: open-source alternative for browser automation via LLM
• Wire: MCP server exposes navigate, click, type, screenshot as tools
• Differentiator: decouples model from runtime — any MCP-capable model operates

Delegated Payments

AP2 — Agent Payments Protocol

• Origin: Google (Sep/2025); 60+ partners (Mastercard, American Express, PayPal, Coinbase, Salesforce)
• Role: Payment initiated by an agent on behalf of the user, with cryptographic proof of authorization
• Mechanism: Mandates — intent mandate (user → agent) + cart mandate (agent → merchant) + payment mandate (signed); all signed with the user's key
• Wire: an extension of A2A; transactions flow as Agent Card → mandate exchange
• For Kode: relevant when Koder agents buy APIs/resources on behalf of the user (future Koder Hub paid tier)
• Spec: ap2-protocol.org

x402 — HTTP 402 Payment Required

• Origin: Coinbase (May/2025)
• Role: Micropayment in stablecoin (USDC) over HTTP — the server returns 402, the client pays, the server delivers
• Wire: X-Payment header with on-chain proof of payment (Base L2)
• Differentiator vs AP2: AP2 = delegated mandate (multi-step); x402 = transactional paywall (single-shot)
• For Kode: a standard for pricing Koder Hub APIs per call if crypto-pricing becomes an option
• Spec: x402.org

Observability (cross-link)

Detailed coverage in observability.md. Summary of the contracts:

OpenTelemetry GenAI Semantic Conventions

• Origin: OpenTelemetry SIG (stable Oct/2025)
• Canonical attributes: gen_ai.system, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, gen_ai.response.finish_reasons
• Events: gen_ai.user.message, gen_ai.assistant.message, gen_ai.tool.message
• Adoption: became the base of all platforms (Phoenix, LangFuse, Datadog, Honeycomb)

OpenInference (Arize)

• Focus: OTel conventions + spans specific to LLMs (retrieval, embedding, agent steps)
• Difference: more granular than the standard GenAI semconv; LangFuse/Phoenix use it underneath

OpenLLMetry (Traceloop)

• Focus: OTel conventions + auto-instrumentation SDKs for OpenAIAnthropicetc.
• Difference: OpenInference is "schema-first", OpenLLMetry is "instrumentation-first"

Identity and Discovery

Agent Cards (A2A)

• Location: /.well-known/agent.json on the agent's host
• Content: name, description, capabilities, auth schemes, endpoints, skill examples
• Standard for automatic discovery — another agent reads the card before connecting

OASF — Open Agentic Schema Framework

• Origin: AGNTCY (Cisco)
• Role: Canonical schema to describe agents (capabilities, IO, lifecycle, requirements)
• Difference from Agent Cards: OASF is more complete (lifecycle, dependencies), Cards are simpler (capabilities + auth)

OAuth 2.1 + DPoP for agents

• Status: RFC 9449 (DPoP) finalized; application to agents still emerging
• Role: The agent demonstrates possession of a key on each request (vs a shareable bearer token)
• Relevance to Koder ID: the natural path if Koder ID issues tokens delegable to agents

Decision Table — Which Protocol to Use

Recommended Stack for Kode

Tool calling:        MCP (default) + OpenAI Function Calling (single-provider)
Inferência:          OpenAI-compatible API via Koder AI Gateway (KMCP-001.2)
Agent-to-agent:      A2A quando federar; bus interno pra co-located
Computer use:        Computer Use API + sandbox VM (Incus/Docker)
Observabilidade:     OTel GenAI semconv → LangFuse self-hosted
Identity:            Koder ID (OAuth 2.1) + DPoP quando agentes externos chegarem

Adoption principle: follow policies/self-hosted-first.kmd — prefer open and self-hosted-friendly protocols (MCP, A2A, OpenAI-compat) over proprietary ones (Bedrock Converse, OpenAI Operator).

Last updated: 2026-05-22 (initial split from agents.md; coverage: MCP, A2A, ACP, AGNTCY, NLIP, OpenAI-compat, Bedrock Converse, Computer Use, AP2, x402, OTel GenAI semconv, OASF)