Protocolos do Ecossistema de Agentes e IA

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

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

Mapa de Camadas

Tool Calling

MCP — Model Context Protocol

• *rigem:*Anthropic (nov2024); doado ao Agentic AI Foundation da Linux Foundation (dez2025)
• *apel:*Protocolo padrão para LLMs acessarem ferramentas externas (e fontes de contexto, prompts, recursos)
• *ire:*JSON-RPC 2.0; transportes stdio, HTTP/SSE, Streamable HTTP
• *ervidores disponíveis:*filesystem, git, GitHub, databases, browsers, Slack, Notion, Linear, etc. (centenas)
• *doção:*Claude (nativo), OpenAI (set/2025), Gemini, Cursor, Windsurf, VSCode Copilot, Zed, Sourcegraph
• *pec:*modelcontextprotocol.io
• *ara 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

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

Anthropic Tool Use

• *rigem:*Anthropic (mai/2024)
• *apel:*Tool calling nativo via blocks tool_use / tool_result no Messages API
• *iferencial:*Suporta cache_control para tool definitions (prompt caching)
• *elação com MCP:*MCP é a camada de *ransporte*entre cliente e servers; Tool Use é a camada *ire*entre Claude e o cliente

Gemini Function Calling

• *rigem:*Google (dez/2023)
• *ormato:*OpenAPI schema (mais expressivo que JSON Schema puro)
• *iferencial:*Suporta function calling modes (AUTO, ANY, NONE) e parallel function calling

AgenttoAgent

A2A — Agent2Agent Protocol

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

ACP — Agent Communication Protocol

• *rigem:*IBM + BeeAI sob Linux Foundation (mar/2025)
• *apel:*Comunicação entre agentes, RESTfirst, serverside state
• *ire:*HTTP REST com longpolling/SSE; foco em *treaming multimodal multi-turn*
• *iferença para A2A:*state lives no servidor (stateful sessions) vs A2A stateless por padrão
• *doção:*IBM watsonx; ecossistema menor que A2A
• *pec:*agentcommunicationprotocol.dev

AGNTCY — Internet of Agents

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

NLIP — Natural Language Interaction Protocol

• *rigem:*ECMA International TC56 (mai/2025)
• *apel:*Padroniza *gente ↔ humano*(não agente ↔ agente)
• *ire:*envelope JSON com partes textoáudiovisual + control flow
• *doção:*early; complementar a A2A
• *pec:*nlip-project.org

Inferência (Model Serving)

OpenAI-Compatible API

• *tatus:*padrão *e facto*da indústria
• *ndpoints canônicos:*/v1/chat/completions, /v1/completions, /v1/embeddings, /v1/responses
• *mplementadores:*OpenAI, vLLM, Ollama, llama.cpp, SGLang, Mistral, Together, Groq, DeepSeek, Anthropic (via SDK adapter), Gemini (via SDK adapter), LiteLLM (proxy universal)
• *ara o Kode:*alvo do *oder AI Gateway*(KMCP001.2 inprogress); qualquer cliente Koder fala uma única API e o gateway roteia

Bedrock Converse API

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

Hugging Face TGI / Inference Endpoints

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

Computer Use

Anthropic Computer Use

• *rigem:*Anthropic (out/2024)
• *apel:*Claude controla mousetecladoscreen via tool computer
• *ire:*Tool Use com tools computer_20241022, text_editor_20241022, bash_20241022
• *andbox:*responsabilidade do cliente (Docker/VM recomendado)
• *doção:*Claude Desktop (Anthropic), Goose (Block), Bytebot

OpenAI Computer Use / Operator

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

browser-use / Playwright MCP

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

Pagamentos Delegados

AP2 — Agent Payments Protocol

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

x402 — HTTP 402 Payment Required

• *rigem:*Coinbase (mai/2025)
• *apel:*Micropagamento em stablecoin (USDC) sobre HTTP — servidor retorna 402, cliente paga, servidor entrega
• *ire:*header X-Payment com proof of payment on-chain (Base L2)
• *iferencial vs AP2:*AP2 = mandato delegado (multistep); x402 = paywall transacional (singleshot)
• *ara o Kode:*padrão pra precificar APIs do Koder Hub por chamada se cripto-pricing virar opção
• *pec:*x402.org

Observabilidade (cross-link)

Cobertura detalhada em observabilidade.md. Resumo dos contratos:

OpenTelemetry GenAI Semantic Conventions

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

OpenInference (Arize)

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

OpenLLMetry (Traceloop)

• *oco:*convenções OTel + SDKs auto-instrumentation pra OpenAIAnthropicetc.
• *iferença:*OpenInference é "schemafirst", OpenLLMetry é "instrumentationfirst"

Identity e Discovery

Agent Cards (A2A)

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

OASF — Open Agentic Schema Framework

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

OAuth 2.1 + DPoP para agentes

• *tatus:*RFC 9449 (DPoP) finalizado; aplicação a agentes ainda emergente
• *apel:*Agent demonstra posse de chave a cada request (vs bearer token compartilhável)
• *elevâ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

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

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