When Email Stops Being the Message: Toward State-Centric Communication Between AI Agents

Source asciidoc: `docs/article/when-email-stops-being-the-message.adoc`

Oleksandr Tishchenko, Founder and Architect, Marketing America Corp

Introduction

We are used to treating an email as the object of communication.

One person formulates an idea, chooses words, adds a greeting, softens a request, repeats context, expresses gratitude, and sends the resulting text to another person.

Generative AI is beginning to break one of the hidden assumptions behind that model: that the text written by the sender must be the same text read by the recipient.

Increasingly, a recipient does not read a long thread directly. Instead, the recipient asks an AI system:

Read this thread. What do they actually want? What changed? What remains unresolved? Is there a risk? What should I do next?

At that moment, the email itself is no longer the primary object of work.

The primary object becomes the state of the communication.

That distinction points toward a larger architectural transition.

The future of business messaging may not be AI writing better email. It may be a world in which AI agents no longer need to exchange human prose as the canonical representation of a message at all.

From AI-Mediated Communication to Agent-Native Communication

This subject does not begin with large language models.

In 2020, Jeffrey Hancock of Stanford University, Mor Naaman of Cornell University, and Karen Levy of Cornell University formally described Artificial Intelligence-Mediated Communication (AI-MC) as interpersonal communication in which an intelligent agent operates on behalf of a communicator by modifying, augmenting, or generating messages in pursuit of communication goals.

Most current AI communication products still preserve the old architecture:

Human -> AI-assisted text -> Human

AI may improve wording, summarize a thread, translate a message, or adjust tone, but human-readable prose remains the canonical object being created, transmitted, stored, and interpreted.

That may be only a transitional stage.

A more radical architecture looks like this:

Human -> Agent -> Semantic State -> Agent -> Human

The text becomes one possible rendering of the state rather than the state itself.

What Is Actually Inside a Business Email?

Much of professional communication can be decomposed into a relatively small set of semantic entities:

  • who wants what;

  • what happened;

  • which claims each party is making;

  • which facts are accepted or disputed;

  • which evidence is attached;

  • which questions remain unanswered;

  • which commitments have already been made;

  • which deadlines exist;

  • how urgent an action is;

  • what decision is requested;

  • what the current relationship between the parties looks like.

There is also a social layer: respect, gratitude, dissatisfaction, caution, willingness to compromise, warning of escalation, confidence, and uncertainty.

Today, all of this is encoded into natural language.

We may write:

Thank you again for your continued assistance. We completely understand that your team may require additional time. However, since this matter has remained unresolved for several weeks, we would appreciate a definitive status update by Friday.

For an AI agent, the same communication could be represented more directly as:

intent: status_request
relationship_stance: cooperative
escalation_level: warning
issue_status: unresolved
deadline: Friday
requested_action: definitive_response
previous_delay: several_weeks
tone: respectful_but_firm

The human sentence is one serialization of that state. It is not necessarily the only serialization.

Politeness May Become Structured

The disappearance of repetitive courtesies would not mean the disappearance of their social function.

Phrases such as "thank you" or "we appreciate your help" help regulate relationships, soften face-threatening acts, signal cooperation, and control escalation.

An agent-native layer would still need to represent those intentions:

relationship_stance: friendly
gratitude: present
face_threat: low
escalation_intention: none

The recipient’s agent could then decide how much of that information deserves to be rendered.

One user might see, "They are following up politely and are not escalating." Another might see only, "No status change. No action required."

The social meaning remains even if the original phrasing does not.

The Sender May Write a Message the Recipient Never Reads

Consider a sender who writes 1,500 words.

The sender’s agent extracts three factual claims, two requests, one deadline, four evidence references, a confidence level, and a preferred level of diplomacy.

The recipient’s agent receives that state, compares it with prior history, and displays:

The vendor acknowledges the delay, requests five additional business days, provides no new evidence, and still has not answered your second question. Recommended response: agree only if the new date is confirmed in writing.

The recipient understands what matters, but has not read the sender’s text.

More importantly, the text shown to the recipient may never have existed on the sender’s side.

That is a profound change in the nature of written communication.

From Document-Centric to State-Centric Communication

Email, messaging systems, and ticketing platforms are mostly document-centric.

They store sequences of messages and then ask a person, or increasingly an AI system, to reconstruct the current state from the history.

AI makes it possible to invert that model.

The primary object can become the current state:

issue: refund
amount: 378.54 USD
status: unresolved
counterparty_claim: resolved
observed_state: still_unresolved
outstanding_questions: 3
next_deadline: 2026-09-15
escalation_path: legal_claim
evidence: screenshot, transaction_history

Messages then become the event log that explains how the state changed, rather than the state itself.

