Picture this: a customer’s AI agent calls your business and says, “Cancel my flight and request a refund.” It knows the itinerary. It sounds sure of itself. It may even have the right account details.
The question isn’t whether the agent can talk to your support system anymore. It’s whether you can prove which agent is calling, which customer it represents, and exactly what that customer authorized it to do.
That’s the gap Decagon is going after with its Personal Agent Consent & Trust Protocol, or PACT, and its Personal Agent Gateway. Decagon doesn’t treat consumer AI agents as one more chat channel. It treats them as a new kind of outside actor, one that needs OAuth-style delegated authorization, scoped permissions, policy enforcement, and an audit trail.
The agent on the other end of the line
Personal AI agents are moving past answering questions and starting to act. They can book travel, change reservations, cancel orders, dispute charges, haggle over refunds, and manage subscriptions for the people they work for.
For consumers, that’s convenience. For businesses, it raises an uncomfortable question: when an agent kicks off a consequential action, who’s accountable?
An agent that can chat with your support system is interesting. An agent that can change a customer’s account without provable consent is a security problem.
And the risk goes beyond impersonation. An agent can also operate with vague, over-broad, or unverified authority, which turns a helpful assistant into an uncontrolled doorway into your systems.
From support automation to attack surface
Most enterprises have spent years locking down their human-facing channels: web, mobile apps, email, contact centers, APIs. Those channels mostly assume a real person is on the other end, logged in and answerable for what they ask.
Personal agents break that assumption.
An agent might start a request while the customer isn’t around. It might read a broad instruction in a way nobody expected. It might ask for credentials, try to do more than it was asked, or run into systems that never had to tell the difference between a customer, a customer’s employee, and a customer’s autonomous agent.
Decagon’s position is that businesses must confirm which customer an agent represents and what it’s allowed to do, and that OAuth already gives us a familiar model for that kind of delegation.
| Traditional customer channel | Personal-agent channel |
|---|---|
| A human customer initiates and confirms the request | An autonomous agent may initiate the request |
| Identity is usually tied to a direct login or verified session | The agent’s identity and the customer’s identity are separate |
| Permissions are implicit in the customer’s account access | Permissions must be explicitly scoped and delegated |
| Actions are generally visible in the customer’s session | Actions need durable, auditable authorization records |
| Support teams handle ambiguity with a human | Policy and escalation controls must work at agent speed |
The big shift is that an agent is not the customer. It’s a delegate acting on the customer’s behalf, and delegates need limits.
What “going rogue” actually means
“Rogue AI” sounds dramatic, but in a B2C setting it points to some very down-to-earth business risks.
| Risk | Example | Business consequence |
|---|---|---|
| Impersonation | An agent claims to represent a customer but cannot prove account ownership | Unauthorized cancellation, disclosure, or account change |
| Over-broad consent | A customer approves “manage my booking,” but the agent treats that as permission to change, cancel, and rebook | Disputes, refunds, and operational disruption |
| Scope creep | An agent begins with a read-only request, then attempts a destructive action | Policy violations and weak auditability |
| Credential exposure | The agent asks the customer for a password or one-time code | Phishing-style compromise and account takeover |
| Untraceable action | A cancellation occurs, but the business cannot show which agent, user, scope, and action caused it | Poor dispute resolution and compliance evidence |
That last one deserves extra attention. If an agent cancels a reservation or asks for a refund, a chat transcript isn’t enough. You need proof of the agent’s identity, the customer’s delegation, the approved scope, the action taken, and what happened as a result.
PACT is built around exactly that. It verifies who the agent is separately from deciding whether that agent may act on a customer’s account.
Enter PACT: OAuth for autonomous agents
PACT stands for Personal Agent Consent & Trust. Decagon open-sourced it, co-developed with Instinct, so businesses have a standard way to verify and authorize personal agents.
The core idea is simple:
PACT doesn’t ask whether an AI agent is trustworthy. It asks whether that specific agent has been authorized by that specific customer to perform that specific action.
It builds on two things that already exist:
- Agent2Agent (A2A): handles agent discovery and communication.
- OAuth 2.0: provides the delegated-authorization model for giving an agent limited access to a customer’s account.
OAuth has solved a similar problem before. When you connect a third-party app to your Google account, you don’t hand over your password. You sign in directly, look at the permissions being requested, and grant a narrow slice of access.
PACT takes that same mental model and applies it to AI agents.

