The Platform PM
Primitive 06

Interfaces and standards

What format and protocol do counterparties speak?

Regulated industries talk to each other through standards that predate your product and will outlive it. Learn which ones carry the money and the data, and you'll know where the integration work and the partner dependencies live.

What it is

Interfaces are how organizations exchange data and instructions: file formats, message standards, APIs and network protocols, usually set by an industry body or a regulator. You rarely get to choose them.

The standard decides what can even be expressed. A field the standard doesn't have is a feature you can't build without a workaround.

Where you'll see it

IndustryStandards in the path
PaymentsISO 20022 messages, card network formats, NACHA files for US bank transfers
HealthcareHL7 FHIR, X12 claim transactions
TelcoE.164 numbering, SMPP, SIP, RCS Universal Profile
LegalLEDES e-billing files
PayrollTax agency filing formats, bank payment files

Questions to ask in week one

  1. Which standards do we send and receive, and who sets them?
  2. Which version are we on, and who forces upgrades?
  3. Where do we translate between our model and the standard's, and what gets lost?
  4. Is the exchange real-time, batch files or both?
  5. What happens when a counterparty reads the standard differently than we do?

The trap

Treating a standard as a spec everyone implements the same way. Every counterparty speaks its own dialect, and most of the integration work lives in the differences, not in the standard.

In the Field Guides

AI agents: orchestration platforms

Tool calling works the same way at all three API labs. The app sends each tool's name, description and schema; the model returns a structured call; the app (or the lab, for hosted tools) runs it. The model never executes anything. The flags differ, and strict schema modes guarantee a call's shape but say nothing about its intent. OpenAI suggests fewer than 20 functions per turn. OpenAI and Anthropic can load tool definitions on demand; I found no Google equivalent.

MCP

What it covers
Agent to tools and data
Status (Oct 2026)
Spec of 2026-07-28; registry in preview
Governed by
Agentic AI Foundation (Linux Foundation) since 2025-12-09

A2A

What it covers
Agent to agent tasks
Status (Oct 2026)
v1.0.0 since 2026-03-12
Governed by
Same foundation since August 2026

AuthZEN profiles

What it covers
Per-action and MCP tool authorization
Status (Oct 2026)
Drafts, 2026-06-15
Governed by
OpenID Foundation

OpenTelemetry GenAI

What it covers
Traces of agents, models, tools
Status (Oct 2026)
Every attribute "Development"
Governed by
OpenTelemetry

AP2; ACP

What it covers
Agent payments; checkout
Status (Oct 2026)
AP2 v0.2 (2026-04-28); ACP since 2025-09-29
Governed by
FIDO Alliance; OpenAI and Stripe

MCP connects a host application to tool servers, local or remote. Its dated versions tell the security story: OAuth 2.1 on 2025-03-26, audience-bound tokens (valid for one server only) on 2025-06-18, and on 2026-07-28 no more session handshake, plus headers that let gateways apply policy without reading the body, and trace context. Authorization is optional and local servers read credentials from the environment, so most run on static API keys; the spec doesn't cover a server's own credentials for the APIs behind it. Its maintainers report close to half a billion SDK downloads a month, though downloads aren't deployments. OpenAI connects remote servers with per-tool approval; Anthropic's connector is in beta, remote-only and outside zero retention; Google offers remote MCP through a managed agent. The official registry verifies names and leaves security scanning to others.

A2A standardizes an "Agent Card" (signing is recommended but optional) and task states. Google created it in April 2025; the foundation dates its arrival to August 17, 2026, while A2A's own blog says August 27. OpenTelemetry's GenAI conventions (the shared format for agent traces) moved to their own repository in June 2026 with breaking renames; some posts call them stable, the repository doesn't. Ask any "OTel-native" vendor which version they mean.

MCP and A2A have settled the wire. Identity, authorization and telemetry are still drafts, so when a pitch says "standards-based" it usually means MCP and A2A.

AI coding agents: writing, reviewing and shipping code

