Protocolos do Ecossistema de Agentes e IA

Contratos de interoperabilidade entre agentes, modelos, ferramentas e infraestrutura. Distinto de frameworks (SDKs/orquestradores) — protocolos são as "USB-C" desse ecossistema.

Cobertura: tool calling · agent-to-agent · inferência (model serving) · pagamentos delegados · observabilidade · identidade. Para SDKs e orquestradores que consomem estes protocolos, ver agentes.md.

Mapa de Camadas

Tool Calling

MCP — Model Context Protocol

• Origem: Anthropic (nov2024); doado ao Agentic AI Foundation da Linux Foundation (dez2025)
• Papel: Protocolo padrão para LLMs acessarem ferramentas externas (e fontes de contexto, prompts, recursos)
• Wire: JSON-RPC 2.0; transportes stdio, HTTP/SSE, Streamable HTTP
• Servidores disponíveis: filesystem, git, GitHub, databases, browsers, Slack, Notion, Linear, etc. (centenas)
• Adoção: Claude (nativo), OpenAI (set/2025), Gemini, Cursor, Windsurf, VSCode Copilot, Zed, Sourcegraph
• Spec: modelcontextprotocol.io
• Para o Kode: padrão de tool calling; Kruze já consome MCP no AiChatBridge (KMCP-001 phase 2). Servers MCP custom da Koder Stack: candidatos óbvios em engines/sdk/

OpenAI Function Calling / Tool Use

• Origem: OpenAI (jun2023); evoluiu pra Responses API (mar2025)
• Papel: Tool calling inline no payload de chat completion
• Formato: JSON Schema para definir ferramentas; resposta em bloco tool_calls
• Adoção: OpenAI nativo + todos os provedores OpenAI-compatible (vLLM, Ollama, Mistral, Together, Groq, DeepSeek)
• Diferença do MCP: in-band (mesmo wire da inferência) vs out-of-band (server separado)
• Para o Kode: continua dominante em integrações single-provider; Kruze suporta os dois modos via flag ai.openai_native_contract

Anthropic Tool Use

• Origem: Anthropic (mai/2024)
• Papel: Tool calling nativo via blocks tool_use / tool_result no Messages API
• Diferencial: Suporta cache_control para tool definitions (prompt caching)
• Relação com MCP: MCP é a camada de transporte entre cliente e servers; Tool Use é a camada wire entre Claude e o cliente

Gemini Function Calling

• Origem: Google (dez/2023)
• Formato: OpenAPI schema (mais expressivo que JSON Schema puro)
• Diferencial: Suporta function calling modes (AUTO, ANY, NONE) e parallel function calling

Microsoft IQ / Web IQ — grounding MCP-native

• Origem: Microsoft, Build 2026 (02062026)
• Papel: Microsoft IQ é a camada de inteligência/grounding que conecta agentes ao contexto organizacional, exposta de forma MCP-native (entre outros wires). Quatro componentes:
  • Work IQ — semântica de e-mailsreuniõesdocs/chats dentro do trust boundary do M365; APIs públicas em A2A + MCP + REST (GA no Build).
  • Foundry IQ (GA) — knowledge bases que unificam Work IQ, Fabric IQ, File Search e Azure SQL atrás de um endpoint de retrieval com SLA; ship com Foundry IQ MCP server para qualquer host MCP-compatível.
  • Fabric IQ Ontology (preview) — semântica compartilhada (pessoasdadosworkflows).
  • Web IQ (novo) — stack de busca web AI-first, model-agnostic e MCP-native: descobre, ranqueia, extrai e empacota passagens frescas (webnewsimagens/vídeo). Microsoft afirma retorno de passagens relevantes a ~2,5× a velocidade da segunda melhor opção.
• Relação com MCP: consome MCP como camada de transporte — é um caso de retrieval/grounding exposto como MCP server, não um protocolo novo. Reforça o MCP como ponto único de integração agente↔conhecimento.
• Para o Kode: valida o padrão "grounding como MCP server" — o caminho natural para a Stack expor o Koder AI Gateway + RAG de codebase (ver agentes.md "Stack Recomendado") como um MCP server unificado que qualquer cliente Koder (Kruze, Kode) consome, em vez de N integrações ad-hoc. A separação WorkFabricFoundry/Web espelha as fontes que a Koder precisaria fundir (docs internos, dados estruturados, web).
• Fontes: What's new in Microsoft Foundry — Build 2026 · Foundry IQ — serverless retrieval