How PACT works
PACT runs a three-step authorization flow.
1. Identify the agent
First, the personal agent finds the business’s A2A Agent Card, which describes the agent endpoint, the authentication requirements, and the permissions on offer.
The agent then authenticates with a short-lived signed JWT, and the provider checks the signature against the agent platform’s published public keys.
That tells you which agent platform is calling. It doesn’t yet tell you which customer the agent speaks for.
2. Authenticate the customer and get consent
Next, the agent asks for specific permissions, called scopes, like orders:read or orders:cancel.
The customer signs in directly with the business using OAuth’s device authorization flow, then picks which permissions to grant.
The important part: the personal agent never sees the customer’s login credentials. The customer authenticates with the business itself, which keeps the agent and the account owner cleanly separated.
3. Act only within the granted permissions
Once authorization is done, every request carries two things:
- The agent’s verified identity
- The customer’s delegated authorization
The provider checks both before letting the business agent run the requested workflow within the approved scopes. If the agent needs more permission later, PACT uses A2A’s authorization-required state to ask for it and pick the same conversation back up.
The provider also returns signed receipts recording which scopes were used and what actions were taken.
Personal agent
|
| 1. Discover A2A Agent Card
v
Business agent endpoint
|
| 2. Agent signs in with short-lived JWT
v
Agent identity verified
|
| 3. Customer signs in directly and selects scopes
v
Customer grants limited delegation
|
| 4. Agent performs only approved action
v
Business executes workflow + issues signed receipt
Permissions become the product

The most important security control isn’t how well the agent talks. It’s the permission model.
A business shouldn’t give an agent “access to the account.” It should give permission to do one narrowly defined thing, under defined conditions.
A few examples:
orders:read: view order status and historyorders:cancel: cancel an eligible orderreservations:view: retrieve booking detailsreservations:modify: change dates or passenger detailssupport:dispute: open a billing disputepayments:refund: request or approve a refund, potentially requiring step-up authentication
Decagon’s Personal Agent Gateway ties these permissions into Agent Operating Procedures, or AOPs. So an enterprise can link each scope to the specific procedures an agent is allowed to use, instead of handing it broad access to the systems underneath.
The right unit of trust isn’t “access to the account.” It’s “permission to perform this narrowly defined action, under these conditions.”
Inside Decagon’s Personal Agent Gateway
PACT defines the authorization protocol. The Personal Agent Gateway is the operational layer that makes it work in production.
The Gateway is built to:
- Detect likely personal agents in live chat and voice interactions.
- Route self-identifying agents through a dedicated channel alongside chat, email, and voice.
- Enforce business policy through Agent Operating Procedures and permission scopes.
- Authorize agent actions using PACT’s identity and delegation model.
- Escalate to humans when a request goes beyond policy, authorization, or confidence thresholds.
In practice, this is zero trust for customer agents. A business shouldn’t assume an agent is legitimate just because it’s persuasive, knows some basic account details, or shows up through a channel that feels familiar.
Every consequential interaction should clear the same five questions:
- Which agent is calling?
- Which verified customer does it represent?
- What did that customer explicitly authorize?
- Is the requested action within business policy?
- Can the enterprise prove all of the above later?
Why OAuth is the right model
The OAuth comparison isn’t just a handy analogy. It’s a sound governance model for agent access.
| OAuth concept | PACT equivalent |
|---|---|
| Third-party app | Personal AI agent |
| Resource owner | Verified customer |
| Authorization server / business | Enterprise and its Decagon-hosted agent provider |
| OAuth scopes | Business-defined action permissions |
| Access token | Short-lived delegation token |
| Consent screen | Customer’s direct sign-in and permission selection |
| Audit trail | Signed receipts of scopes used and actions taken |
Decagon makes the same comparison to connecting an app to a Google account: the business defines the scopes, the customer grants them, and the grant leaves a record of what was authorized.

That gives enterprises something many agent interactions lack today: a clear, auditable line between what the customer wanted, what the agent can do, and what the company actually did.
What enterprises should do now
You don’t have to wait for the agent ecosystem to mature. Start treating personal agents as their own identity and channel class today.
- Publish machine-readable agent capabilities and permission scopes.
- Require direct customer authentication for any delegated account access.
- Separate read, modify, cancel, purchase, and financial-action permissions.
- Apply step-up authentication for high-risk actions like refunds, cancellations, or account changes.
- Log the agent’s identity, the customer’s delegation, the approved scope, the action, the timestamp, and the outcome.
- Plan escalation paths for missing scopes, ambiguous intent, or policy-sensitive requests.
- Never accept customer credentials through the agent itself.
With PACT’s signed receipts and explicit scopes, a business can show not only that an action happened, but which authorization made it possible.
The bigger picture: an interoperable trust layer
PACT isn’t meant to be just a Decagon feature. It’s positioned as an open standard, so agent developers can use one integration pattern across participating providers, and businesses can support many agents through a common interface.
Decagon has also joined the Personal Agent Protocol working group associated with Muse, a sign that it wants the industry to settle on shared norms for agent identity and consent.
That hints at a larger shift. The next platform fight may not be about whose agent is smartest. It may be about whose trust layer lets businesses feel safe saying yes.

Consent is the new API contract
Personal agents could become a powerful customer channel, but only if enterprises keep control over identity, scope, policy, and auditability.
PACT turns a fuzzy conversational request into a verifiable delegation:
This agent, for this customer, may perform this action, within these limits, and with a receipt to prove it.
The question for businesses isn’t whether to serve AI agents. It’s what an agent should be allowed to do on a customer’s behalf, and the answer is to make every permission explicit.