RedLectern topic
Interfaces and standards connecting applications · models · tools · data · agents.
For: Developers · technical learners.
After this page you can: Identify which interface or standard an integration needs.
Page reviewed
Part of: Artificial Intelligence
AI integration standards are agreements about how software discovers capabilities, sends requests, carries data, and applies access controls across an integration boundary. Start by asking what is connecting to what: an application calling a service, an AI application using tools or application context, an editor working with a coding agent, or one agent service handing a task to another. These boundaries call for different interfaces, even when each is casually described as an agent protocol. A useful choice starts with the peer roles, message shape, transport, discovery, and access checks the integration needs.
Begin with the interface and access vocabulary, then compare Model Context Protocol, using specification revision 2026-07-28, which covers application-facing tools and context, with agent interoperability, which covers agent-to-agent, editor-agent, and portable skill interfaces. As you assess an integration, write down its caller and callee, whether it needs replies, streams, or task updates, how capabilities are discovered, and who grants access. Then check which revision, bindings, and optional features both endpoints support.
Read the MCP overview, then use the practice questions to distinguish application-to-tool integrations from agent-to-agent and editor-agent integrations.
Start with: Model Context Protocol overview
An API is the software contract a component exposes to other software. JSON-RPC defines a lightweight, transport-agnostic way to make remote procedure calls using JSON. OAuth is for delegated access to protected resources; it does not, by itself, describe the operations an application offers. Authentication establishes or verifies an asserted identity, while authorization determines whether that identity may access a resource or perform an action. For a concrete integration, first identify the operations and data being exposed, then decide how requests are represented and how the caller’s identity and permissions are checked. These are related interface decisions, but they answer different questions.
Use it to inspect the request and response conventions in a method-call protocol.
Use it to understand delegated access and the roles in an authorization flow.
Use the authentication and authorization distinction when reviewing an integration boundary.
API
A defined software interface through which one component can interact with another component’s capabilities.
JSON-RPC
A lightweight, transport-agnostic remote procedure call protocol that uses JSON as its data format.
OAuth
A framework that lets a third-party application obtain limited access to an HTTP service, with a resource owner’s approval or on its own behalf.
Authentication
Verifying credentials and the identity they assert.
Deciding whether an authenticated party has permission to access a particular resource or service.
For a service integration, write one sentence each explaining what an API contract, JSON-RPC, and OAuth answer.
The API defines the software interface; JSON-RPC defines a JSON-based method-call protocol; OAuth supports delegated, limited access to a protected HTTP service.
Use Model Context Protocol (MCP) when an AI application needs a shared contract for tools, resources, or prompts. In MCP specification revision 2026-07-28, tools let servers expose operations that models can invoke, resources let servers share context with clients, and the overview identifies prompts as a server feature. The revision’s lifecycle is stateless: requests carry their metadata, and state that must span requests is referenced by an explicit identifier. Its standard transports are stdio and Streamable HTTP; choose based on how the peers communicate, then verify the actual client and server support the selected transport and features. MCP authorization is optional; for HTTP transports, the specification defines an authorization flow, while STDIO implementations retrieve credentials from the environment.
Compare the standard transport bindings and what each binding carries.
Check how authorization requirements differ between HTTP-based and STDIO transports.
For an MCP integration targeting revision 2026-07-28, choose a transport for a client-launched local subprocess and for a remote HTTP endpoint.
Use stdio for the client-launched subprocess and Streamable HTTP for the remote HTTP endpoint.
Choose Agent2Agent (A2A) version 1.0.0 when independent agent systems need to communicate and discover one another; its Agent Card describes the server’s identity, capabilities, skills, and interaction requirements. Choose Agent Client Protocol (ACP) v1 when connecting a code editor client with a coding agent: its overview describes JSON-RPC methods and notifications, session setup, prompt turns, and permission requests. Agent Skills provides a portable directory format built around a required SKILL.md file, with optional scripts, references, and assets. These interfaces address different peers and exchange patterns. Check the current protocol version, advertised capabilities, authentication requirements, and supported operations for both endpoints before designing the handoff.
Review the editor-client and coding-agent communication model.
Review the portable skill directory format and its required and optional files.
Choose a protocol for each case: an editor communicating with its coding agent, and one independent remote agent handing a task to another.
Use ACP v1 for the editor-to-coding-agent interface and A2A for communication between independent agent systems.
No recent updates are available.
JJ Geewax · 2021
A practical catalog of API patterns for resource design, standard methods, compatibility, authentication, and validation. Manning offers a free ebook by request.
Leonard Richardson and Mike Amundsen (foreword by Sam Ruby) · 2013
A focused guide to REST, HTTP, and hypermedia that helps readers understand the design choices behind REST-style interfaces. Its 2013 edition covers architectural concepts; consult current standards for protocol details.