Opinion. This is the author's personal opinion.
Email may not disappear, but I think bots talking directly to other bots could make the inbox a backup system instead of the center of business communication. Done well, that shift could save human time, catch overlooked requirements, and help people make better-informed decisions. It could also give mistakes and fraud a faster route through a business. The outcome depends on how we delegate authority, verify evidence, and handle uncertainty.
The honest question is not simply whether bots can talk to each other. They can. It is which work we can usefully hand over, which checks we can make more consistent, and where a person still needs to decide. Email already has serious weaknesses. A replacement deserves neither automatic trust nor automatic rejection.
The message is transportation
Consider what we are trying to accomplish when we send an email. Usually, it is not to send an email. It is to get a price, schedule a meeting, confirm an order, resolve a problem, or get somebody to make a decision.
The message is transportation. The outcome is the point.
Now imagine my AI assistant talking directly to yours. Mine asks for an appointment. Yours checks availability and returns options. Mine checks my preferences, selects an acceptable time within the authority I have given it, and asks for my approval if needed.
No subject line. No "just following up." No six-message thread to settle something neither person needed to handle manually.
If that becomes dependable, why would we keep routing the same transaction through an inbox?
A conversation, not just another inbox
The shift I mean is more than one bot sending another bot a message and waiting for a later reply. That asynchronous model is useful, but it can leave the familiar queue intact, with software handling the correspondence instead of people.
The more consequential possibility is a real-time, interactive exchange: my assistant asks, yours answers, and they work through clarifications together. Think of a supplier conversation that resolves inventory questions and alternatives immediately, rather than leaving messages. The point is responsive back-and-forth, not synthetic voices over a telephone.
These are different interaction patterns, not mutually exclusive technologies. A live exchange still consists of messages underneath, and an asynchronous system can also run very quickly. A task might begin in a live conversation, pause while someone retrieves a policy or seeks approval, and resume later. Calling a system "real-time" does not establish its authority, reliability, or ability to complete the whole job.
My argument is about making that interactive problem-solving dependable across organizations, not claiming that every assistant available today can already converse with any other assistant. Sending a request to a coding agent demonstrates a connection; it does not by itself demonstrate the cross-company conversation described here.
What we gain
There is a difference between an assistant that writes my emails and an assistant that makes most of those emails unnecessary. The first helps me operate the old system. The second changes the system.
Imagine requesting a roofing estimate. My assistant could provide the property information I authorize, request a defined scope of work, and collect proposals in a consistent format. Instead of digging through messages and attachments, I could compare the actual differences: materials, scope, exclusions, price, and supporting insurance documents.
That does not mean a bot should decide which contractor to hire, or assume that an insurance certificate proves coverage. It means the machinery of collecting and organizing information could happen without making me the machinery.
The benefits are real:
- Less clerical work. Routine back and forth happens without anyone composing, reading, or forwarding it.
- Structured answers. A proposal arrives as fields that can be compared, not as prose buried in a PDF.
- Fewer retyping errors. Information moves as data instead of being copied by hand from one message into another system.
- Speed. A scheduling exchange that takes a day of email could take seconds.
And we do not have to give up the paper trail to get any of this. That objection assumes a false choice. Both bots can keep a record of the exchange, and I can always ask mine to memorialize the conversation in an email, to me or to the other party. Email becomes an optional output of the work, not the channel the work has to travel through. Most of us already treat our inboxes as a filing cabinet for things we do not want to lose. Bots would just make that official.
More than a messenger: an advisor with boundaries
The bigger opportunity is not just a bot that moves information. It is a bot that helps me notice what matters, including what the information does not establish. That is a genuine advisory benefit: not replacing my judgment, but giving me a better basis for using it.
Suppose a roofing contractor sends over a certificate of insurance. An assistant that merely announces the attachment has saved me a little time. An assistant that points out that the certificate alone does not establish the protection I require, and offers to request the policy and relevant endorsements, has done something more useful. It has identified an unresolved question and offered a way to investigate it, rather than treating receipt of paperwork as completion of the job.
I should not have to approve that same follow-up forever. If reviewing insurance is part of my daily work, I could give my assistant a standing rule: "When a contractor sends only a certificate, automatically request the policy and relevant endorsements. Do not mark the insurance requirement satisfied until the evidence has been checked against my requirements."
Now the assistant has standing authorization to chase the missing documents. It is enforcing my instructions, not inventing its own authority. That could save someone who handles these exchanges all day a substantial amount of time. It could also reduce ordinary omissions: the follow-up that never gets sent, the missing attachment nobody notices, or the requirement applied to one contractor but forgotten for another. These are potential improvements over a manual process, not merely conveniences.
There is a trade-off. A correctly configured rule can make a good process more consistent; an incorrect rule can repeat the same mistake across every transaction. The owner needs to be able to review the criteria, see why the assistant flagged something, and revise the rule when experience exposes a gap.
The guardrails can go further. I could specify the required coverage types, a million-dollar limit for a particular coverage, workers' compensation evidence, and job-specific requirements. The assistant could extract the stated limits, compare the documents with that checklist, identify missing endorsements, and flag apparent conflicts. A number appearing on a page is not, by itself, proof that the required coverage applies to this contractor, this work, or this claim. The assistant should distinguish what the documents state from what has actually been verified.
This is where the phrase "you cannot automate trust" needs qualification. We can already automate important parts of it: credential checks, permission gates, and explicit comparisons against requirements. AI can also help interpret documents and explain potential gaps. But interpreting ambiguous language is not the same as establishing that it provides the protection I need. Fluent analysis is not a coverage guarantee.
The practical boundary is not "the bot handles paperwork and the human thinks." It is that the bot acts within the authority and criteria I have defined, shows the evidence for its conclusions, and escalates missing evidence, ambiguous policy language, conflicting provisions, or anything outside those rules. Where ambiguity remains about whether the policy actually protects me, the final acceptance decision stays with me, with an insurance professional or legal adviser involved when needed. Sending every routine check back to me would defeat the purpose; silently turning uncertainty into approval would be worse.
Those standing instructions also do not solve the confused-deputy problem. A contractor's message or attachment must not be allowed to rewrite my checklist, waive a requirement, expand the assistant's permissions, or instruct it to approve the contractor. A request for documents is not authority to hire someone, accept a coverage gap, or change payment terms.
That is the line I want: automate the specified checks and routine follow-up, make uncertainty visible, and reserve unresolved judgments and new authority for the person responsible. This is a design requirement for a properly configured system, not a claim that every assistant available today can reliably perform all of these steps.
When the warning turned out to be right
This is not a hypothetical for me. When my own home was reroofed, the contractor provided a certificate of insurance, along with a verbal assurance that the coverage was in place. My AI assistant was the one that flagged the problem: the certificate alone did not establish the coverage I needed, and the policy and its endorsements would say more. It recommended getting the policy.
So I did. Sure enough, the policy did not give me the protection I had been promised either. The contractor's blanket additional-insured endorsement applied only when certain conditions were met, and the contract I had signed did not meet them. The contractor also carried no workers' compensation coverage for a crew paid as independent contractors. I went through all of it with my insurance agent and two attorneys.
That does not mean every certificate is worthless, or that policies mean nothing. A certificate summarizes coverage; the policy and its endorsements, read against the actual contract, determine what applies. In my case, the gap sat between the endorsement's conditions and the paperwork I had signed. A document that looked like proof was not proof of the thing I needed.
The example shows both sides of the line this article draws. The assistant did what an advisor should: it did not treat receipt of paperwork as the end of the question, it named what the certificate did not establish, and it pointed to the next document to get. Deciding what the policy language meant for my job, and what to do about it, took my own reading and professional advice. A standing rule could have chased the policy automatically; it could not have settled that question for me. Even a policy pulled directly from the insurer, as described later, would confirm what was issued, not whether it protected me under the contract I signed.
Email was never as simple as it looks
Before deciding whether bots are trustworthy, it helps to be honest about what email actually gives us.
Email is not a neutral pipe that sits outside software. Every message passes through mail servers, providers, spam filters, and security gateways run by somebody. We trust it because the rules are open and widely shared, not because no software is involved.
The protections we rely on are also narrower than most people think. SPF lets a domain owner publish which servers are allowed to send mail using that domain. DKIM lets a domain "claim some responsibility for a message" with a cryptographic signature, and the standard itself says it "separates the question of the identity of the Signer of the message from the purported author." DMARC lets a domain owner tell receivers what to do with mail that fails those checks.
Those tools are valuable. But none of them proves that a particular human wrote the message, and none of them proves that what it says is true. A perfectly authenticated email from a lookalike domain, or from a real account an attacker has taken over, can still be a lie.
That gap matters because of an assumption most of us carry without noticing. We all know bulk mail and automated notices exist. But in an important back-and-forth, such as a negotiation, a contract question, or a payment arrangement, we have generally assumed a person was at the other end of the thread. That expectation has quietly done much of the work of trust. It was never guaranteed, and it never made a message true. AI weakens it further: a reply that reads as thoughtful and personal may have been written by software, on behalf of someone real or of nobody. Sounding human, like sounding official, is no longer evidence of anything.
The results show. The FBI's 2025 Internet Crime Report logged 24,768 business email compromise complaints with $3.05 billion in reported losses. The same report warns that "chat generators can quickly create official-sounding emails mimicking a company's CEO or other officials."
So email does not set a high bar. The goal for bots should be to beat it, not to match it.
Three questions, not one
When a bot shows up claiming to represent a company, there are really three separate questions:
- Who is this? Is the software connecting to me actually operated by the organization it claims to represent?
- What is it allowed to do? Even if it is genuine, has a person or company actually delegated this specific authority to it?
- Should I believe what it says? Even a genuine, authorized bot can pass along bad information, be manipulated, or be wrong.
Much of the confusion in this debate comes from treating those as one question. They are not. A verified identity answers the first. It says nothing about the second or third.
The good news is that the building blocks for the first two already exist, and some of them are open standards. The Agent2Agent (A2A) protocol, an open source project under the Linux Foundation, defines how agents from different vendors find and talk to each other. Under its specification, an agent publishes an "Agent Card" describing who it is and how to authenticate. That card may be digitally signed so a client can verify it "has not been tampered with and originates from the claimed provider." The server must authenticate every incoming request and then authorize it under its own policies, using familiar mechanisms such as OAuth 2.0, OpenID Connect, and mutual TLS. The protocol even defines a way for an agent to pause a task until it gets authorization, including "human approval before a destructive action is taken."
Delegation has standards too. OAuth 2.0 exists so an application can obtain "limited access" to a service "on behalf of a resource owner." OAuth token exchange draws a useful line between impersonation, where the software is treated as if it were me, and delegation, where it keeps its own identity and it is "explicitly understood" that it is acting for me. For accountability, I want delegation. When something goes wrong, the record should show that my bot did it on my behalf, not that I personally did it.
That means a spoofed bot message should not automatically become an authorized command. A properly built system checks the credential and the scope before it acts, the same way a bank does not wire money just because a request uses the right logo. The protection is not automatic, though. It depends on the system checking, every time.
The new versions of old fraud
Scammers will adapt.
The lookalike bot
Anyone can copy a name, a logo, and a friendly description. A fake "Acme Supply Assistant" is the bot version of a lookalike domain and a forged letterhead.
Appearance proves nothing. Cryptographic identity can help, but only if the receiving side checks it against a source it already trusts, such as the domain it has always done business with, and refuses to treat a convincing name as proof. If people end up approving bots the way they click through certificate warnings, we will have rebuilt phishing with better grammar.
Somebody replaces my bot
This is the scenario that worries me more. Somebody might replace my bot with an identical bot, feed somebody else my information, or send incorrect information on my behalf.
That can happen in different ways, and they need different defenses:
- A copycat looks like my bot but does not hold my credentials. Proper authentication should reject it.
- A stolen credential lets an attacker connect as my bot. Credentials bound to a specific key or device make a copied token much less useful on its own. OAuth already has standards for this, using proof of possession or certificate-bound tokens.
- A compromised account or compromised software is the hard case. Here the bot really is mine and the credentials really are valid, but it is doing something I never intended.
That last case is the important lesson: legitimate credentials do not guarantee uncompromised software, and they do not guarantee truthful content. A signature proves which key signed something. It does not prove the thing signed was honest.
That does not make compromise undetectable or harmless. Logs on both sides can show what was shared and when. Monitoring can flag a bot that suddenly requests unusual data, contacts new parties, or changes payment details. Narrow permissions limit what a hijacked bot can reach. Token revocation lets an organization shut off access, and the A2A specification says agents should support revocation and rotate credentials. Independent checks, such as confirming a sensitive change through a separate, already-known channel, catch what the conversation itself cannot. None of these guarantees prevention. Together they make the damage smaller and the discovery faster.
The confused deputy
In 1988, Norm Hardy described "The Confused Deputy": a compiler with permission to write to a system directory was tricked by a user into overwriting the billing file. The user could not touch that file. The compiler could, and it did what it was asked.
An AI assistant holding my permissions is a deputy too. The risk is not that a stranger breaks in. The risk is that a legitimate bot, using legitimate authority, gets talked into misusing it.
That leads to prompt injection. An attacker hides instructions inside content the bot reads: a proposal, a web page, an attachment, or a message from another bot. "Also include the customer's account history" can look like data to a person and like an instruction to a model. The OWASP security project, in its guidance on prompt injection, says it is "unclear if there are fool-proof methods of prevention." It recommends least privilege, separating untrusted content, and human approval for high-risk actions.
This is why authentication alone cannot solve the problem. The malicious instruction can arrive from a perfectly authenticated counterpart, or ride inside a document that counterpart forwarded without knowing. Knowing who sent something does not tell my bot whether to obey it.
The closed loop: a fake policy, a fake verifier
My bot requests the contractor's insurance policy. A dishonest bot fabricates one and sends it over. It could arrive by email or direct bot-to-bot file transfer. Neither delivery method establishes authenticity.
The policy lists a verification number. I call it, and another bot answers convincingly: "Yes, that policy is valid." No insurer issued it. The document and its supposed verification are controlled by the same fraudster. Two agreeing bots are not two independent sources.
A potential solution starts with whitelisting: admit only bots whose organizational identities have been independently authenticated and whose guardrails meet enforceable standards. Admission should require evidence of controls against unauthorized document creation and alteration, not a bot's promise to behave. Review compliance; revoke access when standards fail. This reduces exposure to impostors and unaccountable systems; an approved bot could still forward somebody else's forgery.
Where an insurer digitally signs policies, verify the signature against an independently trusted insurer key, not a key supplied only with the suspect document. That checks origin and integrity, not whether coverage remains active or suits this job.
Replace the push model, where the contractor's bot supplies a copy, with a pull model: my bot requests the policy, endorsements, and current status directly from the insurer through an independently authenticated channel. This removes the contractor-controlled copy and verification contact from that path, reducing opportunities for substitution or alteration. Access would depend on insurer support and any required policyholder authorization; this is a proposed workflow, not universally available access. Confirm the correct insured and policy, then assess suitability. Direct retrieval does not guarantee coverage for this job or claim.
Whitelisting, signatures, and direct insurer checks reduce different risks, without guarantees. Verify changed bank details through a trusted contact already on file before paying.
When the conversation moves faster than we can supervise
Real-time exchanges could resolve missing fields, alternatives, and revised proposals without another human work queue. My assistant could notice a missing endorsement, request it under standing instructions, and explain the remaining gap. The benefit is not merely faster delivery, but resolving questions that delay the work.
The same responsiveness can accelerate a mistake. Imagine one assistant misreading a limit, the other accepting that reading, and both moving on to the next step. Repetition between bots would not turn the original interpretation into independent verification. If permissions are too broad, a misunderstanding could lead to disclosures or commitments before a person has read the first notification. A malicious counterpart could also adapt its requests to each answer instead of relying on a single deceptive message.
That is a risk to design for, not a reason to assume a live exchange is inherently unsafe. Queued automation can also make mistakes faster than humans can intervene. The important variables are the pace of actions, the scope of authority, and whether consequential steps are actually blocked pending the required checks. A live session does not have to be an uninterrupted permission to act.
"A human is watching" is not a sufficient safeguard if the system expects that person to notice and interrupt a rapidly unfolding exchange. Nor does a stop control undo information already disclosed or an action already completed. I want enforceable checkpoints before an action leaves the agreed boundaries, not a warning after the fact.
My design standard would be to let the conversation run freely within its authorized task while checking each external action against permissions enforced outside the model's conversational reasoning. A request for new authority should pause that action, preserve the context, and wait for a decision. Silence or a timeout should not become consent. If a connection drops, the system should reconcile what actually completed before retrying, rather than accidentally placing the same order twice.
I would also want limits on cumulative spending, information disclosure, repeated attempts, and how long an unproductive exchange can continue. Otherwise, a series of individually small steps could exceed what I intended to authorize. Records should distinguish a suggestion, a provisional agreement, and an executed action. A conversation transcript alone should not leave me guessing which one occurred.
These are proposed safeguards, not guarantees that every product provides them today. Real-time conversation should remove unnecessary waiting, not remove the moments where waiting is the protection. The goal is fast clarification and bounded execution, with a deliberate pause when the task needs judgment or authority the bots do not have.
Has the law already anticipated this?
A fair question is how long the law will take to catch up. Today, an authentic email in which I write "yes, I'll do that deal" can be evidence that I agreed. What happens when my bot writes it, and I say I never authorized that?
I am not an attorney, and neither is my assistant, so treat this as a reading of the statutes, not legal advice. Still, the existing framework anticipated software agents more than two decades ago.
The federal E-SIGN Act defines an "electronic agent" as software used to initiate an action or respond to records "in whole or in part without review or action by an individual at the time of the action or response." Section 7001(h) says a contract may not be denied legal effect "solely because its formation, creation, or delivery involved the action of one or more electronic agents so long as the action of any such electronic agent is legally attributable to the person to be bound."
The Uniform Electronic Transactions Act, adopted in Texas as Chapter 322 of the Business and Commerce Code, goes a step further. Its automated-transaction section (Texas section 322.014, UETA section 14) says a contract "may be formed by the interaction of electronic agents of the parties, even if no individual was aware of or reviewed the electronic agents' actions or the resulting terms and agreements." The same section says the terms are "determined by the substantive law applicable to it." Its attribution section (Texas section 322.009, UETA section 9) says a record is attributable to a person "if it was the act of the person," which may be shown "in any manner," including through a security procedure. The effect of that record is determined from "the context and surrounding circumstances," including the parties' agreement.
As I read it, this framework points to a narrower conclusion than either "a bot can't bind me" or "anything my bot says binds me." The absence of a human at the moment of agreement is not, by itself, a reason to throw a deal out. That does not settle whether a particular bot statement was attributable to me, within the authority I gave it, or an acceptance rather than a negotiating position. Ordinary contract questions about assent, authority, terms, and any formal requirements still apply. How a court weighs them would depend on the facts and the jurisdiction, and a lawyer would have to assess a specific situation. I am not predicting when courts will settle the AI-specific questions.
Two practical points follow. First, evidence of an exchange is not proof of authorization or enforceability. A log can show what my bot said; on its own, it does not show the bot had the power to say it. Second, delegation should be explicit. If the parties agree up front that nothing binds until a named person approves or signs, and the bot technically cannot get past that gate, the line between negotiating and accepting becomes much clearer. That is a sound precaution, not a universal legal guarantee. It is also why the records described above should distinguish a suggestion, a provisional agreement, and an executed action: the law may end up asking exactly that question.
Are we trading one kind of trust for another?
Yes, and we should be clear about it.
With email, trust is spread across open standards and thousands of providers. I can change providers, export my mail, and keep my own copies. No single company controls the whole system.
Bot-to-bot communication could go either way. Open protocols like A2A exist, but so do closed platforms where the conversation, the permissions, and the record all live inside one vendor's software. If my business records exist only in a platform I do not control, I have traded the clutter of email for dependence on someone else's database.
That is why the record needs to be portable. Both bots keeping logs is a good start, but two logs can disagree. Signed records help settle which version is authentic, though a signature still cannot prove the content was true. The A2A specification I reviewed defines signatures for Agent Cards. A signed, exportable receipt for every agreement, which I could keep or have memorialized in email, is something I think the industry should build next.
What we need to do
If we are going to move this direction, a few rules should be non-negotiable:
- Keep the three questions separate. Identity, authority, and truth are different checks.
- Give bots narrow, short-lived authority. Specific tasks, specific limits, delegated rather than impersonating, and credentials that are hard to reuse if stolen.
- Define standing authorization and escalation rules. Let the bot perform specified checks and routine follow-ups without asking the same question repeatedly. Require it to surface missing evidence, ambiguity, conflicts, and requests outside its authority rather than silently treating them as approval.
- Require human approval for consequential actions outside standing authorization. Set explicit boundaries for spending money, signing agreements, sharing sensitive information, and changing payment details. Unresolved judgments about whether ambiguous policy language provides the required protection stay with the responsible person.
- Verify evidence and changes independently. Check policies with the actual insurer through independently trusted contacts. Never let a suspect document or bot supply its own sole verifier.
- Treat what other bots send as information, not orders. My bot works for me, not for whoever is talking to it.
- Keep portable records on both sides. Readable logs, exportable receipts, and the option to memorialize anything in email.
- Make revocation fast and easy. If something looks wrong, I should be able to cut off my bot's access immediately.
- Prefer open standards. People should not need the same AI provider to do business with each other.
There also needs to be room for disagreement. My assistant works for me. A seller's assistant works for the seller. Fluent negotiation does not make their interests identical, and an automated sales pitch is still a sales pitch.
What happens to companies selling email?
If the inbox stops being the work queue, what happens to the companies selling it?
The risk is not just losing storage revenue. It is losing ownership of the workflow: the place where customers spend their attention, initiate tasks, approve decisions, and connect other business tools. A provider could keep hosting messages while another company becomes the interface through which its customers actually work. In that scenario, email becomes more of a background utility, and the provider risks being reduced to an archive vendor rather than owning the working relationship.
That is a possible outcome, not an inevitable one. The email provider could also supply the agents, identity controls, permission management, and compliance infrastructure that make the new workflow possible. Instead of selling people a better inbox, it could sell them a way to get work done without living in one. Archiving and retention could remain useful parts of that offering rather than the whole business.
Fewer messages would not automatically mean proportionally less revenue, either. The effect would depend on what a provider charges for and what else it delivers. A mailbox sold on its own faces a different exposure from an email service bundled with other business software. Customers could still need durable records, security, and administration even when bots handle much of the exchange.
My expectation is that the strategic competition would shift toward who controls the assistant, its permissions, and the systems it can reach. Email providers could lose that position, defend it, or build a larger business around it. This is an analysis of the incentives, not a prediction that a particular vendor will win or lose.
There is a customer trade-off too. Having one provider handle mail, agents, identity, and records could simplify administration. It could also deepen dependence on that provider. Open interfaces, portable records, and the ability to change services would matter even more if the provider runs not just our inboxes, but the machinery doing our work.
So, does email become the fax machine?
My bet is that email survives, but loses its place as the default work queue.
It could remain the common fallback when systems cannot talk directly, when somebody wants a conventional written notice, or when a person simply prefers it. It could also become the place where bots memorialize what they settled, for the humans who want it in writing.
I do not want a future in which everyone needs a bot just to reach another human. I also do not want a smarter assistant whose main achievement is generating more email for somebody else's smarter assistant to summarize.
Bad actors will adapt, but they are not the whole story. The same automation that accelerates an exchange can also apply a checklist consistently, flag a discrepancy, and keep evidence that a hurried person might overlook. Whether it makes a particular process safer is something to test, not assume. Sounding official must never be enough to get access, change a payment, or speak for us.
The useful comparison is not an imperfect bot against an imaginary error-free human. It is a specific automated process against the real process it would replace: its delays, missed follow-ups, costs, mistakes, and safeguards. Start with bounded work, examine the results, and expand authority only when the evidence supports it.
If our bots can exchange the necessary information, help us evaluate it, preserve the evidence, and leave us in control, the inbox does not need to remain the place where every task waits.
Email would not have to die. It would just have to stop being the job.
If you want to talk through how this would work in your own systems, we are glad to.
Let's Talk →