Agent-to-Agent

A2A — Agent2Agent Protocol

• Origem: Google (abr2025); doado à Linux Foundation (jun2025); v1.0 (early 2026)
• Papel: Protocolo padrão para comunicação entre agentes (não agente ↔ tool)
• Wire: JSON-RPC 2.0 sobre HTTP + SSE ou gRPC
• Auth: API keys, OAuth 2.0, OIDC, mutual TLS
• Agent Card: JSON em /.well-known/agent.json com capacidades, endpoints, auth — discovery e negociação automáticos
• Adoção: 150+ organizações (Microsoft, AWS, Salesforce, SAP, ServiceNow, Atlassian)
• Spec: a2a-protocol.org · github.coma2aprojectA2A
• Relação com MCP: complementares — MCP conecta agente → tool; A2A conecta agente → agente

ACP — Agent Communication Protocol

• Origem: IBM + BeeAI sob Linux Foundation (mar/2025)
• Papel: Comunicação entre agentes, REST-first, server-side state
• Wire: HTTP REST com long-polling/SSE; foco em streaming multi-modal multi-turn
• Diferença para A2A: state lives no servidor (stateful sessions) vs A2A stateless por padrão
• Adoção: IBM watsonx; ecossistema menor que A2A
• Spec: agentcommunicationprotocol.dev

AGNTCY — Internet of Agents

• Origem: Cisco + Outshift (abr/2025); apoiado por LangChain, Galileo, Glean
• Papel: Stack completo — directory + identity + messaging + observability
• Componentes: OASF (schema), Agent Directory, Agent Gateway, Agent Identity
• Diferença para A2A/ACP: mais ambicioso (stack inteiro), menos adotado
• Spec: agntcy.org

NLIP — Natural Language Interaction Protocol

• Origem: ECMA International TC56 (mai/2025)
• Papel: Padroniza agente ↔ humano (não agente ↔ agente)
• Wire: envelope JSON com partes textoáudiovisual + control flow
• Adoção: early; complementar a A2A
• Spec: nlip-project.org

Inferência (Model Serving)

OpenAI-Compatible API

• Status: padrão de facto da indústria
• Endpoints canônicos: /v1/chat/completions, /v1/completions, /v1/embeddings, /v1/responses
• Implementadores: OpenAI, vLLM, Ollama, llama.cpp, SGLang, Mistral, Together, Groq, DeepSeek, Anthropic (via SDK adapter), Gemini (via SDK adapter), LiteLLM (proxy universal)
• Para o Kode: alvo do Koder AI Gateway (KMCP-001.2 in-progress); qualquer cliente Koder fala uma única API e o gateway roteia

Bedrock Converse API

• Origem: AWS (nov/2024)
• Papel: Unifica chamada de múltiplos modelos hospedados no Bedrock (Claude, Llama, Mistral, Titan)
• Wire: REST + streaming SSE; auth IAM/SigV4
• Tool use: padronizado entre modelos (vs APIs nativas que divergem)

Hugging Face TGI / Inference Endpoints

• Origem: Hugging Face (2023)
• Papel: Protocolo próprio (Messages API + Generation API); também expõe OpenAI-compat
• Diferencial: integração nativa com Hub (modelo por ID)

Computer Use

Anthropic Computer Use

• Origem: Anthropic (out/2024)
• Papel: Claude controla mousetecladoscreen via tool computer
• Wire: Tool Use com tools computer_20241022, text_editor_20241022, bash_20241022
• Sandbox: responsabilidade do cliente (Docker/VM recomendado)
• Adoção: Claude Desktop (Anthropic), Goose (Block), Bytebot

OpenAI Computer Use / Operator

• Origem: OpenAI (jan/2026, GA)
• Papel: modelo computer-use-preview opera GUI via Responses API
• Wire: tool computer_use_preview com action: click/type/scroll/...
• Diferencial: modelo dedicado (não GPT-5 puro); roda em ambiente cloud da OpenAI

