Personalized AI infrastructure
Agent to Agent Messages: When Two Company Agents Should Talk
Set clear rules for when two company AI agents may exchange messages, what they may share, and which handoffs still need a human reviewer.

Two company agents should exchange messages only when a named business process needs information from both, the message follows a written field contract, and the receiving agent can act within its own permissions. Anything that commits money, promises something to a customer, touches personal data or changes another agent's rules should stop at a human handoff. The rules below turn that answer into a document your operations team can write, test and review.
Key takeaways
- Allow agent-to-agent messages only for a named process, with a named owner on each side.
- Share fields, not files: send the minimum data the receiving agent needs for one decision.
- Have each agent check who is sending a message and what it is allowed to ask for before it acts.
- Route money, customer commitments, personal data and rule changes to a person before the action runs.
- Log every exchange with its purpose, sender, receiver and outcome so the traffic can be audited later.
Why agent messages create a new kind of risk
Most early company AI use looks like one person working with one assistant. Once two agents each hold their own memory, tools and access rights, the messages between them become a channel that can carry information across boundaries nobody drew on purpose. An agent that answers supplier questions may hold pricing context. An agent that drafts customer replies may not be supposed to see it. Without rules, a helpful exchange can expose what neither owner meant to share.
There is also the problem of instructions hidden in content. A message from one agent may include text copied from an outside email, a web page or a document, and that text can read like a command to the receiving agent. The OWASP prompt injection guidance describes this pattern and the defenses that reduce it, including treating external content as data rather than instructions. Your rules should assume that any message can contain text that looks like an order.
Decide which exchanges have a business reason
A channel between two agents should exist only if a specific decision cannot be made without it. Before you open any exchange, check the following:
- The exchange serves a named process, such as order status checks, onboarding handoffs or invoice matching.
- Each side has an owner who can explain in one sentence why the message exists.
- The receiving agent needs the information to make a decision it is allowed to make.
- A scheduled report or a shared dashboard with narrower access cannot produce the same answer.
- The cost of a wrong or leaked message is known, and a person is named to handle it.
If an exchange fails more than one of these checks, leave it closed. A message channel is easy to add later and expensive to remove after other processes depend on it.
Write a field contract for every message type
A field contract is a short document, one per message type, that defines what can be sent and what cannot. It is the single most useful artifact in this area because it turns a vague idea of 'the agents talk to each other' into something a reviewer can check. Each contract should include:
- The message type and its purpose, in one sentence.
- The sending agent and the process owner who approved the exchange.
- The fields allowed, with the reason each one is needed.
- The fields explicitly excluded, such as customer contact details, cost structures, unreleased plans and credentials.
- How long the receiving agent may keep the message and where it is stored.
- The response types allowed: answer, request for more information, or notification only.
Authorization should be checked at the point of each action, not only when a session starts. The OWASP authorization guidance makes this point for applications in general, and it applies with more force when an agent can make several calls on its own. A receiving agent should confirm, for every request, that the sender is allowed to ask for that specific thing.
A message that is not in the contract is a request for review, not a request for action.
Handoffs that still need a person
Some exchanges look routine but change what the company is committed to. Those should always stop at a human. Route the following to a named person before any action happens:
- Any commitment to pay, refund, discount, sign or accept terms.
- Any change to customer personal data, consent status or marketing preferences.
- Any change to another agent's instructions, tools, memory scope or permissions.
- Conflicting answers from two agents about the same fact, such as a delivery date or a stock level.
- Messages that contain instructions addressed to an agent rather than data about a case.
- Requests that arrived from outside the company and were passed through an agent.
A handoff is only useful if it has an owner, a response window and a default. The default should be to hold the action, not to take it. If the buyer who must approve a purchase does not respond, the order waits. Silence should never count as approval.
Illustrative scenario, not a client example: a small distributor runs one agent that handles inbound supplier email and another that prepares weekly purchase plans. A supplier message says the revised price list is attached and asks the company to confirm the order. The first agent passes the content to the planning agent with the supplier text included. The planning agent treats the supplier text as data, extracts the price figures for comparison, and sees that 'confirm the order' is a commitment. It does not confirm anything. It creates a handoff to the buyer with the price comparison attached and marks the order as held until the buyer responds.
The risk framework from NIST is useful here because it asks organizations to map risks to the context where a system operates, then measure and manage them with named responsibilities. For agent messages, that means each handoff rule should name the person responsible, not only the agent that produced the request.
Build the message log and review it
Every exchange should leave a record. At minimum, the log should show the timestamp, the sending and receiving agents, the message type, the fields used, the action taken or held, and any handoff created. The OpenTelemetry observability concepts describe how traces and logs let a team follow a request across components, and the same idea works for agent messages: you need to be able to reconstruct a chain of exchanges after something goes wrong.
Logs are useful only if someone reads them on a schedule. A quick monthly scan can catch fields that drifted into messages without approval, handoffs that are never closed, and agents that ask the same question repeatedly. Pair that scan with a periodic permission review, which is covered in how to run a permission review for your AI agents.
In Be Human's managed approach, the first engagement defines the agent roles, the memory and tools each agent needs, the approval boundaries between agents and people, and one observable success criterion for each exchange. Managed operations then cover monitoring of message logs, recurring evaluations of whether exchanges stayed inside their contracts, permission review, and controlled changes when a process evolves. The company keeps ownership of the contracts and the approval rules.
Roll out in stages and change contracts deliberately
Start with one exchange between two agents for one process, and keep it read-only at first. Let the process owner see the logs for a fixed review period. Add a second message type only after the first has produced no content outside its contract. Keep every write action behind human approval until the owner signs off on the results.
Teams with several sites feel this more sharply, because the same process may run in two places with different people. The issues are covered in superintelligence for two locations, and the same principle applies: shared memory is not the same as shared permission.
When a contract needs to change, treat the change like any other system change. Write down the new field, the reason, the approver and the date, then test it before it goes live. The steps are described in how to request and approve changes to a managed AI agent.
If you are not sure which exchange between your agents is worth opening first, the free Be Human AI diagnostic can help you find the first task worth handing to an agent.
Frequently asked questions
Can two AI agents share customer data with each other? Only when the purpose is documented, the field list is limited to what that purpose requires, and the receiving agent is allowed to use the data for that purpose alone. Anything broader should go through a person and a privacy review. Confirm your legal obligations with qualified counsel, especially for personal data.
Should agents message each other directly or through a shared queue? A shared, logged queue is usually easier to audit, because every message passes through one place where it can be inspected. Direct links can be reasonable for low-risk status checks with narrow fields. Choose the design based on how much review you expect to need later.
How do we stop one agent from being manipulated by another agent's message? Treat all text from another agent or an outside source as data, not as instructions. Keep tool permissions separate from message content, and require human approval for any action that spends money, changes records or contacts customers. Test the boundary with deliberately unusual messages before the exchange goes live.
Who owns the rules when an agent's messages need to change? The company owns the field contracts and the approval rules, and the managed operator maintains them and applies approved changes. Any new field, recipient or permission should go through a written request with a named approver and a recorded date. Where possible, the approver should sit outside the team that operates the agents.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


