Live in Production  ·  Mark Miller Subaru  ·  Salt Lake City, Utah

Jarvis ARM
The First ARM.

What It Is

The world's first working implementation of an Agent Relationship Manager. Live. In production. At a real dealership. Handling real agent traffic across three protocols right now.

Why It Matters

The ARM was a category definition. Now it is a running system. Every claim in the founding rubric is being validated in production commerce at Mark Miller Subaru.

Jarvis ARM  ·  Built by Ben Reuling
Mark Miller Subaru  ·  thearm.ai
First deployment: April 2026
LIVE
System Status
3
Protocols Active
334ms
P95 Latency
6 / 10
Rubric Criteria Live
Protocol Stack: MCP — Model Context Protocol A2A — Agent to Agent UCP — Universal Commerce Protocol AP2 — Authorize Payments AG-UI — Agent-User Interaction Protocol A2UI — Declarative Generative UI Specification
The Proof

This is what
an ARM looks like.

Jarvis ARM Dashboard showing live agent traffic, protocol distribution, tool mix, and audit log

Jarvis ARM Dashboard  ·  Live at Mark Miller Subaru  ·  Agent traffic, protocol distribution, tool mix, and cryptographic audit log

MCP
Model Context Protocol

The primary protocol for agent-to-tool communication. Agents using MCP connect directly to dealership inventory, pricing, and availability data. The dominant traffic source in the current deployment.

A2A
Agent to Agent

An open protocol for agent-to-agent communication, now governed by the Linux Foundation. A2A enables independent AI agents to discover each other, exchange information, and coordinate on tasks. In the ARM context it is the channel through which the dealer's agent and the buyer's agent communicate directly at machine speed.

UCP
Universal Commerce Protocol

An open commerce protocol developed by Google with Shopify, Walmart, Target, and over 20 global partners. UCP enables AI agents to discover, negotiate, and transact with any business through a standardized interface. Each interaction produces a signed, cryptographically provable record. Built for agent commerce at any scale.

Ten criteria.
The protocols that build them.

The founding rubric at thearm.ai defines what a native ARM must do. Jarvis runs in production against every criterion using an open protocol stack. Each criterion below shows which protocols power it and how they work together. Eight of ten criteria are live. Two are in active development.

Criterion 01
Detect
Live

Jarvis identifies agent-originated traffic at the point of entry by protocol type. MCP, A2A, and UCP sessions are classified and separated from human sessions before routing begins. Every agent interaction is tagged at ingestion so the system always knows what it is handling.

Protocols: MCP A2A UCP
Criterion 02
Deploy
Live

The dealer's own transacting agent is in production. When a buyer's agent enters the pipeline, the ARM deploys the dealer's pre-configured agent to meet it autonomously within set parameters. The A2A protocol is the channel through which the dealer's agent and the buyer's agent negotiate directly, machine to machine. Agent-to-agent traffic is live in the audit log.

Protocols: A2A
Criterion 03
Enforce
Live

Pricing floors, doc fees, registration fees, and tax disclosure are encoded into the protocol schema and managed per rooftop by the dealership. The ARM holds these parameters through every quote request. The get_pricing_disclosure tool and the request_quote out-the-door estimate consume the saved fees on every call. No concessions outside the dealer's defined boundaries without human authorization. UCP carries the commercial transaction envelope that enforces the terms.

Protocols: UCP A2A
Criterion 04
Route
Live

Agent leads and human leads travel separate paths from the moment they enter the pipeline. The protocol classifier in Jarvis applies distinct logic to each traffic type. Human leads route to the CRM. Agent leads route to the ARM pipeline. Same dealership. Same inventory. Two parallel systems.

Protocols: MCP A2A UCP
Criterion 05
Report
Live

Independent reporting on all agent activity runs as a separate line from human analytics. Requests, error rate, active agents, latency, throughput by protocol, tool mix, and audit log are all live in the Jarvis dashboard. AG-UI is the bi-directional protocol that connects the agent backend to the human-facing interface in real time, streaming agent activity to the operator and carrying operator inputs back to the agent. A2UI is Google's declarative UI specification that defines the structure of the interface components the agent returns. Together they solve the human-in-the-loop problem: machine-speed agent activity becomes a readable, actionable operator dashboard.

Protocols: AG-UI A2UI
Criterion 06
Adapt
Building

The knowledge base update loop allows the dealer's agent to refine its response logic based on what worked and what did not across previous negotiations. When a buyer's agent applies a pattern the dealer's agent has seen before, it recognizes it and adjusts. The audit trail being built now is the foundation for this layer. AG-UI carries the negotiation event stream that will feed the pattern recognition engine as it comes online.

Protocols: A2A AG-UI
Criterion 07
Verify
Live

Agent identity is verified cryptographically via Auth0 M2M authentication before any tool access is granted. Named agents are checked against trusted registries. Legitimate consumer advocacy agents, scraper bots, and malicious probing agents each receive a distinct response protocol. No identity, no transaction.

