← The ARM  ·  Hound →  ·  Jennifer →  ·  Every Industry →  ·  DMC-12.ai →
Live in Production  ·  Mark Miller Subaru  ·  Salt Lake City, Utah

Jarvis ARM
The First ARM.

What It Is

The world's first working 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. The founding rubric is being validated in production commerce at Mark Miller Subaru.

Read The Rubric Back to The Standard
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.

Rubric Status

Ten criteria.
The protocols that build them.

The founding rubric defines what a native ARM must do. Jarvis runs against every criterion on an open protocol stack. Each one below shows the protocols that power it. Eight of ten are live. Two are in active development.

Criterion 01
Detect
Live

Jarvis classifies agent traffic at entry by protocol. MCP, A2A, and UCP sessions are separated from human sessions before routing begins. Every interaction is tagged at ingestion.

Protocols: MCP A2A UCP
Criterion 02
Deploy
Live

The dealer's own transacting agent is in production. When a buyer's agent enters, the ARM deploys the dealer's agent to meet it autonomously within set parameters. A2A is the channel the two agents negotiate over, machine to machine. That traffic is live in the audit log.

Protocols: A2A
Criterion 03
Enforce
Live

Pricing floors, doc fees, and tax disclosure are encoded in the schema and managed per rooftop. The ARM holds them through every quote. The get_pricing_disclosure and request_quote tools consume the saved fees on every call. No concessions outside the dealer's boundaries without human authorization. UCP carries the envelope that enforces the terms.

Protocols: UCP A2A
Criterion 04
Route
Live

Agent and human leads travel separate paths from the moment they enter. The classifier applies distinct logic to each. Human leads route to the CRM. Agent leads route to the ARM. Same dealership, same inventory, two systems.

Protocols: MCP A2A UCP
Criterion 05
Report
Live

Agent activity reports as its own line, separate from human analytics. Requests, error rate, active agents, latency, throughput, tool mix, and audit log are live in the dashboard. AG-UI streams agent activity to the operator and carries inputs back in real time. A2UI structures the interface components the agent returns. Together they turn machine-speed activity into a readable operator dashboard.

Protocols: AG-UI A2UI
Criterion 06
Adapt
Building

The dealer's agent refines its logic on what worked across past negotiations. When a buyer's agent repeats a pattern, it recognizes and adjusts. The audit trail being built now is the foundation. AG-UI carries the event stream that will feed the pattern engine as it comes online.

Protocols: A2A AG-UI
Criterion 07
Verify
Live

Agent identity is verified cryptographically via Auth0 M2M before any tool access. Named agents are checked against trusted registries. Advocacy agents, scrapers, and malicious probes each get a distinct response. No identity, no transaction.

Protocols: A2A MCP
Criterion 08
Operate
Live

Jarvis runs a separate agentic lane alongside the dealership stack, not through it. Agent-to-agent transactions execute end to end at machine speed, drawing on the dealership's tools when needed. AG-UI and A2UI surface the live activity for any human who wants to watch or act. Discovery and delivery stay human, 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 interaction is recorded with a cryptographic trace. Identity, protocol, tool, status, latency, trace ID. Persistent, non-repudiable, queryable. Every signed UCP and A2A envelope is a permanent record. When a buyer's agent returns, the system knows it.

Protocols: UCP A2A AG-UI
Criterion 10
Forecast
Building

Forward projection of agent volume and margin impact from 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, giving leadership a live view of 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. Five pillars define it as a distinct infrastructure layer for agent 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. Reputation is computed per agent and used to grant or restrict access, the way credit scores gate lending. The interaction log 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 at once, and each turn makes the next 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. Good agents earn wider access. Bad ones get narrower schemas and harder limits. The system sorts 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, new versions ship. Partners adopt them to unlock capabilities. The rulebook becomes the industry rulebook. Switching cost 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 now.

01
Identity Infrastructure Is Standard

Machine-to-machine identity is now commodity. OAuth client credentials, JWKS, signed agent cards. The primitives are boring, which means they are ready to build 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. Real commerce, real scale, real 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 building an ARM can 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.

Evaluate Against The Rubric Read The Founding Document
ARM
Agent Relationship
Management