Agentic commerce sounds simple when everything works.
You tell an agent what you want. It finds a seller. It makes a deal. Someone performs. Money moves.
The interesting problems start when something goes wrong.
Did the agent have authority to make the purchase? Did the seller deliver what it promised? Which records prove what happened? Who takes the loss? Can anyone get the money back?
We should not invent the answers from scratch every time. We need ground rules.
Someone has to be responsible.
Software does not make responsibility disappear. Every important promise should belong to an identifiable person or business.
The buyer may be responsible for payment. The merchant may be responsible for delivery. An agent provider may be responsible for following the user’s instructions. A payment company may have its own narrower duties.
Calling software an agent should not make everyone responsible for everything it does. It also should not let the companies behind a transaction disappear when something goes wrong.
Say what the agent is allowed to do.
“Act for me” is too vague.
An agent might be allowed to search but not buy. It might be allowed to spend $50 but not $5,000. It might be allowed to make a purchase but not waive a refund claim or settle a dispute.
Those permissions should be explicit. An agent cannot give itself more authority by claiming it has permission. If the buyer sets a $100 budget, two agents talking to each other cannot turn it into $1,000.
Ask when it matters. Otherwise, act.
An agent should not ask permission for every tiny choice. That defeats much of the point of using an agent.
But it should ask when an instruction leaves a major question unresolved. “Order me lunch” leaves room to choose between two similar sandwiches. “Buy me a flight” does not necessarily mean “buy me a $9,000 first-class ticket.”
Ask when the unresolved choice is important. When the user genuinely gave the agent discretion, respect the choice the agent made within that discretion.
Limits have to survive delegation.
Agents will delegate work to other agents. The rules cannot disappear halfway through the chain.
If I give an agent a $100 budget and it asks three other agents to help, that does not create three $100 budgets. The same rule applies to deadlines, location limits, product restrictions, and privacy requirements.
Important limits need to travel with the task. Delegation is not a loophole.
“Done” should mean something.
An agent saying a task succeeded does not prove that it succeeded.
A hotel reservation needs a reservation record. A delivered file needs proof of delivery. A purchase of 100 units needs a record of what was actually bought.
A payment authorization proves that payment was authorized. It does not prove that the product arrived. A success message proves that software generated a success message. It does not prove that the outside world changed.
Different records prove different things.
A signature can show who signed something. It does not always show that the signer had authority.
A delivery record can show that a package arrived. It does not show that the package contained what was promised. A payment can show that money moved. It does not show that the buyer accepted the goods.
Agentic systems should preserve enough information to answer each question. Resolving one dispute should not require dumping an entire conversation history, exposing credentials, or revealing unrelated transactions.
Decide who has to keep the receipts.
Disputes become much harder when nobody knows who had to preserve the evidence. The rules should say.
If a merchant must retain proof of delivery, say so. If an agent provider must retain the user’s mandate, say so. If a payment provider must preserve a transaction record, say so.
The rules should also say what happens when evidence disappears. The consequence should fit the missing proof.
Find the failure before deciding who gets paid.
An agentic dispute may involve several relationships. The user’s agent may exceed its instructions while the merchant performs exactly as promised. The payment system may have its own rules.
Separate those questions. Identify who promised what, what went wrong, who knew what, what can be fixed, and who still holds the goods or money. Then decide the remedy.
Three apples, not three MacBook Pros
Suppose I tell my agent to buy three apples and give it a $20 budget. Instead, it buys three MacBook Pros for $6,000.
The agent plainly exceeded its instructions. The next question is who bears the loss.
Did the merchant know about the $20 limit? Did the agent send that limit to the merchant? Can the MacBooks be returned? Who has the computers? Who has the money? What did each participant know?
The agent provider may have failed even if the merchant still has a valid claim for payment. That is why we need clear rules instead of one giant undo button.
eBay set the ground rules
eBay did more than connect buyers and sellers. It set the rules for what happened when a deal went wrong, built those rules into the transaction, and enforced the result.
Colin Rule has explained how this worked. When a buyer said an item never arrived, eBay stopped investigating every case from scratch. It told sellers what proof they had to keep. Delivery confirmation controlled ordinary claims. More expensive purchases required a signature.
eBay then made that proof easier to create. Tracking came with shipping labels bought through the platform. The rule, the evidence, and the dispute process became parts of the same system. Routine cases could be resolved consistently and, eventually, automatically.
The result was a marketplace where strangers could trade with more confidence. They knew what would happen if a package disappeared. In a later study, Rule found that buyers who used effective redress generally increased their activity on eBay, including buyers who lost their disputes.
Agentic commerce needs the same foundation. Set the rules before the transaction. Say what the agent may do, what proof each participant must keep, who decides a dispute, and what that decision can change.
These eight principles are a starting point.
The agent economy needs rules for when the software gets it wrong.