ACP + MCP: Structured Transactions for AI Agents

How lifecycle-aware transaction state and structured model context enable reliable AI-to-commerce interoperability.

Modern AI agents require structured, deterministic context to operate reliably in commerce workflows. Two protocols address complementary layers of this requirement:

In automotive retail, AI agents increasingly assist with lead handling, appointment scheduling, trade-in capture, and lifecycle progression. ACP ensures that those agent outputs persist as structured transaction state across dealership systems.

Together, they enable a pipeline where AI agent reasoning is grounded in structured transaction data, and agent outputs flow into deterministic business state.

What MCP Does

The Model Context Protocol (MCP) standardizes how AI models receive and exchange structured context and tool outputs. It focuses on model-to-tool interoperability in agent-based systems.

MCP defines:

1. Tool definitions — Structured schemas that describe what tools an agent can call, with typed inputs and outputs.
2. Context injection — Mechanisms for providing agents with structured data before and during reasoning.
3. Output schemas — Typed results that tools return to the model, enabling deterministic downstream processing.

MCP operates at the agent reasoning layer — it governs what the model sees and what the model can do. It is agnostic to the business domain.

What ACP Does

The Automotive Commerce Protocol (ACP) standardizes lifecycle-aware transaction state exchange between business systems. It defines versioned snapshot and delta envelopes for deterministic state progression in automotive commerce.

ACP defines:

1. Envelope structure — Eight top-level objects (acp, source, dealership, lead, transaction, conversation, events, ai_analysis) that capture the full transaction lifecycle.
2. Snapshot & delta semantics — Immutable snapshots represent complete state; deltas represent incremental updates referencing a parent.
3. Schema validation — JSON Schema enforcement ensures structural compliance across all producers and receivers.

ACP operates at the business state layer — it governs what the transaction looks like at any point in time. It is agnostic to the AI implementation.

How They Complement Each Other

MCP and ACP address different layers of the same pipeline. Neither replaces the other.

The key interoperability points:

• ACP envelopes as MCP context — An ACP snapshot can serve as structured context input to an MCP-compatible agent, giving the model complete transaction awareness.
• MCP tool outputs as ACP deltas — When an MCP agent calls a tool that modifies transaction state, the output can be packaged as an ACP delta envelope.
• Bidirectional state flow — The agent reads state (ACP → MCP) and writes state (MCP → ACP) through structured, validated interfaces at every step.

Architecture

Example Flow

A concrete sequence showing ACP and MCP interoperating in a vehicle purchase conversation:

Implementation: MCP Tool Definition

An MCP tool that produces ACP-compatible output might be defined as:

{
  "name": "extract_transaction_state",
  "description": "Extract structured transaction fields from conversation",
  "input_schema": {
    "type": "object",
    "properties": {
      "message": { "type": "string" },
      "current_state": { "$ref": "acp-envelope-v1.0.0.json" }
    }
  },
  "output_schema": {
    "type": "object",
    "properties": {
      "intents": { "type": "array", "items": { "$ref": "#/definitions/intent" } },
      "vehicle_interests": { "type": "array" },
      "budget_update": { "$ref": "#/definitions/budget" },
      "score_delta": { "type": "number" }
    }
  }
}

The tool's output_schema maps directly to ACP envelope fields. This alignment is intentional — ACP's typed field definitions serve as the canonical vocabulary for tool outputs in automotive commerce.

Delta Output Example

The MCP tool output above produces an ACP delta:

{
  "acp": {
    "version": "1.0.0",
    "protocol": "acp",
    "envelope_id": "acp_1707900000_d4f8",
    "parent_envelope_id": "acp_1707899000_a1b2",
    "generated_at": "2025-02-14T10:00:00Z"
  },
  "events": [
    {
      "event_type": "INTENT_DETECTED",
      "timestamp": "2025-02-14T10:00:00Z",
      "data": {
        "intent": "FINANCING",
        "confidence": 0.91,
        "source": "mcp_tool:extract_transaction_state"
      }
    },
    {
      "event_type": "BUDGET_UPDATED",
      "timestamp": "2025-02-14T10:00:00Z",
      "data": {
        "down_payment": 5000,
        "source": "mcp_tool:extract_transaction_state"
      }
    }
  ]
}

Note the source field in each event references the MCP tool that produced it. This creates a full audit trail from agent reasoning to business state.

Snapshot as Agent Context

An ACP snapshot provides complete transaction context to an MCP agent. The agent receives:

This structured input replaces unstructured prompt engineering. The agent doesn't need to parse conversation history to understand the deal — the state is pre-computed, validated, and typed.

Independence Notice

ACP envelopes are valid and complete without any MCP involvement. Any AI system — MCP-compatible or otherwise — can produce and consume ACP envelopes. The interoperability described here is a natural consequence of both protocols using structured, typed, schema-validated data exchange.

Design Principles

The ACP + MCP interoperability pattern follows these architectural principles:

Use Cases

Scenarios where ACP + MCP interoperability provides architectural value: