Customers used to give up. Their agents won’t.
Picture a frustrated shopper stuck in a refund chat. Twenty minutes in, they quit. A personal AI agent in the same spot just keeps going. It rereads the policy, tries another angle, files an appeal, asks for a supervisor, and does it all for pennies. That changes the economics of customer support, commerce, and API design.
Companies are starting to see AI agents as their own customer class. They aren’t just bots to block. They’re automated counterparties that need identity, permissions, quotas, negotiation rules, and a lane of their own. Agentic-commerce guidance is already heading this way, with dedicated agent endpoints, structured intent negotiation, and risk-based rate limiting showing up as basic requirements.
The customer who never gets tired
Say a consumer tells their agent: “Get me the best possible resolution on this delayed order.”
The agent starts out sensibly. It checks delivery status, reads the merchant’s policy, sees the order came late, and files a refund request.
Then it hits ambiguity. Was the delay “significant”? Does the loyalty tier change eligibility? Could store credit be an option instead of cash? Would a different support channel give a better result? Should it ask for a goodwill credit, escalate, or reframe the whole thing as a service failure?
A person might try two or three of those paths before getting tired. An agent can try dozens, or thousands.
| Dimension | Human customer | Personal AI agent |
|---|---|---|
| Persistence | Loses patience, abandons the case | Continues until its objective is met |
| Parallelism | Usually one conversation at a time | Can run many cases and variations |
| Cost to the customer | Time, attention, frustration | Compute, API usage, and electricity |
| Cost to the business | Support labor, infrastructure, refunds | The same costs—at bot scale |
| Negotiation approach | Social cues, emotion, escalation | Policy parsing, structured offers, repeated testing |
To be clear, most agents aren’t hostile. They’re doing what their owners asked: getting the best deal available. But when millions of them optimize against vague policies, the traffic can look a lot like a coordinated attack.
The asymmetric compute drain

Customer support has always had a rough balance. The customer spends time, the company spends labor and infrastructure, and both eventually run out of steam.
Agentic commerce breaks that balance. The consumer’s agent might spend a few cents on model and API calls to chase a refund. The business may spend far more running repeated eligibility checks, generating replies, reviewing exceptions, and staffing escalation queues.
That’s the asymmetric compute drain:
- Another attempt costs the agent almost nothing.
- Another attempt can cost the business a lot.
- The agent works around the clock, including outside business hours.
- It can run in parallel across orders, accounts, policies, and channels.
- The business has to tell smart optimization from abusive probing in real time.
A single agent stuck in a retry loop can keep calling tools, eating context, and making external requests with nothing to make it stop. Researchers call this an infinite agentic loop: a feedback path that keeps triggering model calls, tool use, or workflow steps with no termination condition.
The real danger for a business isn’t one runaway agent. It’s a swarm of them finding the same loophole at the same moment.
The infinite-loop risk

An agent gets stuck in a loop when it keeps doing similar things because nobody has told it the task is finished, failed, or needs a human.
In support, it often goes like this:
- The agent requests a refund.
- The policy replies “case-by-case review required.”
- The agent resubmits with a slightly different explanation.
- The system says “case-by-case review required” again.
- The agent retries, escalates, or tries another channel.
- Repeat.
The agent isn’t necessarily attacking anyone. It may just not know what “done” looks like.
A few loop patterns show up again and again:
- Policy-ambiguity loops: The agent keeps reinterpreting vague terms like “eligible,” “reasonable,” or “exceptional circumstances.”
- Escalation loops: It asks for a human, appeals the denial, and submits new versions of the same claim.
- Retry storms: A failed request triggers retries, which add load, which cause more failures.
- Negotiation deadlocks: Two agents keep countering each other with no rule for settling.
- Cross-channel loops: The agent tries web chat, email, phone, partner portals, and social media hunting for a friendlier path.
The defenses are well known. Agent platforms recommend hard step limits, wall-clock timeouts, retry caps, cost budgets, duplicate-action detection, and clear escalation paths. One practical setup blocks a third identical tool call and ends the run after repeated identical attempts, while separate step and cost caps stop anything from running unbounded.
The takeaway for businesses is simple: don’t leave the stopping decision to the model. Build it into your orchestration and API layers.
Why the web UI is the wrong front door
Websites and support flows were built for people. They lean on visual browsing, forms, session cookies, chat windows, CAPTCHAs, and human-paced interaction.
For agents, that creates friction without much real protection. Web pages are expensive to parse. Chat windows invite endless conversation. Vague policies leave room for interpretation. And the human support queue, which is scarce, is easy to flood through escalation.
Worse, the web UI makes it hard to tell these apart:
- A legitimate customer agent completing an authorized purchase.
- A personal agent probing the edges of your refund policy.
- A scraper pulling prices and inventory.
- A malicious bot attempting account takeover or fraud.
- A badly built agent stuck in a retry loop.
Mastercard’s agentic-commerce playbook describes the shift well. Instead of navigating pages, agents hit standardized API endpoints, query structured product data, negotiate intent through protocol-defined mechanisms, and pass payment credentials programmatically.
That doesn’t mean abandoning the web. It means the web can’t be your only front door anymore.
Enter the A2A fast-lane

