Skip to content

MCP, HTTP, Webhooks and A2A Explained Simply

MCP, HTTP with OpenAPI, webhooks and A2A connect systems at different levels. What matters is which responsibility lies at each boundary.

≈ 8 min readSoftwareAIArchitecture

Four connections can all run over HTTP technically and still serve four fundamentally different purposes. An agent application discovers a tool. A fixed program calls a documented endpoint. A service reports an event that has already happened. An independent agent takes on a task with its own lifetime.

MCP, HTTP with OpenAPI, webhooks and A2A describe these boundaries. None of them replaces the domain decision about who may read, write, approve or publish. A product can offer several of these machine interfaces and also have its own web UI for people. It still remains one domain with one authoritative product state and the same domain rules.

Four questions instead of a ranking#

An interface is an agreed boundary between systems. It defines inputs, results and errors. The transport, however, doesn’t yet answer which responsibility is handed over at this boundary.

Technique Guiding question Typical task
MCP Which capabilities can an agent application discover and use? Providing tools and context for an open-ended task
HTTP with OpenAPI Which known machine command can a client execute? Calling and checking a stable service contract
Webhook Which event that has occurred should another system learn about? Triggering a downstream process promptly
A2A Which bounded task can an independent agent take on? Delegating stateful work to another agent system

The four options are not ranked, and they don’t sit on the same technical layer. HTTP is a transport protocol, OpenAPI describes an interface, webhooks use HTTP to deliver events, and MCP and A2A each bring their own interaction contracts. An A2A agent can call MCP tools and ordinary HTTP APIs internally.

MCP provides capabilities for agent applications#

MCP stands for Model Context Protocol. With it, an agent application can, for example, discover a knowledge service’s search as a tool; the visibility of this tool is not yet a domain permission and no substitute for a fixed workflow.

A server can run locally as a process or remotely as a web service. The word “server” describes its role in the protocol, not its location.

{
  "mcpServers": {
    "knowledge": {
      "type": "http",
      "url": "https://knowledge.example.com/mcp"
    }
  }
}

After connecting, the agent application can check the input schema and call the tool. This doesn’t give the model a blanket permission. The host controls which capabilities are visible and which calls require consent. The server authenticates and authorizes the call. The responsible service additionally enforces its domain rules for the operation.

MCP fits open-ended tasks. An agent application can search a knowledge service for approved knowledge, read sources and, depending on the result, decide which next step makes sense. For repeated publications with an identical sequence of steps, this freedom is unnecessary. A stored, approved workflow is easier to check and repeat there.

HTTP and OpenAPI form an explicit machine contract#

HTTP governs request and response. OpenAPI describes the APIs built on top of it in a machine-readable way: paths, methods, inputs, responses and security schemes. People can read the description, programs can generate clients from it, and checks can compare the implementation with the contract.

The following call is a schematic example:

POST /v1/sites/demo/previews HTTP/1.1
Host: content.example.com
Authorization: Bearer <token>
Content-Type: application/json

{
  "revisionIds": ["rev-123", "rev-456"]
}

The call requests a preview. It says nothing about who reviewed the content from a domain point of view or whether this preview may be published. OpenAPI can make the technical contract precise. The approval rule belongs in the domain and in the controlled process.

In a publishing system, the HTTP and OpenAPI interface can serve fixed integrations, a remote MCP endpoint can offer selected capabilities to agent applications, and a web UI can carry the human work in the same publishing domain. All three access paths then work with the same revisions, previews, releases and permission boundaries; none of them introduces a second persistence path.

A webhook reports an event#

With a normal API call, the client actively asks. With a webhook, the event source sends an HTTP request to a previously registered address. That way, the receiver doesn’t have to keep checking whether something has changed.

POST /webhooks/knowledge HTTP/1.1
Host: orchestration.example.com
webhook-id: evt-789
webhook-timestamp: 1785585600
webhook-signature: v1,<signature>
Content-Type: application/json

{
  "type": "proposal.approved",
  "data": {
    "space": "product-docs",
    "concepts": ["integration-options"]
  }
}

The event type in the example is deliberately generic. In this flow, the webhook only carries the event and the reference to the authoritative state. The receiver checks signature and age, detects duplicate deliveries via the event ID and then reads the state from the responsible system with its own permissions.

