On May 29, 2026, Palo Alto Networks completed its acquisition of Portkey, and the company has since said Portkey will be absorbed into Prisma AIRS, its AI security suite. For teams already running Portkey in production, nothing broke overnight — the gateway still routes, the dashboards still load. But if you're a CTO who chose Portkey deliberately and you're now asking whether it's still the right long-term bet, that's a reasonable question to be asking. This is a buyer's guide to answering it fairly.
Portkey earned its place. It was a strong independent AI gateway — broad provider coverage, semantic caching, a real observability layer, a growing set of guardrails, and one of the more serious bets on MCP in the market. If you're evaluating alternatives, the honest starting point is that you're replacing a good product, not escaping a bad one.
What the acquisition actually changes for a buyer
Three things shift when an independent tool is absorbed into a larger platform. None of them are accusations — they're the normal consequences of a change in ownership, and they're worth weighing openly.
The roadmap now serves a suite strategy. Portkey's roadmap used to answer one question: what makes the best independent AI gateway? Inside Prisma AIRS, the roadmap answers a broader one: what makes the best AI security platform for Palo Alto's enterprise customers? Those goals overlap, but they aren't identical. Features that matter to a standalone gateway buyer may or may not survive prioritization against a security-suite backlog. That's not a prediction of neglect — it's an acknowledgment that the decision-making inputs have changed.
Pricing and positioning are in flux. Post-acquisition, the packaging of a product typically gets re-fit to the acquirer's go-to-market. Where Portkey previously published mid-market tiers, that structure is now being reconciled against Palo Alto's enterprise pricing motion. If you buy through enterprise procurement and already hold a Prisma contract, this may work in your favor. If you don't, it's genuinely uncertain — and uncertainty is a legitimate input to a switching decision.
The neutrality question is now open. Part of what made Portkey attractive was that it was a neutral, multi-provider gateway — it didn't care which model you called. Living inside a security platform doesn't erase that neutrality, but it does mean the product now sits next to a CASB, a SASE, and a DLP stack, and its center of gravity is a security buyer's panel. If you valued Portkey specifically as an independent routing layer, it's fair to re-check whether that independence is still the product's north star.
How to evaluate an alternative
Don't start from vendor names. Start from the criteria that matter for your workloads, then see which tools clear them. Here are the ones worth scoring.
Gateway breadth and routing. How many providers and models, how good the fallback and load-balancing logic, how faithful the wire-level compatibility. This was a Portkey strength, and it's table stakes for any replacement. If pure routing breadth is all you need, pure gateways like LiteLLM (open source, self-hostable) or OpenRouter (a hosted aggregator across 1,900+ models) are honest, focused options — and worth naming, because not everyone needs more than a gateway.
Observability. Traces, latency, token counts, error rates, per-request logs. Portkey did this well; any serious alternative should too. This is where engineering telemetry lives.
Guardrails. PII handling, content filters, prompt-injection defenses. Coverage and enforcement model both matter — a guardrail you can bypass is a suggestion, not a control.
Those three, most mature tools do competently. The criterion the whole category tends to under-serve — Portkey included, and not as a knock on Portkey specifically — is spend control for the finance buyer. Almost every gateway treats cost as something you observe after the fact: a dashboard, a chart, a CSV you export at month-end. Very few treat it as something you enforce before the call. If AI is now a board line item you have to forecast and defend, that gap is the one that actually costs you.
Concretely, spend control breaks into four criteria most evaluations skip:
- Per-key hard budgets enforced before the call. Not an alert after you've overspent — a cap that returns a 402 and never reaches the model once the budget is exhausted.
- Multi-dimension chargeback. Every token reconciled to who, how much, why (project and task), where, and when — exportable to a CSV your controller can actually reconcile to the provider invoice.
- Binding-key identity. The identity of the caller signed into the key envelope and verifiable offline, so attribution survives a leaked key instead of trusting whatever metadata the app happened to set.
- Compliance evidence. A real evidence pack for SOC 2, ISO 27001, ISO 42001, and NIST AI RMF — not a claimed certification, but the collected artifacts an auditor asks for.
The evaluation table
Scored fairly. Portkey's real strengths are marked as strengths; the columns diverge on the spend-control axis, which is where Tokenality is purpose-built rather than uniformly "better."
| Criterion | Portkey (now Prisma AIRS) | Pure gateways (LiteLLM / OpenRouter) | Tokenality | |---|---|---|---| | Gateway breadth / routing | Strong — broad provider coverage, fallbacks | Strong — that's the whole product | Governed proxy: Anthropic native, others proxied, 1,900+ via pass-through | | Observability | Strong — mature traces + logs | Basic (LiteLLM) / minimal (OpenRouter) | Per-request ledger rows, real-time attribution | | Guardrails | Strong — growing guardrail set | Minimal / none | Fail-closed PII pre-flight on the customer path | | Semantic caching | Strong — a Portkey differentiator | LiteLLM has basic caching | Semantic caching with a $-savings frame | | Per-key hard budgets (enforced pre-call) | Rate limits + alerts | Not a focus | Budget signed into the key; 402 before any LLM call | | Five-dimension chargeback (CSV) | Log/cost export | Not a focus | WHO · HOW MUCH · WHY · WHERE · WHEN, reconcilable CSV | | Binding-key second factor | Metadata (trust-the-caller) | Not a focus | Identity signed into the envelope, verified offline | | Compliance evidence pack | Custom queries | Not a focus | Two-click pack: SOC 2 / ISO 27001 / ISO 42001 / NIST AI RMF |
Read that table honestly and the picture is not "one tool wins everything." If you need the deepest routing breadth or the most mature guardrail catalog, Portkey built genuinely strong versions of those, and a focused gateway may be all you need. Where Tokenality is the better answer is a specific axis: when the person who has to defend the AI bill is in Finance, and the requirement is enforceable spend control, per-owner attribution, and audit evidence — not another dashboard to read after the money's gone.
The honest positioning
Tokenality is not trying to be a better gateway than Portkey at gateway things. It's the AI spend control plane — built for the finance-and-audit axis the gateways historically treated as a reporting afterthought. It issues governed Virtual AI Keys, each with a hard budget the gateway enforces before the call, a five-dimension Token Ledger that reconciles every token to an owner, a binding-key second factor so identity survives a leak, and a compliance evidence pack across four frameworks. If your reason for looking is "the acquisition made me re-examine whether cost governance is a first-class part of my stack," that's exactly the axis we're built for.
If your reason is "I just want the routing to keep working and I don't have a finance-governance problem," that's a real answer too — and it might point you at LiteLLM, OpenRouter, or simply staying on Prisma AIRS if you're already a Palo Alto shop. A good buyer's guide should be willing to send you elsewhere.
See spend control before you commit
The fastest way to judge whether enforce-before-the-call spend control is worth switching for is to watch it happen. Try the live playground: set a budget on a key, exhaust it, and see the 402 come back before the model is ever called. That single behavior — a cap that holds instead of an alert that fires too late — is the clearest test of whether an alternative solves the problem the acquisition made you re-open.