Protocols: A2A MCP
Criterion 08
Operate
Live

Jarvis ARM operates a separate agentic lane that runs alongside the dealership stack, not through it. Agent-to-agent transactions execute end to end at machine speed without a human in the loop. The protocol handles discovery, quote, reservation, and deal structure autonomously, drawing on tools in the dealership stack when needed. AG-UI and A2UI surface the live activity in the operator's existing environment, so any human who wants to watch or act has full visibility. Discovery and delivery stay with humans because that is where the emotion lives. The friction in the middle is removed by design.

Protocols: A2UI AG-UI MCP
Criterion 09
Remember
Live

Every agent interaction is recorded in the audit log with a cryptographic trace. Agent identity, protocol, tool called, status, latency, and trace ID. Persistent. Non-repudiable. Queryable. Every signed UCP and A2A envelope creates a permanent record. The ARM never starts from zero. When a buyer's agent returns, the system knows it.

Protocols: UCP A2A AG-UI
Criterion 10
Forecast
Building

Forward projection of agent traffic volume and gross margin impact based on accumulated interaction data. The audit trail and throughput data being built now are the foundation. As the projection layer comes online, AG-UI will carry forecast data to the frontend in real time using A2UI-structured components, giving leadership a live view of what the agent pipeline will produce next quarter.

Protocols: AG-UI A2UI
The Architecture

Five pillars.
One system of record.

The ARM is not a feature of the CRM. It is a separate primitive. These are the five pillars that define it as a distinct infrastructure layer for agent-mediated commerce.

01
Agent Registry

Every agent that transacts with the business has an identity, a set of capabilities it is authorized to use, and a public key that can be verified. No identity. No transaction. Jarvis currently verifies agents via Auth0 M2M with named agent tracking in the audit log.

02
Trust and Reputation

Every interaction produces signal. Success rate, latency, adherence to terms, follow-through on commitments. Reputation is computed per agent and used to grant or restrict access. The same way credit scores gate lending. The interaction log in Jarvis is building this dataset in real time.

03
Interaction Logging

Every call, every negotiation round, every signed commitment is recorded with a cryptographic trace. Non-repudiable. Auditable. Queryable. The audit log in Jarvis is this pillar operating in production today.

04
Protocol Management

The rules of engagement are explicit, versioned, and machine-readable. Partners do not integrate through phone calls and PDFs. They read a schema and plug in. Jarvis currently supports MCP, A2A, and UCP as distinct protocol channels with independent handling logic.

05
Human Escalation

The conditions under which a transaction must route to a person are written into the protocol itself. Not buried in application code. The schema is the policy. Escalation rules are being encoded into the ARM protocol layer alongside the dealer agent build.

The Moat

What compounds
over time.

A CRM gets more valuable as you add contacts. An ARM gets more valuable as agents transact against it. Four things compound simultaneously and each turn makes the next turn faster, cheaper, and safer.

Schema_Compound
Schemas

Every schema shipped teaches every future agent how to work with the business. Write once. Onboard forever. The schema library becomes the industry reference.

Reputation_Compound
Reputation

Every interaction sharpens the score. Agents that behave well earn wider access. Agents that misbehave get narrower schemas and harder limits. The system gets better at sorting signal from noise on its own.

Audit_Compound
Audit Trails

Every signed message is a permanent record. Over time the ARM becomes the highest-quality dataset in the business for how commerce actually happens. No other system has this.

Protocol_Compound
Protocol Versions

As the ARM learns what works, new versions ship. Partners adopt the new version to unlock new capabilities. The rulebook becomes the industry rulebook. The cost of switching rises every quarter.

The loop is the moat. Each turn makes the next turn faster, cheaper, and safer.

The Window

Three conditions.
All true right now.

Three conditions had to be true before the ARM was buildable. All three became true in the last twelve months. The window to define the category is open.

01
Identity Infrastructure Is Standard

Authentication infrastructure for machine-to-machine identity is now commodity. OAuth client credentials, JWKS, signed agent cards. The primitives are boring. Which means they are ready to be built on. Jarvis uses Auth0 M2M today.

02
Protocol Specifications Are Mature

MCP, A2A, and UCP have reached sufficient maturity that businesses can publish a manifest and be discovered by any major agent runtime. Discovery is solved. Jarvis is live on all three protocols.

03
The Counterparty Exists

The agent side of the market has crossed from research to revenue. Agents are executing real commerce at real scale with real commercial stakes. The buyer's agent is already in the pipeline. Jarvis is already seeing it.

Jarvis ARM is the proof of concept. The reference implementation. The timestamp. Anyone who wants to build an ARM can evaluate against the ten-point rubric and measure their progress against what is already running in production.

The Standard Is Written. The First ARM Is Live.

The CRM was the infrastructure of the human lead era. Jarvis ARM is the first infrastructure of the agent era.

ARM
Agent Relationship
Management