AI agents are starting to make phone calls for people. They book a table, reschedule a dentist appointment, or chase a delivery. Most businesses still have no API, but they all have a phone number, so the agent calls it.
For the network this is a strange caller. The call shows your number, but you are not on it. STIR/SHAKEN only proves the call is allowed to use that number. It says nothing about who is actually talking, or what they are allowed to do.
Jon Peterson, one of the original STIR authors, just published an Internet-Draft for this: Secure Telephone Identity for Agents (draft-peterson-stir-agentic-00). It is an individual -00 draft from November 2026, so it is an early proposal, not a standard. I read it twice and liked it more the second time. Below I go through what it proposes, draw the flows, and then list what I think is missing, looking at it as someone who spends most days in SIP traces.
A 1-minute STIR recap
If you have not worked with STIR:
- The originating side signs every call with a certificate that proves it may use the calling number (RFC 8226).
- The signed token is a PASSporT (RFC 8225), a JWT carried in the SIP
Identityheader (RFC 8224). It holdsorig(calling number),dest(called number) andiat(time). - The terminating side checks the signature and decides what to do with the call.
- Rich Call Data (RFC 9795) adds display info to the PASSporT: a name (
nam), a logo, and a call reason (crn).
STIR always allowed “legitimate impersonation”. A call center presents a bank’s number. A doctor calls from the clinic’s main line. Delegate certificates (RFC 9060) let a number holder authorize someone else to sign for its numbers. The draft’s starting point is that an AI agent is just the newest case of this pattern.
The problem the draft solves
Today, when an agent places a call using your number, the called party sees a normal call from you. They cannot tell:
- that an agent is calling, not you;
- which agent it is;
- what you actually told it to do.
The call reason (crn) does not help much. It is free text written by whoever signs the call, so nothing can check it against what the agent does.
The draft adds two PASSporT claims to fix this. One says who is acting. The other carries signed proof of what you authorized.
Claim 1: act, “an agent is calling for this number”
The act claim comes from OAuth Token Exchange (RFC 8693). That RFC separates two ways one party can act for another:
- Impersonation: the actor is invisible, and relying parties only see the subject.
- Delegation: the subject stays the same, and the actor is named in an
actclaim.
STIR today is effectively impersonation. A call center call looks exactly like the enterprise calling. The draft adopts delegation for agents:
act.submust be a URI that identifies the agent. An HTTPS URI that points to a description of the agent (for example an A2A Agent Card) is recommended.- It should name a specific agent or agent service, not just “some AI company”.
actcan be nested for agent-of-agent chains. The outermost one is the current actor.
Note what act does not prove. It only says which agent claims to be acting. It says nothing about who runs it, whether it is benign, or whether it is authorized. That is the job of the second claim.
Making disclosure mandatory
Nothing at the protocol level can force an agent to say it is an agent. The draft gives the number holder a lever, though. When a carrier or enterprise issues a delegate certificate to an agent platform, it can put act in the certificate’s JWT Claim Constraints as mustInclude (RFC 8226 and RFC 9118). Any PASSporT signed with that certificate must then carry an act claim, or it fails verification.
So the number owner decides whether its agents must say they are agents. I like this part a lot, mostly because it is boring: the constraint mechanism has been in STIR certificates for years, and here it finally gets a good job.
What a human sees
act is for machines. For people, the draft says the signer should also add Rich Call Data, for example nam: "Alice (agent)", plus a call reason. A phone that supports RCD but knows nothing about this draft can still show “Alice (agent)” and “Order: 1 large pizza”. A phone with no RCD support at all just gets a normal call.
Claim 2: intent, “here is what I authorized”
The intent claim is an array of entries:
| member | meaning |
|---|---|
typ |
intent type, from a new IANA registry |
val |
the intent object, inline |
uri |
HTTPS URL to fetch the intent object |
dig |
digest of the object (same format as RCD’s rcdi) |
Each entry has either val or uri. A call can carry several entries, for example a coarse one for quick triage and a full payment mandate next to it. A verifier uses the types it knows and ignores the rest.
Here is the example payload from the draft:
|
|
Neither STIR nor the agent signs the intent object. An intent authority does. That could be the user, an OAuth authorization server, a wallet, or a payment network. STIR does not define new trust anchors for these. It reuses trust that already exists: a pizza shop’s point-of-sale system already trusts its payment network, so it can check a mandate that network signed.
The trust model
Three parties sign things, and the one in the middle signs nothing:
graph LR
U["User (principal)"] -- "1. order a pizza" --> A["Agent platform (untrusted)"]
A -- "2. draft intent" --> IA["Intent authority: wallet, OAuth AS, payment network"]
IA -- "3. fixed rendering" --> U
U -- "4. approve" --> IA
IA -- "5. signed intent" --> A
C["Number holder / carrier"] -- "delegate cert, mustInclude act" --> AS["STIR authentication service"]
A -- "6. INVITE + intent ref" --> AS
AS -- "7. signed PASSporT" --> VS["Verification service"]
VS --> IV["Intent verifier, e.g. shop POS"]
IV -- "fetch intent by uri" --> IA
The draft says it plainly: the agent platform is trusted by no one. It carries a PASSporT it cannot forge and an intent object it cannot forge.
Binding the two together
Two signatures from two different worlds are only useful if each one is tied to the other. Otherwise a dishonest platform could take a real mandate and stick it on a scam call. The draft binds them in both directions.
From intent to call: the intent object lists, under the intent authority’s signature, which calling numbers it covers (and optionally which called numbers). It also has a validity period, a unique ID, and can limit how many calls it covers. The verifier checks that the PASSporT’s orig and dest are in that list.
From call to intent: the STIR signer puts the digest of the intent object in the PASSporT and signs it. Now a verifier that fetches the object by URL knows it is the object that came with this call, not just any object from the same authority.
One subtle point: the STIR signature over the digest only says “this object came with this call”. It does not say the contents are true, or that the signer checked them. STIR keys keep proving authority over numbers, and intent keys prove authority over intent. Neither side has to understand the other’s credentials, so existing authentication services can carry intent without any change to their certificates.
The call flow
Putting it together for the pizza example:
sequenceDiagram
participant User
participant Agent as Agent platform
participant IA as Intent authority
participant AS as STIR auth service
participant VS as Verification service
participant IV as Intent verifier (POS)
User->>Agent: 1 large, half plain, half onion and olive, pickup
Agent->>IA: draft manifest
IA->>User: fixed rendering of the manifest
User->>IA: approve
IA-->>Agent: signed manifest (numbers, validity, id, max calls)
Agent->>AS: INVITE with act and intent reference
AS->>AS: sign PASSporT incl. act, rcd, crn, intent digest
AS->>VS: INVITE with Identity header
VS->>VS: verify PASSporT as usual
VS->>IV: verified PASSporT
IV->>IA: GET intent uri over HTTPS
IV->>IV: check digest, signature, numbers, time, agent, call reason
Note over IV: verified, unverified or invalid
The person who answers just hears a normal pizza order. The POS system can compare the order with the signed mandate before the payment clears.
Verified, unverified, invalid
The verifier’s steps are simple, but the outcome has three states, not two:
graph TD
S["Verified PASSporT"] --> T{"intent type supported?"}
T -- no --> UN["UNVERIFIED: an agent, intent unknown"]
T -- yes --> R{"object retrieved?"}
R -- no --> UN
R -- yes --> D{"digest matches?"}
D -- no --> INV["INVALID: negative signal"]
D -- yes --> SG{"authority signature valid?"}
SG -- no --> INV
SG -- yes --> TR{"authority trusted by local policy?"}
TR -- no --> UN
TR -- yes --> B{"orig and dest covered, within validity?"}
B -- no --> INV
B -- yes --> AC{"act present and matches the authorized agent?"}
AC -- no --> INV
AC -- yes --> CR{"call reason consistent with intent?"}
CR -- no --> INV
CR -- yes --> OK["VERIFIED"]
- Unverified means “I could not check this”: unknown type, fetch failed, or an authority I do not trust. It carries no signal either way, and the call is treated as a call from an agent whose intent is unknown.
- Invalid means “this was checked and it is wrong”: bad digest, bad signature, wrong numbers, expired, or the agent in
actis not the one the intent authorized. That is either a bug or an attempt to show intent the user never approved, and policy may treat it as a red flag.
Neither result changes the PASSporT verification itself. A call with broken intent is still a validly signed call.
The hardest part: turning words into intent
Section 11 is my favorite part of the draft, because it does not pretend to solve something it cannot.
In practice nobody writes a JSON mandate. You say “order me a pizza”, an LLM turns that into a structured intent object, and at best you tap “confirm”. That translation step cannot be checked by any machine, and the draft says so.
So it is careful about what the intent authority’s signature means. It proves you approved a rendering of the object, not that the object matches what you meant. And that approval only counts if:
- The text you see is generated from the object by fixed rules defined by the intent type, not written by an LLM. Otherwise the agent could show you one thing and sign another.
- You confirm on a system the agent platform does not control, such as your wallet, your phone’s OS, or your payment provider.
It goes one step further. Most of what you want is never said. If you say “order a pizza” and the agent sets a price limit of $30, the agent just wrote part of your intent. So the draft says intent types should mark each constraint by where it came from: stated by you, taken from a standing policy you set, or guessed by the agent. The confirmation screen should point out the guessed ones.
That splits “did the agent behave?” into three separate questions:
| question | who can answer |
|---|---|
| Did the agent follow the intent object? | a machine, mechanically |
| Did the user approve the intent object? | the intent authority’s signature |
| Did the intent object capture what the user meant? | only an audit of the original request |
I think this framing is useful well beyond phone calls.
Other details worth knowing
The same claims work in reverse when an agent answers. With connected identity (RFC 9970), a caller can learn it reached an agent, whose agent it is, and what it may do, for example “can look up your booking but not change it”.
A missing act proves nothing. An agent that wants to hide just leaves it out, unless the number holder forces it with certificate constraints. So no act does not mean a human is calling.
On privacy, act already reveals which services you use, and intent objects can reveal much more. The draft asks intent types to keep their contents small and to support selective disclosure with SD-JWT, so the shop sees the order but not your card. Payment credentials stay out entirely, and reference URLs should be unguessable and short-lived.
Then there is SSRF. On every incoming call, the terminating side fetches a URL that the calling side picked. The draft requires HTTPS only, no private or internal addresses, limited redirects, 200 responses only and a size cap. Anyone who has run a public SIP service knows why that list exists.
Finally, a verifier that wants to support audit or traceback should log its result at call time. It should not count on fetching the PASSporT, certificate or intent object again later.
What I think is missing
This is a -00 draft, so gaps are expected. These are the ones I noticed coming from the SIP and carrier side. They are my opinions, not part of the draft.
1. The base intent type is still TBD
The draft defines the framework and a registry, but says the base intent type is “[TBD]”. Payment mandates such as AP2 and Mastercard Verifiable Intent are expected to register their own types. Without a simple base type, though, the dentist case has nothing to interoperate on. Here is a rough sketch of what a minimal one could hold (my idea, not from the draft):
|
|
2. SIP message size
A PASSporT with full Rich Call Data is already big. Add an inline intent object and the Identity header gets large fast. RFC 3261 section 18.1.1 says a request larger than about 1300 bytes, when the path MTU is unknown, must go over a congestion-controlled transport like TCP, and many SBCs cap header length anyway. I wrote about what happens when SIP over UDP gets too big in SIP and UDP Fragmentation. For SIP, I would like the draft to recommend uri over val.
3. Post-dial delay
Fetching the intent object during INVITE processing adds an HTTPS round trip to call setup. The draft only says verifiers should bound the time. A practical split: check the PASSporT and act before the phone rings, and verify intent in parallel or after answer. The POS in the pizza example only needs the result before the payment clears, not before ringing.
4. How SHAKEN is deployed today
The draft says it works with existing credentials, including SPC certificates (requirement REQ-11). In the US, though, SHAKEN mostly uses certificates that identify the service provider, not the numbers. The mustInclude: act lever only works when the number holder issues a TN-level delegate certificate (RFC 9060, ATIS-1000092), and those are still rare. So in practice “agents must disclose” depends on delegate certificates taking off. There is also no agent signal in the A/B/C attestation levels, so how call analytics should weigh act is still open.
5. TDM drops everything
Many calls still cross a TDM segment somewhere, and the Identity header does not survive it. Unless out-of-band STIR (RFC 8816) is used, act and intent are simply gone on those calls. Another reason a missing act proves nothing.
6. No way to cancel a mandate
If you change your mind after the agent got a signed mandate, the object stays valid until it expires. Short validity windows help. A status check, for example the OAuth Token Status List, would let a verifier see that you revoked it.
7. Nothing covers what is said during the call
Intent is checked once, at call setup. Nothing ties what the agent says after answer to the mandate. If the agent changes the order or accepts an upsell halfway through, only the POS comparing the final order with the mandate would catch it. Confirmation during the call, along the lines of CHEQ, could fill that gap.
8. Messaging is mentioned but not specified
The draft’s definition of an agent includes sending and receiving messages, but everything else is about calls. Agents will text as much as they call, so a profile for STIR for messaging and RCS would make sense.
9. Regulators are already asking for this
In the US, the FCC ruled in February 2024 (FCC 24-17) that AI-generated voices count as “artificial” voices under the TCPA, so these calls need prior consent. A follow-up proposal (FCC 24-84) would require callers to disclose AI-generated calls, and it is still only a proposal. In the EU, Article 50 of the AI Act has applied since 2 August 2026, and it requires people to be told when they are dealing with an AI system.
Today, the usual disclosure is the agent saying “I am an AI assistant” at the start of the call. A signed act claim plus “(agent)” in Rich Call Data would be disclosure that a machine can check and that shows up before anyone answers. Consent could even become its own intent type. The draft does not mention regulation at all, and I think making that link would help it get adopted.
10. Finding an agent-native endpoint
Advertising that a called party can also be reached through an agent protocol (for example “talk to my A2A endpoint instead of calling”) is out of scope. That is fine for this draft, but it is the obvious next step. Two agents talking to each other in synthesized voice over a phone line is not a great use of a voice network.
Wrapping up
What I like most is how little the draft adds to STIR: two claims and one registry. Terminating parties that ignore it lose nothing, and thanks to the two-way binding nobody has to trust the agent platform. The section on LLM translation is also the most honest thing I have read in an agent protocol so far.
I do have mixed feelings about who it helps. Honest agents will send act, and scammers won’t. So the first win is not catching bad calls. It is giving good agent calls a way to stand out, which matters when call analytics are already suspicious of anything automated. That is still worth having, but it is a smaller promise than “solving AI robocalls”.
Most of what is open is deployment work: the base intent type, delegate certificates in SHAKEN, SIP message size and setup delay. Carrier engineers know these problems well, so if you work on STIR or SBCs, read the draft and send comments to the STIR list.
One last thing: the draft’s acknowledgments say it was written with help from an LLM, which seems right for a draft about agents.
Take care and stay safe! ;)
Useful Links
- draft-peterson-stir-agentic-00: Secure Telephone Identity for Agents
- RFC 8224: Authenticated Identity Management in SIP
- RFC 8225: PASSporT
- RFC 8226: STIR Certificates
- RFC 9060: STIR Certificate Delegation
- RFC 9118: Enhanced JWT Claim Constraints for STIR Certificates
- RFC 9795: PASSporT Extension for Rich Call Data
- RFC 8693: OAuth 2.0 Token Exchange
- RFC 8816: STIR Out-of-Band Architecture
- CHEQ: Confirmation of AI Agent Decisions with Human in the Loop