browser-use / Playwright MCP

• Origem: browser-use (out2024); Playwright MCP server (fev2025)
• Papel: alternativa open-source pra browser automation via LLM
• Wire: MCP server expõe navigate, click, type, screenshot como tools
• Diferencial: decouple model de runtime — qualquer modelo MCP-capable opera

Pagamentos Delegados

AP2 — Agent Payments Protocol

• Origem: Google (set/2025); 60+ parceiros (Mastercard, American Express, PayPal, Coinbase, Salesforce)
• Papel: Pagamento iniciado por agente em nome do usuário, com prova criptográfica de autorização
• Mecanismo: Mandates — intent mandate (user → agent) + cart mandate (agent → merchant) + payment mandate (signed); todos assinados com chave do usuário
• Wire: extensão do A2A; transações fluem como Agent Card → mandate exchange
• Para o Kode: relevante quando agentes Koder forem comprar APIs/recursos em nome do user (futuro Koder Hub paid tier)
• Spec: ap2-protocol.org

x402 — HTTP 402 Payment Required

• Origem: Coinbase (mai/2025)
• Papel: Micropagamento em stablecoin (USDC) sobre HTTP — servidor retorna 402, cliente paga, servidor entrega
• Wire: header X-Payment com proof of payment on-chain (Base L2)
• Diferencial vs AP2: AP2 = mandato delegado (multi-step); x402 = paywall transacional (single-shot)
• Para o Kode: padrão pra precificar APIs do Koder Hub por chamada se cripto-pricing virar opção
• Spec: x402.org

Observabilidade (cross-link)

Cobertura detalhada em observabilidade.md. Resumo dos contratos:

OpenTelemetry GenAI Semantic Conventions

• Origem: OpenTelemetry SIG (estável out/2025)
• Atributos canônicos: gen_ai.system, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, gen_ai.response.finish_reasons
• Eventos: gen_ai.user.message, gen_ai.assistant.message, gen_ai.tool.message
• Adoção: virou base de todas as plataformas (Phoenix, LangFuse, Datadog, Honeycomb)

OpenInference (Arize)

• Foco: convenções OTel + spans específicos pra LLM (retrieval, embedding, agent steps)
• Diferença: mais granular que GenAI semconv padrão; LangFuse/Phoenix usam por baixo

OpenLLMetry (Traceloop)

• Foco: convenções OTel + SDKs auto-instrumentation pra OpenAIAnthropicetc.
• Diferença: OpenInference é "schema-first", OpenLLMetry é "instrumentation-first"

Identity e Discovery

Agent Cards (A2A)

• Localização: /.well-known/agent.json no host do agente
• Conteúdo: name, description, capabilities, auth schemes, endpoints, skill examples
• Padrão para discovery automática — outro agente lê o card antes de conectar

OASF — Open Agentic Schema Framework

• Origem: AGNTCY (Cisco)
• Papel: Schema canônico pra descrever agentes (capabilities, IO, lifecycle, requirements)
• Diferença para Agent Cards: OASF é mais completo (lifecycle, dependências), Cards são mais simples (capabilities + auth)

OAuth 2.1 + DPoP para agentes

• Status: RFC 9449 (DPoP) finalizado; aplicação a agentes ainda emergente
• Papel: Agent demonstra posse de chave a cada request (vs bearer token compartilhável)
• Relevância pro Koder ID: caminho natural se Koder ID emitir tokens delegáveis a agentes

Tabela de Decisão — Qual Protocolo Usar

Stack Recomendado para 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

Princípio de adoção: seguir policies/self-hosted-first.kmd — preferir protocolos abertos e self-hosted-friendly (MCP, A2A, OpenAI-compat) sobre proprietários (Bedrock Converse, OpenAI Operator).

Última atualização: 2026-05-22 (split inicial de agentes.md; cobertura: MCP, A2A, ACP, AGNTCY, NLIP, OpenAI-compat, Bedrock Converse, Computer Use, AP2, x402, OTel GenAI semconv, OASF)