Duplicate delivery is part of the normal failure pattern. The receiver has to work idempotently: the same event ID may only take effect once in domain terms. It responds quickly and moves longer work into a stored process. A knowledge service can deliver signed Standard Webhooks for this. A workflow engine can bind such an input – with signature checks and protection against replays – to exactly one versioned workflow, without taking over the knowledge or publishing rules of the systems involved.

A2A delegates to an independent agent system#

A2A stands for Agent2Agent. The protocol connects a calling agent with an independent remote agent system. The client knows its published capabilities, but not its internal plan, memory or tools. The remote agent remains responsible for how it handles the task within its boundaries.

An Agent Card describes identity, endpoint, capabilities and authentication requirements. A message carries a conversation step made of text, files or structured data. Longer-running work gets a task with its own ID and a lifecycle. Results are returned as artifacts. Follow-up questions and other necessary decisions appear as state transitions of the task.

That distinguishes delegation from a tool call. With MCP, an agent application calls a described capability. With A2A, one agent hands a goal to another system that can plan on its own, use tools and carry out several steps.

Web UIs and machine interfaces serve different purposes#

A web UI for people is not a fifth kind of integration. MCP, HTTP with OpenAPI, webhooks and A2A connect machines. The web UI and the machine interfaces work with the state of the same domain and don’t introduce a second persistence path.

Each web UI uses the terms and decisions of its own domain for this. In a knowledge service, a pending knowledge change is a change proposal; in a workflow engine, an execution belongs to a specific workflow version.

Two boundaries follow from this separation:

  • A web UI doesn’t become a second domain system with diverging rules.
  • A machine protocol doesn’t become an unintended way around the human decision.

No protocol grants permissions by itself#

Authentication answers: who is making the request? Authorization answers: what may this identity do? A valid key shouldn’t lump reading, writing and publishing together across the board.

An agent searching for knowledge only needs read permissions. A step that builds a preview needs the write permissions required for that. A publication may require its own permission and a visibly bound human approval. If an operation is offered via several interfaces, the same domain approval boundaries must apply to it.

Reliability doesn’t come from the name of the protocol either. An HTTP call can break off after successful processing, before the response reaches the client. A webhook can arrive more than once. An A2A task can wait a long time for a decision. Every writing step therefore needs a stable identifier, a clear retry rule and a stored state.

For integrations that write or require approval, three contracts have to fit together:

  • The technical contract describes inputs, results and errors.
  • The domain contract defines which system owns knowledge, approval and publication.
  • The operational contract governs time limits, retries, logging and how outages are handled.

A flow with all four boundaries#

flowchart LR
    U["Human<br/>states a goal"] --> A["Agent application<br/>works on an open task"]
    A -->|"MCP<br/>search and read"| K["Knowledge service<br/>reviewed knowledge"]
    A -->|"MCP or HTTP / OpenAPI<br/>revision and preview"| C["Publishing system<br/>publishing domain"]
    K -->|"signed webhook<br/>approval event"| S["Workflow engine<br/>versioned workflow"]
    S -->|"HTTP / OpenAPI<br/>defined steps"| C
    A -.->|"A2A<br/>delegate a bounded task"| R["Agent system<br/>independent task"]
    H["Human in the respective web UI"] -.-> K
    H -.-> S
    H -.-> C
    H -.-> R

The first run can be supervised. An agent application reads from the knowledge service, generates Markdown and builds a preview in the publishing system. A person sees the results and can still change the order.

As soon as the sequence repeats reliably, it belongs in a workflow engine as a versioned workflow. The workflow reads a specific approved knowledge revision, creates a content revision and builds a preview. It doesn’t publish automatically just because a webhook started it. The publishing system keeps the approval and release boundary.

A2A comes in when an independent agent system actually takes on a bounded task with its own lifetime. Calling something an “agent” doesn’t turn a simple API call into delegation.

The decision comes before the protocol#

The table only helps once three questions are answered: which system owns the state? Which identity may change it? Which effect requires a human decision? From these follow the rules for retries and the view in which a person can check the current state.

First you decide who owns state and approval. Then comes the protocol.

Further reading#

Revised and translated from German with the help of AI.