This resembles the difference between reading every Git commit in order to understand a repository and inspecting the current repository state while preserving the commit history for provenance.

History still matters. But most operational decisions require the current state first.

Transmit the Delta, Not the Entire Story

Once both sides already know the current state, there is no architectural reason to retransmit the whole narrative every time something changes.

A future agent could transmit only a delta:

issue_id: 9827
status_change: delayed
new_deadline: 2026-09-18
new_commitment: refund_confirmed
new_evidence_ref: document-827
requested_action: acknowledgment

That is closer to the way distributed systems synchronize state than to the way human email works today.

Traditional email repeatedly packages a small amount of new information together with previous quoted messages, signatures, disclaimers, HTML formatting, repeated context, embedded images, and tracking elements.

In state-centric communication, the default becomes:

Apply this state change.

The whole story does not need to be sent again.

Network Traffic: A Real Benefit, but Not the Main One

Plain email text is not one of the dominant sources of global Internet traffic, so it would be misleading to claim that structured agent communication would radically reduce Internet traffic by itself.

However, there is still a meaningful infrastructure effect, especially inside large organizations and future multi-agent ecosystems.

The same message may be transmitted to several systems, synchronized across multiple clients, spam-scanned, indexed, backed up, archived, copied into CRM and ticketing systems, embedded for semantic search, and parsed repeatedly by language models.

In an environment containing millions of automated agents, repeatedly converting structured internal state into verbose natural language, transmitting it, storing it, and parsing it back into structured state becomes increasingly wasteful.

The network savings may be secondary.

The larger opportunity is reducing the total processing amplification around communication.

Storage Amplification May Matter Even More

An email rarely exists in only one place.

It may simultaneously exist in the sender’s Sent folder, the recipient’s Inbox, intermediate mail infrastructure, enterprise archives, backups, CRM systems, ticketing systems, search indexes, vector databases, compliance storage, and inside the quoted history of later replies.

A small amount of new meaning can therefore produce substantial storage amplification.

This happens partly because a document is forced to serve several roles at once:

  • data;

  • presentation;

  • history;

  • evidence;

  • user interface.

An agent-native architecture can separate these concerns.

Store Meaning. Transmit Changes. Render Language.

The architecture can be summarized in three principles:

Store meaning. Transmit changes. Render language.

Store meaning

The canonical object is a verifiable semantic structure rather than necessarily the full human prose.

It may include identities, claims, commitments, accepted and disputed facts, evidence references, timestamps, permissions, deadlines, uncertainty, and relationship state.

Transmit changes

When context is already shared, agents transmit only changes.

This resembles event sourcing, versioned state, or other synchronization patterns already common in software systems.

Render language

Human language is created when a human needs to consume the communication.

It becomes a presentation layer rather than the sole source of truth.

Render-on-Demand Communication

The conventional process is:

write human text -> transmit human text -> parse human text

An agent-native process can instead be:

encode meaning -> transmit meaning -> render if needed

The human recipient might receive a two-line summary, dashboard update, task, spoken briefing, traditional email, legal-style rendering, or no notification until an action is required.

The communication remains the same. Its representation changes according to the needs of the recipient.

Why This Resembles Normal Software Architecture

Modern software already separates state from presentation.

A database does not normally store screenshots of an application as the application’s primary data model. It stores state, and the user interface renders that state.

Email historically combines these layers.

The text is simultaneously state, interface, transport, and history.

That model is excellent for direct human-to-human communication. It is not necessarily optimal for communication in which AI agents operate on both sides.

Three Layers of Agent-Native Communication

A future architecture could contain at least three layers.

1. Protocol layer

The smallest formal communication between systems:

  • message type;

  • sender identity;

  • receiver identity;

  • intent;

  • claims;

  • requested action;

  • commitments;

  • timestamps;

  • references;

  • state transitions.

2. Semantic and social layer

Context that machines need to preserve but humans do not always need to read directly:

  • confidence;

  • provenance;

  • relationship stance;

  • urgency;

  • escalation level;

  • politeness intent;

  • uncertainty;

  • negotiation state.

3. Human rendering layer

The representation shown to a person:

  • email;

  • summary;

  • timeline;

  • checklist;

  • voice briefing;

  • dashboard;

  • contract-style language.

This is a deeper form of programmability than conventional email automation.

Existing Infrastructure Already Points in This Direction

The pieces of this architecture are not purely hypothetical.

Google’s Gmail documentation already describes the use of Schema.org markup in email so that machine-readable entities such as flights, reservations, orders, invoices, and actions can be extracted and presented separately from the prose. Gmail supports JSON-LD and Microdata for this purpose.