Git and the pull request are the universal hand-off, and GitHub Actions is the closest thing to a standard CI interface (Cursor's Origin runs Actions workflows). AGENTS.md, a plain file of instructions for agents stewarded by the Agentic AI Foundation under the Linux Foundation, says more than 60,000 open-source projects use it, and Codex, Jules, Gemini CLI, Copilot, Cursor and Devin all read it; Claude Code reads its own CLAUDE.md, and AGENTS.md if present. MCP, the protocol agents use to reach tools, is covered in AI agents: orchestration platforms.

NeedWhat exists (Oct 2026)Gap
Marking AI-written changes"Assisted-by:" (Linux kernel), "Co-authored-by:" trailers (vendor practice)No cross-vendor standard
Production context for agentsOpenTelemetry traces (Bluebox is built on it), MCP servers from Sentry and othersEach observability vendor claims the loop
Supply chainTrusted publishing with OIDC (short-lived tokens instead of stored ones), SLSA provenance, SBOMs, minimum release age in package managersAgents pick dependencies faster than people check them

AI evals and observability: how teams measure AI quality

Tracing is closer to portable than evals. OpenTelemetry's AI conventions define spans for model calls, agent runs and tool calls, plus an event to carry an evaluator's score; they're still in "Development", so vendors fill gaps with their own SDKs or Arize's related spec, OpenInference.

Evals have no shared format: Promptfoo's YAML files, Inspect's Python tasks, Google ADK's evalset JSON and Braintrust's experiments don't move cleanly between tools, so lock-in sits in the eval history more than in the traces. Gates plug in through CI: Braintrust's GitHub Action can block a merge when a score falls below a threshold, and Promptfoo's has a fail-on-threshold setting. Inspect, from the UK AI Security Institute, is the closest thing to a neutral runner, and batch APIs at OpenAI, Anthropic and Google halve token prices for runs that can wait, which covers most nightly suites.

Labs disagree on how to grade agents. Anthropic grades the outcome (did the refund land, did the tests pass) so a valid path nobody anticipated isn't punished. Google's ADK scores tool calls against an expected sequence, with an exact-match default, which suits regression tests and penalises creativity. OpenAI's trace grading sits between, scoring whole traces against criteria.

AI governance and model risk

StandardWhat it isWho asks for it
NIST AI RMF and its generative AI profile (2024)Voluntary US framework; inventory is GOVERN 1.6; under revision, no 2.0 by October 2026US buyers and regulators, as shared language
ISO/IEC 42001Certifiable AI management systemEnterprise procurement
ISO/IEC 42005 and 42006 (2025)Guidance for impact assessments; rules for the bodies that certify to 42001Assessment teams; buyers checking a certificate
CSA AI-CAIQ and STAR for AIA standard AI questionnaire; Level 1 self-assessed, Level 2 validated and requiring 42001 (from November 20, 2025)Enterprise buyers
SIG questionnaireShared Assessments' vendor questionnaire: 128 questions (Lite), 627 (Core), 1,936 (Detail)Enterprise buyers
SOC 2No AI-specific criteria found by October 2026; AI systems are scoped into ordinary reportsEnterprise buyers
NYC bias auditImpact ratios by sex, race and ethnicity, and their intersectionsNYC employers
EU code on marking AI content (June 10, 2026)Voluntary layered marking, such as metadata plus a watermark, and a common EU iconEU regulators

The interface that matters most is the crosswalk between frameworks (NIST publishes one to ISO/IEC 23894), and vendors sell "map once, comply many". Questionnaires still travel as spreadsheets and portal forms. Model cards, labs' system cards and the EU's technical file describe a model, and none of them is a validation report.

Agent identity and delegated access: how AI agents act for people

StandardWhat it does for agentsStatus (Oct 2026)
OAuth 2.1The base MCP builds onInternet-Draft 16 (September 2026); MCP still cites draft 13
Token exchange (RFC 8693)Acting for someone; the agent in the act claimStandard since 2020
Rich Authorization Requests (RFC 9396)Describing one action for consentStandard since 2023
CIBA Core 1.0Approval on the person's phoneOpenID Final, 2021
DPoP (RFC 9449), mutual-TLS tokens (RFC 8705)Binding a token to its holderStandards; DPoP in MCP is still a proposal
Protected Resource Metadata (RFC 9728)Pointing an agent to the authorization serverStandard since April 2025; MCP requires it
Client ID Metadata DocumentA client ID that describes the clientWorking-group draft 02 (July 2026)
ID-JAGThe assertion behind Cross App AccessWorking-group draft 04 (May 21, 2026)
HTTP Message Signatures (RFC 9421)The signature under Web Bot AuthStandard since 2024
Web Bot AuthAgents signing requestsWorking-group draft dated September 1, 2026
GNAP (RFC 9635)An alternative to OAuth grantsStandard since 2024; no agent product uses it that I found
MCP authorizationOAuth between agent apps and tool serversSpec version of July 28, 2026; optional

The underlying standards are old enough to rely on. Everything specific to agents is a draft, and a handful of people at Okta, Ping Identity, AWS, Cloudflare, Google, OpenAI and a small workload-identity startup write most of them. Drafts move: ID-JAG must be renewed by November 22, 2026, and Web Bot Auth is months behind its own charter. An individual draft that would have added an agent field to OAuth requests expired without being adopted, so there's still no standard way to say who really did something.

B2B payments: cross-border payouts

A payout platform speaks four families of standards, most of them behind a partner's API.

  • Swift, in ISO 20022 since coexistence with MT ended on November 22, 2025. pacs.008 carries the customer transfer (formerly the MT103), pacs.009 COV the cover between banks, camt.056 a cancellation request, pacs.004 a return. The charge field says OUR (the sender pays every charge), SHA (each side pays its own bank; intermediaries may deduct) or BEN (the beneficiary pays, out of the principal). Every gpi payment carries a 36-character UETR.
  • Local rails, through partners: CLABE plus RFC or CURP for SPEI; Pix keys; account, IFSC and purpose code in India; account or wallet in the Philippines; sort code and account in the UK; IBAN for SEPA.
  • Card pushes: network messages based on ISO 8583.
  • Government formats, the real payroll interfaces: Mexico's CFDI payroll complement; Brazil's FGTS Digital, which takes the 8% severance-fund deposit only by Pix; India's Form 143 (since April 1, 2026); the UK's Full Payment Submission by payday.

Where payee data breaks

  1. Onboarding takes one address line. From November 14, 2026, Swift stops accepting fully unstructured addresses (town and country need their own tags), and non-compliant messages "may be rejected or delayed".
  2. A partner strips or truncates structured fields.
  3. The purpose code is missing or wrong. In India it decides whether a receipt is a services export or a salary.
  4. The tax ID the rail now wants was never collected: RFC or CURP on SPEI, phased in by February 23, 2026.

Swift's Payment Pre-validation (2021) checks the account and format before sending; nobody publishes how widely it's used. Swift itself can now carry structured data end to end, so the failures tend to come from your own onboarding form or a partner's API.

B2B payments: order to cash

The standards mostly exist, but the data often still doesn't arrive.

  • Order to invoice: ASC X12 sets 850 (purchase order), 855 (acknowledgment), 856 (ship notice), 810 (invoice), 812 (credit or debit adjustment) and 824 (application advice, often a rejection), alongside payer portals, emailed PDFs and e-invoicing networks. A US e-invoice exchange framework went market-ready in 2023; I found no US or Canadian B2B e-invoicing mandate (October 2026).
  • ACH: CCD+ carries one 80-character addenda field; CTX up to 9,999 addenda records, enough for an X12 820 (the EDI remittance advice).
  • Wires and instant payments: ISO 20022 on Fedwire (since July 2025), RTP, FedNow and Canada's Lynx (since November 2025). Providers report RTP's free-text remittance field at 140 characters.
  • Everything else: check stubs and X9 image files; Level 2 and 3 card data; BAI2, camt.053 and lockbox files from banks; a different API for every ERP. Canada's AFT is to gain ISO 20022, no date.

Remittance gets lost in four places: at the payer, whose AP team emails it to a generic inbox; at origination, where the payer's bank portal offers a short free-text field; at the receiving bank, which doesn't report addenda unless asked; and at aggregation, when one payment covers fifty invoices and the file comes days later.

The rails can carry the data, so the product fix belongs at those same edges: payer portals, inbox parsing, full addenda reporting from the bank, and clean order and delivery data so the invoice is accepted first time.

B2B payments: procure to pay

AP speaks four families of standards, and the buyer picks which ones its suppliers must use.

  • Orders and invoices: X12 850 (purchase order), 856 (ship notice) and 810 (invoice); UBL invoices on Peppol; the DBNAlliance exchange framework; emailed PDFs; supplier portals; and, for US federal suppliers, the Treasury's free Invoice Processing Platform.
  • Payment instructions to the bank: Nacha files (CCD, CCD+, CTX); ISO 20022 pain.001, with pain.002 status reports back; check-print files plus Positive Pay issue files; card APIs and Visa straight-through messages; the CPA-005 file for Canadian AFT.
  • Remittance: X12 820, CTX addenda, email or portal advices, and the ISO 20022 remittance model the Business Payments Coalition published in 2024.
  • Bank reporting: BAI2, camt.053 and camt.054.

EDI (electronic data interchange) is still how large North American trading partners swap invoices. Ardent says the average organization can take electronic invoices from just over half its suppliers, but that counts a PDF by email that someone scans.

Where payment details get lost

  1. Split channels. AP sends the money through the bank and the remittance by email, often to a generic inbox.
  2. The bank portal truncates it to a short text field, even when the rail carries thousands of characters.
  3. Empty fields. The ERP doesn't fill them: CTX can carry a full 820, if AP's system builds one.
  4. One payment, many invoices. Batching makes remittance long, and long remittance gets dropped first.

Picture a distributor paying 40 invoices from one supplier in a single ACH credit, with "March invoices" typed into the bank portal's short text field. The supplier sees one lump sum and has to call, or guess, to match it to 40 invoices.

So on the buyer's side remittance is a choice. The rails can carry it, and AP decides whether to fill the fields, which is where the seller's cash-application problem starts.

B2B payments: real-time payments and open banking

RTP and FedNow speak ISO 20022:

PurposeMessage
Move the moneypacs.008, the only message that settles
Statuspacs.002
Ask for payment, and the answerpain.013, pain.014
Ask for money back, and the answercamt.056, camt.029
Returnpacs.004 (FedNow); a new payment (RTP)
Remittance sent separatelyremt.001 (RTP)
Move liquidity between bank accountspacs.009 (FedNow)

Pix, SEPA Instant and Australia's NPP use it too; UPI and Faster Payments run on older formats.

Remittance is where the standard earns its keep. The Fed's launch-era guidance says FedNow accepts up to 4,000 characters of structured remittance, where an ACH CCD+ payment carries 80. In practice data gets lost at the payer's bank portal, which may offer only a short free-text field.

Open banking has a standard per region: FDX in the US (recognized by the CFPB on January 8, 2025), the Open Banking standard in the UK, the Berlin Group's and STET's in the EU, Open Finance Brasil, and India's Account Aggregator specifications.

B2B payments: spend management

A spend platform speaks four families of standards.

  • Authorization: ISO 8583 messages through the issuer processor, turned into webhooks the platform must answer in seconds; just-in-time funding moves the company's money at the same moment.
  • Merchant data: category codes (ISO 18245, though each network keeps its own list), 25-character names, and Level 2 and 3 data (tax, then line items), which only the merchant can send. In the US, Level II no longer earns a lower rate except on fuel, and Level 3 counts only once Visa validates it.
  • Bank card files for outside software: Visa Commercial Format (VCF 4.x) or Mastercard's CDF3, sent by SFTP once the company authorizes its bank. One Canadian bank charges around a thousand dollars to set it up plus a fraction of a dollar per transaction.
  • Out to finance: ERP journals through accounting APIs, payroll files, and Nacha PPD files for reimbursements. Since March 20, 2026, Nacha wants wage credits labeled "PAYROLL"; reimbursements aren't wages, so banks advise a different description.

Accounting APIs now cost money: trade press reports two accounting vendors started charging for access in 2025 and 2026.

Where the receipt gets lost

  1. The rail doesn't carry it. An authorization has an amount, a merchant and a code. Items and purpose aren't in it.
  2. The bank file comes late. A bank card reaches expense software as a daily file after clearing. A platform that sees each authorization can, I'd infer, ask for the receipt while the employee is still at the counter.
  3. The names don't match. The receipt shows a trading name; the card shows a 25-character descriptor, sometimes behind a payment facilitator's prefix.
  4. Line items are optional, and patchy in travel. I found no e-receipt standard with real adoption in North America.

Card rails move money and the merchant's identity and say nothing about why something was bought, so the product has to bridge from authorization data to a receipt and a GL code.

B2B payments: stablecoins and blockchain payments

A stablecoin product speaks token standards that differ by chain (ERC-20 on Ethereum, SPL on Solana, TRC-20 on Tron, TIP-20 on Tempo), issuers' APIs such as Circle Mint, Circle's Cross-Chain Transfer Protocol (CCTP), which burns USDC on one chain and mints it on another, and several Travel Rule protocols. ISO 20022 appears only on the bank legs; I found no mapping for coin transfers.

The gap that matters most to a B2B product is the invoice reference. A plain transfer on Ethereum carries an address and an amount and nothing else. Tempo has a 32-byte memo and Stellar and Solana have memo fields, but in practice remittance data travels in the orchestrator's API, an email or a portal.

The other trap is look-alike coins. A coin bridged by a third party is a different asset from the issuer's own coin on that chain, even when the wallet shows the same name; Stripe's docs name a bridged form of USDC on Tempo. I'd accept only the issuer's native token on the chain named in the payment instructions. And no standard exists for telling a holder its coins were frozen: holders find out when a transfer fails.

Card issuing: launching a card program

A program touches more standards than it builds against directly.

  • Messages. Networks and processors talk ISO 8583; the program usually sees the processor's own webhooks and API, covered in the later guide on authorization.
  • Chip and contactless. EMVCo's specifications, which the card maker and processor implement.
  • Card data security. PCI DSS v4.0.1 applies to anyone who stores, processes or could touch a full card number. Card-issuing platforms show the number inside their own hosted frames, so the program's servers never see it; support tools, logs and push-provisioning payloads can still pull you into scope.
  • Card production. PCI's Card Production and Provisioning standard, physical and logical. Visa requires manufacturers, personalizers and fulfilment vendors to be Visa-approved and listed on its registry of service providers.
  • Tokens. EMV Payment Tokenisation, run by Visa Token Service and Mastercard MDES. In the US, Visa requires its token service for card-absent use on consumer BINs, and an "Active" issuer must keep a monthly token provisioning approval rate of at least 90% per BIN.

Interchange depends on interfaces too. The rate a transaction qualifies for depends on data in the authorization and clearing messages, such as whether the card was present or tokenized, so a processor that drops a field can cost the program interchange.

Cloud security (CNAPP): posture, workloads and permissions

The findings side is converging on a few shared formats:

  • OCSF (the Open Cybersecurity Schema Framework) is the format for AWS's new Security Hub findings and for partner findings sold through Security Hub Extended. Shared formats make it cheaper to swap one tool for another, and they make whoever collects everyone's findings more valuable.
  • CVE, CVSS, EPSS and KEV describe vulnerabilities: CVE names one, CVSS scores its severity, EPSS estimates how likely it is to be exploited, and KEV is CISA's catalog of vulnerabilities known to be exploited.
  • CIS benchmarks define configuration checks, and MITRE ATT&CK names attacker techniques; GuardDuty maps its attack sequences to it.

The rest is plumbing: cross-account roles for reading, Jira, ServiceNow and Slack for ownership, Git for pull requests. The newest piece is MCP, the protocol AI agents use to call tools: Wiz offers its remediation agent over MCP, and Google's Model Armor screens MCP tool calls.

Identity and trust: KYB, KYC and ongoing monitoring

The standards are a patchwork, and most of them sit behind a vendor's API.

  • Registries. Companies House offers a free API (600 requests every five minutes) and a streaming API that pushes changes as they happen; it's the cheapest major registry to build on. Corporations Canada has an API and open data. Most US states offer web search pages, some bulk data and per-lookup fees, so vendors scrape or license.
  • Tax IDs. IRS TIN Matching takes up to 25 pairs at once interactively or 100,000 in bulk, but only for payers who file 1099s.
  • SSNs. SSA's eCBSV answers yes or no on SSN, name and date of birth, with the person's consent.
  • Documents. ICAO 9303 for passports (the machine-readable zone and the chip), the barcode on the back of US driver's licences, ISO/IEC 18013-5 and 18013-7 for mobile driver's licences in person and online.
  • Liveness. ISO/IEC 30107-3 tests presentation attacks: a mask, a printout or a screen held to the camera. Injection attacks, where a fake video feed replaces the camera, are a separate problem with a newer standard. Web capture is easier to inject into than a mobile SDK. A "certified liveness" check usually means it resists masks and printouts and says nothing about faked camera feeds, so ask which attacks it was tested against.
  • Identity levels. NIST SP 800-63-4 (August 2025) for US government, not binding on fintechs but marketed to; eIDAS's "substantial" and "high" in the EU.
  • Codes. MCC (ISO 18245, the card networks' merchant category) and NAICS (the government's industry codes) don't map one to one; a new NAICS version is proposed for data from January 2027.

Login and access for apps: authentication and authorization

StandardWhat it's forStatus (Oct 2026)
OpenID Connect Core 1.0Sign-in on top of OAuthFinal
SAML 2.0Enterprise SSOOASIS standard since 2005
SCIM 2.0Provisioning users and groupsIETF standard since 2015
OAuth security best practice (RFC 9700)PKCE for every public client, no implicit or password grants, exact redirect matchingBest current practice since January 2025
OAuth 2.1OAuth 2.0 and its best practice in one documentInternet-Draft, version 16 (September 2026)
WebAuthn Level 3Passkeys in browsersW3C Recommendation, August 2026
Device authorization (RFC 8628)Sign-in for command-line tools and TVsStandard since 2019
Token exchange (RFC 8693)A service acting for a userStandard since 2020
AuthZEN Authorization API 1.0One request shape for permission checks across enginesOpenID Final, January 2026
MCP authorizationOAuth between AI clients and tool serversSpec version of July 28, 2026; optional; built on the OAuth 2.1 draft

The mature standards cover sign-in and provisioning; the ones for machines, agents and authorization are newer, and several are drafts (the MCP specification still cites version 13 of the OAuth 2.1 draft while the IETF is on 16). SCIM says nothing about revoking sessions, which is the gap behind lingering access, and SAML's XML signature layer, where the ruby-saml bugs sat, is the riskiest part to build.

Models and inference: what AI runs on

OpenAI's Chat Completions and Responses formats are the de facto interface: Bedrock exposes them ("change the base URL and API key"), most inference providers do, and Anthropic runs an OpenAI-compatible endpoint next to its own Messages API. That makes switching mechanically cheap. Everything around the call is unstandardized: usage fields, rate-limit headers, deprecation metadata and reasoning controls differ per provider. Tokenizers differ too, so the same text can be about 30-35% more tokens on Anthropic's newest models than on its older ones.

Measurement is its own layer. Artificial Analysis measures time to the first token and output speed from one server over 72 hours, MLPerf audits hardware results that vendors submit, and SemiAnalysis's InferenceX turns benchmarks into cost per million tokens. Model makers have started checking hosts: Moonshot publishes a Kimi Vendor Verifier and OpenAI added a compatibility test for gpt-oss. Below the token the units change again: GPU-hours for renting chips, gigawatts of power capacity for compute deals, and megawatt-days in power markets.

Observability: metrics, logs and traces

The collection side is now mostly standard:

  • OTLP, OpenTelemetry's protocol for sending traces, metrics and logs, is stable and accepted by every major vendor.
  • W3C Trace Context is the traceparent header that carries a trace ID between services.
  • Semantic conventions name attributes the same way everywhere (HTTP stable since 2023, databases since 2025, AI still in development).
  • Prometheus exposition format and PromQL are the de facto standard for metrics and the closest thing to a common query language; many backends accept PromQL.

The storage and query side has no standard. Logs and traces are queried in each vendor's language: LogQL and TraceQL at Grafana, SPL at Splunk, KQL at Microsoft, ES|QL at Elastic, DQL at Dynatrace, Datadog's own syntax, SQL on ClickHouse. Dashboards and alert rules are written in these languages, which is why they don't port.

Every major vendor now ships its own OpenTelemetry distribution, and the distributions recreate some lock-in. Splunk gives official support only for its own and "best-effort" support upstream. Datadog's wasn't FedRAMP or FIPS compliant when the research was done, which steers government buyers back to the proprietary agent. Tail sampling is "often tied to a specific vendor", in OpenTelemetry's own words. Datadog's FY2025 annual report doesn't mention OpenTelemetry at all; it sells "a single agent" with over 1,000 integrations. Its price list charges $0.50 per GB for spans ingested over OTLP against $0.10 for its own APM ingestion, and application metrics sent through OpenTelemetry generally count as custom metrics.

Vendors are also giving their collection technology away, which is what you do once collection stops being where you make money: Elastic donated its eBPF profiler and Grafana its Beyla. For AI, two newer interfaces matter. MCP lets AI agents query observability tools, and Datadog said MCP tool calls grew more than 22-fold from late 2025 to mid-2026 (company figure). GitHub issues and pull requests are the hand-off between observability AI and coding agents.

Phone numbers, messaging and voice

The standards are old, every provider speaks its own dialect, and the signal you want is often missing.

  • Numbers. E.164, and in the NANP the NPA-NXX-XXXX format (area code, exchange, line). Mobile and landline numbers share area codes, so you need a lookup to know the line type.
  • Messaging. Platforms reach aggregators over SMPP (the SMS industry's binding protocol) or HTTP. Billing counts segments (the parts a long SMS gets split into), and every provider has its own error codes.
  • Porting. An LSR (local service request) goes to the losing carrier, an FOC (firm order commitment, the agreed date) comes back, and the NPAC record flips. A simple port may be validated on just four fields: number, account number, ZIP code and passcode.
  • Caller identity. STIR/SHAKEN (ATIS-1000074) signs each call. "A" means the signer knows the customer and checked its right to the number; "B", it knows the customer but not the number; "C", it's passing on traffic it didn't originate. Since September 18, 2025 a provider must sign with its own SPC token (the credential iconectiv issues to eligible providers). Since March 25, 2026 a terminating provider that blocks on analytics has to say so with SIP code 603+.
  • 911. NG911 carries calls over SIP, with location inside the signaling as PIDF-LO (a standard location object).
  • RCS. GSMA's Universal Profile (4.0 finalized March 2026). Google's API returns 404 when it can't reach a user; fallback is your job.
  • WhatsApp. Cloud API only, since the On-Premises API ended October 23, 2025. Webhooks carry business-scoped user IDs, which you've had to support since April 2026. Embedded Signup v2 is deprecated on October 15, 2026.

An A attestation only tells you who signed the call and what they know about the caller; it says nothing about whether the call is wanted or legal.

Voice AI: real-time voice agents

The phone side is standardized: SIP for setting up and transferring calls, RTP and SRTP for the audio, G.711 at 8 kHz on the phone network, Opus in apps, E.164 numbers, STIR/SHAKEN for caller ID, and DTMF for keypad tones. The AI side has no shared standard. Every platform has its own WebSocket event protocol (Twilio's media streams, OpenAI's Realtime events, Google's Live messages, Deepgram's turn events), and nothing covers turn events, barge-in or tool calls across vendors. That's a lock-in point, and the reason open frameworks like Pipecat and LiveKit's agents exist.

WebRTC

Typical use
A browser or app talking to a model or platform
Strengths
Built for live audio: handles loss, jitter and echo; OpenAI's recommended client path
Weaknesses
Needs media servers and network traversal

WebSocket media stream

Typical use
A communications platform sending call audio to your server
Strengths
Simple, works everywhere
Weaknesses
Lost packets stall the stream; you handle buffering and barge-in

SIP trunk to a platform or model

Typical use
Phone numbers into LiveKit, OpenAI or a voice platform
Strengths
Fewer hops; native transfers; carrier-grade
Weaknesses
You still need a trunk provider; caller ID can change on transfer

The phone network end to end

Typical use
Any phone
Strengths
Reaches everyone
Weaknesses
8 kHz audio, extra delay, spam labels and blocking

OpenAI now accepts SIP calls directly, with a separate EU endpoint, and warns builders not to retry an outbound call automatically after an ambiguous timeout, because the retry can place a second call. For provenance, Google's SynthID and Meta's AudioSeal watermark synthetic audio and C2PA labels files, but a watermark only marks the provider's own output, and phone audio degrades it.

Field Guides are learning notes, not legal or compliance advice. Rules and fees change; check the cited primary sources before you act on anything here.