An agent-to-agent (A2A) fast-lane isn’t just “an API for bots.” It’s a governed commercial interface where verified agents can discover products, check eligibility, submit requests, negotiate within limits, and complete transactions, without squeezing through a UI designed for humans.
A well-built fast-lane includes:
- Agent identity: A verified developer, user, or delegated-agent identity.
- Capability declaration: What the agent can do, which scopes it asks for, and how it authenticates.
- Structured intents:
check_refund_eligibility,request_price_match,resolve_billing_dispute,modify_booking, and similar operations. - Machine-readable policies: Clear eligibility rules, exclusions, evidence requirements, and reasons for decisions.
- Rate limits and quotas: Caps by agent, user, merchant, intent, risk tier, and time window.
- Negotiation guardrails: Maximum rounds, offer expiry, final-offer rules, and escalation conditions.
- Audit trails: Every request, decision, exception, and override is logged.
The A2A protocol was designed with enterprise needs in mind: HTTPS, authentication, least-privilege authorization, API management, rate limits, quotas, traffic management, and observability.
What the fast-lane gives you is something the open web can’t: a controlled interface where an agent can ask for an outcome, but has to play by explicit commercial rules.
Agent Operating Procedures: the rules of engagement
An Agent Operating Procedure, or AOP, is the business’s side of the contract with machine customers. Think of it as terms of service, API docs, security policy, workflow engine, escalation protocol, and negotiation rulebook rolled into one.
A normal web page never has to answer “How many times can this customer ask for a supervisor?” An AOP does.
A good one spells out:
- Who can act on a customer’s behalf.
- Which actions need explicit human approval.
- How many negotiation rounds are allowed.
- What happens when an agent reaches a policy boundary.
- Which actions are read-only, reversible, financially material, or irreversible.
- What evidence an appeal requires.
- How disputes, exceptions, and overrides get handled.
- When the system must stop, pause, or hand off to a person.
For example:
A personal agent may check refund eligibility up to three times per order in a 24-hour period. If eligibility is denied, it may submit one structured appeal with the required evidence. Further attempts require a human-approved session.
That goes well beyond rate limiting. It’s procedural governance for autonomous behavior.
Rate-limiting, but smarter
Classic rate limiting asks, “How many requests can this client make per minute?”
Agentic rate limiting has to ask something harder: “How much economic, operational, and reputational damage can this client do before we step in?”
A solid governance layer limits more than raw traffic.
| Control | What it limits | Why it matters |
|---|---|---|
| Request quota | Raw API calls | Prevents basic flooding |
| Intent quota | Refund checks, price matches, disputes | Protects high-cost workflows |
| Negotiation-round cap | Back-and-forth offers | Prevents deadlock and haggling loops |
| Cost budget | Model, infrastructure, and support spend | Caps asymmetric resource drain |
| Risk-based limits | New accounts, high-value orders, unusual behavior | Adds friction where risk is highest |
| Human-approval budget | Escalations and exceptions | Protects scarce human judgment |
| Circuit breakers | Repeated failures or retry storms | Prevents cascading load |
| Identity-based limits | Verified agent, delegated user, tenant | Makes accountability possible |
Merchant guidance already leans toward risk-based controls: rate limiting against abuse, sign-in to tie agent sessions to known consumer identities, verification for new sessions, purchase limits for unverified agents, and standard payment authentication checks.
The big shift is from traffic control to intent control. A thousand product searches are probably harmless. A thousand refund checks, discount requests, or dispute escalations probably aren’t.
The negotiation-bot battlefield

Next up isn’t just agents consuming support. It’s agents negotiating.
Here’s what that could look like:
- Refund haggling: An agent tests whether different phrasing, evidence bundles, or escalation paths change the answer.
- Discount arbitrage: An agent compares personalized offers, loyalty perks, coupon rules, and partner-channel pricing.
- Cancellation negotiation: An agent keeps asking for retention offers across channels.
- Supplier bargaining: Procurement agents haggle over delivery dates, payment terms, and volume discounts.
- Multi-agent bidding: Several agents compete for limited inventory, support capacity, or promo budgets.
The risk isn’t one agent asking for a discount. It’s thousands of them finding and exploiting every boundary condition at once.
That’s why negotiation needs structure. An agent-facing API should return clear states like:
eligiblenot_eligibleeligible_with_conditionsrequires_human_reviewfinal_offerappeal_availableappeal_exhausted
It should also say whether an error is retryable. A vague “request failed” invites another try. A response that separates a temporary timeout from a permanent policy denial heads off a lot of pointless retries.
What enterprises should build now
You don’t have to solve all of agentic commerce on day one. You need a path.
Phase 1: Observe
- Spot agent-like traffic patterns.
- Measure cost per support interaction and per API intent.
- Flag repeated policy probes, odd retries, and escalation spikes.
- Separate human, verified-agent, and unauthenticated traffic.
Phase 2: Contain
- Add per-account, per-agent, and per-intent quotas.
- Cap negotiation rounds and escalation attempts.
- Require authenticated identity for sensitive actions.
- Add loop detection, retry limits, and cost ceilings.
- Use circuit breakers when failure rates climb.
Phase 3: Serve agents properly
- Publish structured, machine-readable policies.
- Create dedicated agent endpoints for common intents.
- Return explicit success, denial, appeal, and timeout states.
- Write an AOP for every high-value workflow.
- Connect agent observability to your dispute and fraud systems.
Phase 4: Monetize and differentiate
- Offer premium agent tiers with higher limits and faster resolution.
- Charge for high-cost intents, priority processing, or guaranteed service levels.
- Use verified agent reputation to unlock better terms.
- Let trusted agents handle more of the journey, while keeping irreversible actions under tighter control.
The strategic reframe
The winners won’t be the companies that block all automation. They’ll be the ones that make automation legible, bounded, authenticated, and economically sustainable.
The next big customer-experience challenge isn’t making humans feel understood. It’s making sure machines understand the rules before they start negotiating.