This is still a text-first model: structured data is metadata attached to an email. But it demonstrates that email clients already benefit from separating machine-readable semantics from human-readable representation.

At the agent layer, Google introduced the Agent2Agent Protocol (A2A) in 2025 as an open protocol intended to allow independently built AI agents to collaborate across vendors, frameworks, applications, and data systems.

A2A is not itself a replacement for email. But it makes one architectural fact increasingly important: once autonomous systems can communicate directly, natural-language prose no longer has to be the only interoperability format.

The Inefficient Round Trip

The strongest economic argument may appear when both sides of the communication are already machines.

Consider this pipeline:

structured internal state
    -> generated prose
    -> network
    -> stored prose
    -> LLM parsing
    -> structured state

The structure is converted into language only so that another machine can convert the language back into structure.

For human-to-human communication, that is natural.

For machine-to-machine communication, it is architectural overhead.

A more direct pipeline is:

structured state -> structured state

Natural language is generated only at the human boundary.

The Legal and Evidentiary Problem: What Was Actually Communicated?

This architecture immediately creates a difficult problem.

If the recipient’s agent dynamically generates the human wording, what exactly constitutes the legal record?

Suppose the same semantic state is rendered differently for two users. Which version is the document?

This matters for contracts, legal notices, regulated industries, financial obligations, compliance, litigation, and audit trails.

State-centric communication would therefore require stronger provenance mechanisms, potentially including cryptographically signed semantic state, immutable event logs, verified sender identities, explicit human-approval markers, renderer identity and version, and snapshots of the exact representation displayed to a person.

The evidentiary model could then answer two separate questions:

  1. What semantic state was transmitted?

  2. What exact representation was shown to the human recipient?

In some settings, that may ultimately be more rigorous than today’s email record.

Not Every Message Can Be Reduced to Fields

The proposal should not be taken to mean that all human communication can or should be reduced to a schema.

There are domains where form is itself part of the meaning: literature, personal correspondence, diplomacy, condolences, high-stakes negotiation, marketing, political speech, and emotionally significant communication.

In such cases, word choice, rhythm, ambiguity, and authorship may be essential information.

An agent-native protocol therefore needs different fidelity levels.

Sometimes structured state is sufficient. Sometimes exact wording must be preserved. Sometimes both layers are required.

A New Message Model, Not Necessarily a New Email Protocol

This transition does not require SMTP to disappear tomorrow.

It could begin as an additional layer on top of existing infrastructure.

A message might initially contain a canonical structured payload, a human-readable fallback, digital signatures, and evidence references.

An old client would show the human-readable email. An agent-native client would consume the structured state.

Over time, the priority could invert:

Today:    text first, metadata second
Tomorrow: semantic state first, human rendering second

Trust and Authenticity Do Not Disappear

Research on AI-mediated communication increasingly shows that people care not only about the information contained in a message but also about who authored it and whether AI involvement is disclosed.

Recent work has identified an "AI penalty" in some contexts: communication known to involve AI can be perceived as less trustworthy, less authentic, or less useful, even while people simultaneously say that disclosure of AI involvement is important.

That creates a disclosure paradox.

State-centric communication would therefore need to represent authorship and agency explicitly.

It should be possible to distinguish a human-authored claim, an AI-suggested claim, a human-approved AI rendering, an autonomous agent action, an externally sourced fact, and a machine inference.

The system must not merely preserve meaning.

It must preserve provenance of meaning.

Natural Language May Become an Interface Rather Than the Protocol

For thousands of years, natural language has served several roles at once: interface, protocol, storage format, and mechanism for transmitting intent.

Machines do not require that combination.

They can exchange more formal state while still presenting natural language to humans.

Natural language may remain central to human experience while moving outward in the architecture.

It becomes the human interface to a communication state, much as a graphical user interface is essential to the user but not identical to the system’s internal representation.

The Next Stage May Not Be Better Email

We often describe AI as a technology that will help us write better messages.

That may be the near-term use case, but not the long-term architecture.

The larger transition begins when two parties discover that their AI agents do not need to exchange literary email at all.

What they need to exchange is closer to intent, claims, evidence, uncertainty, commitments, permissions, deadlines, negotiation state, and provenance.

The infrastructure principle can then be stated simply:

Store meaning. Transmit changes. Render language.

Human language does not disappear.

It remains indispensable wherever wording itself carries meaning.

But for a large class of operational, commercial, administrative, and machine-mediated communication, its architectural role can change.

One of the most durable forms of digital communication may therefore be transformed for an unexpected reason.

Not because AI finally learned to write the perfect email.

But because, between machines, writing the email may no longer be necessary.

And the central question may change from:

What was written in the message?

to:

What state was transmitted, who approved it, what evidence supported it, and what changed as a result?

Sources