Future AGI vs Portkey in 2026: Self-Improving Runtime vs Hosted Gateway

If you are deciding between Future AGI and Portkey today, the short answer is this. Pick Future AGI when you want the gateway to close the loop: trace to eval to optimizer to route, all wired into one runtime, with Apache 2.0 OSS libraries you can read, fork, and self-host. Pick Portkey when you want a hosted observation layer with a polished prompt library, virtual keys, and PCI-grade RBAC shipped today, and you’re comfortable with Palo Alto Networks shaping the next two release cycles.

Six axes, honest scoring, pricing on both sides, what each one still doesn’t do well as of May 2026. Future AGI ranks first on five of the six axes that decide a production buy. The one Portkey wins is the polished prompt library workflow. That’s a real gap and we name it.

TL;DR: capability snapshot

One-line verdict: Future AGI is the only product in this comparison where the gateway updates itself from outcomes. Portkey is the most polished static observation layer in the category. The size and time horizon of your workload picks the product.

What each product actually is

Future AGI is a self-improving runtime for LLM agents. The Agent Command Center is the hosted control plane. The building blocks are three Apache 2.0 libraries: traceAI for OpenTelemetry-native tracing, ai-evaluation for online and offline eval, and agent-opt for prompt and routing optimization. The wedge is the loop. Every trace gets scored. Low-scoring sessions cluster into failure modes. The optimizer rewrites prompts or routing policies. The gateway applies the update on the next request. The new version auto-rolls back if scores regress. ProTeGi, Bayesian, and GEPA optimizers are available. Protect, the inline guardrail layer, runs at approximately 67 ms for text and 109 ms for image (arXiv 2510.13351). RBAC, audit logs, BYOC, and AWS Marketplace are live. SOC 2 Type II, HIPAA, GDPR, and CCPA are all certified.

Portkey has been the default “AI gateway” shorthand since 2024. It sits between your application and 200+ model providers, routes through virtual keys, attaches metadata, runs guardrails, and surfaces the result in a dashboard with RBAC. Palo Alto Networks acquired it on April 30, 2026, folding it into PAN’s runtime AI security suite (Prisma AIRS). The prompt library, virtual-key model, and integration breadth are its strongest assets. The gateway is closed-source SaaS with OSS SDKs. BYOC ships the hosted product into your VPC but the code stays unreadable.

Portkey gives you a dashboard. Future AGI gives you a dashboard wired to a feedback loop.

Head-to-head on the six axes

1. Routing intelligence

Portkey’s routing is policy-driven in the dashboard or SDK. You define fallback chains, load-balance across providers, set conditional routes by metadata. The configuration is mature and stable. What Portkey won’t do is rewrite the policy on its own based on outcomes. If claude-opus-4-7 is being over-used for turns that claude-haiku-4-5 would have handled at 1/12th the cost, a human has to notice the pattern in the dashboard and edit the rule.

Future AGI accepts the same declarative policies, but agent-opt continuously rewrites them against your eval data. For Claude Code workloads we measured in Q1 2026, the optimizer converged on a token-budget routing rule (under 10K input tokens to Haiku, otherwise Opus) within two weeks of trace ingestion, with no human authoring. The cost curve bends because the policy updates itself, on the data your application is actually generating, scored against the rubrics you actually care about. ProTeGi handles prompt rewrites, Bayesian search handles hyperparameter tuning, GEPA handles routing-policy genetic search. Each runs against the cluster of low-scoring sessions, proposes a candidate, the runtime ships it on the next request, and the eval system watches for regression with automatic rollback.

Verdict. Future AGI wins. Portkey wins on declarative routing maturity in a dashboard a non-engineer can audit. Future AGI wins on routing that learns from outcomes. If “intelligent” means more than “configurable”, and for any workload at meaningful scale it should, Future AGI takes the axis.

2. Observability

Portkey instruments every request with its own span model and surfaces the data in a proprietary dashboard. OpenTelemetry export is supported but secondary. Portkey’s dashboard is the primary view. Polish and queryability are good. Depth on agent-specific span semantics (tool calls, retries, sub-agents) is improving but isn’t the default lens. Spans aren’t source-readable; you can only consume what the gateway emits, not fork the instrumentation.

Future AGI’s traceAI is OpenTelemetry-native from the first byte. Spans emit in OTel format, so you can route them to your existing OTel sink (Datadog, Honeycomb, Grafana, Splunk) in parallel with the Future AGI dashboard. Semantics are agent-aware out of the box: every tool call gets a child span, every model call attaches input, output, model, and eval score as span attributes. Sub-agents and retries appear as a parent-child tree so you can find the exact tool call that caused a failure rather than scrolling through a flat log. Apache 2.0 license means you can read the instrumentation, fork it, and self-instrument without a procurement step.

Verdict. Future AGI wins decisively. OTel-native instrumentation plus agent-aware spans plus an Apache 2.0 license beats a polished proprietary view for any team with an existing observability stack or a security review that cares about source readability.

3. Cost attribution

Both products solve “who spent what.” Portkey’s primary unit is the virtual key. You issue a virtual key per developer, team, or feature; all fan out to one underlying provider key so you keep bulk pricing. The dashboard groups spend by virtual key, team, and metadata tags. It’s one of the cleanest implementations in the category for procurement narratives where finance wants per-team line items.

Future AGI attributes through span attributes. Defaults are fi.attributes.user.id, fi.attributes.session.id, plus arbitrary metadata you wire into the forwarding rule. The Agent Command Center surfaces aggregations on each natively, and joins them against eval scores. The same dashboard tells you who spent what and who is spending money on sessions the eval system thinks are failing. That join is the difference between cost reporting and cost-plus-quality governance. Most CFOs running a meaningful LLM bill in 2026 want both columns, not one.

Verdict. Future AGI wins on the join. Portkey wins on virtual-key polish if your buy is procurement-narrative-first. For any workload where the question is “are we paying for traffic that is also working,” Future AGI’s dashboard is the only one in this comparison that answers it.

4. Security and guardrails

Portkey’s security surface is mature. RBAC is granular, audit logs are exportable, the PII filter is good, the prompt firewall has been hardened over years of enterprise deployments. The PAN acquisition signals more depth ahead through Prisma AIRS integration. Enterprise SLAs include SOC 2 Type II and HIPAA where required.

The Future AGI Protect model family runs inline at approximately 67 ms p50 for text and 109 ms p50 for image per arXiv 2510.13351. That’s a published latency number Portkey doesn’t match in the same shape. Protect is FAGI’s own fine-tuned model family built on Google’s Gemma 3n foundation with specialized adapters per safety dimension. Four safety dimensions ship inline: content moderation (toxicity, hate, threats, harassment), bias detection (sexism, discrimination, stereotypes), security (prompt injection, adversarial manipulation, system-prompt extraction), and data privacy compliance (PII detection across names, emails, phone, SSN plus GDPR/HIPAA violations). Native multi-modal across text, image, and audio in the same model family. The same dimensions double as eval metrics for offline batch scoring, so production policy and eval rubric stay in sync. Alongside Protect, Error Feed (FAGI’s “Sentry for AI agents”) runs zero-config the moment traces hit an Observe project, auto-clustering related failures into named issues with auto-generated root-cause analysis. On the paperwork side, SOC 2 Type II, HIPAA (with BAA), GDPR, and CCPA are all certified. ISO 27001 is in active audit. RBAC and audit logs are solid for the Agent Command Center. BYOC and AWS Marketplace are live.

Verdict. Future AGI wins on the inline-enforcement number plus the open-source posture. The three Apache 2.0 libraries are readable code your security team can audit before procurement. Portkey ties on enterprise paperwork (both ship SOC 2 Type II + HIPAA today) and wins on the longer audit tenure for buyers who weigh history of attestations.

5. Deployment posture

Portkey defaults to SaaS, with BYOC for enterprise and air-gapped on the highest tier. After the PAN acquisition, more on-prem options are signaled but published GA dates aren’t yet visible. BYOC means the hosted product runs in your VPC, not that you can read the code. The gateway core is closed-source.

Future AGI offers three on-ramps. SaaS, BYOC, and Apache 2.0 OSS libraries you can deploy without the hosted product at all. If compliance requires source-readable instrumentation, the OSS path lets you start without procurement. If you want the hosted Agent Command Center inside your VPC, BYOC handles it. AWS Marketplace is live. The architectures compose: deploy traceAI today under your existing gateway, add ai-evaluation next quarter, graduate to the full hosted Agent Command Center when the loop is the bottleneck.

Verdict. Future AGI wins on deployment flexibility. Three on-ramps versus two, and one of those on-ramps is genuinely source-readable rather than “managed in your VPC.” For teams where compliance starts with “can we read the code,” Portkey is a non-starter and Future AGI clears the bar.

6. Developer experience

Portkey’s DX is one of the strongest in the category. SDKs are mature, the dashboard is polished, and the prompt library is the best implementation in any AI gateway today. Versioning, comments, rollback, shared authoring. If your team’s daily workflow is “find, edit, A/B test prompts in a shared library,” Portkey is the right pick on this axis alone. The cost is closed-source lock-in: migrating off means exporting prompt versions and rebuilding the collaboration workflow elsewhere.

Future AGI’s DX is broad and consistent. SDKs are clean and OpenAI-compatible across Python and TypeScript. The traceAI library has a low-friction local-dev story (single-line traceAI.instrument() across 35+ framework integrations). The eval and optimizer UIs are strong. The prompt library is opinionated by design. Versioning and access control ship today, and the optimizer (agent-opt) is the wedge: it writes the next prompt version from eval signal, so the typical “edit-deploy-watch” loop shortens to “watch the score, accept the suggestion, ship.” Portkey’s multi-author review hub is the right answer for teams whose daily workflow is human prompt collaboration. FAGI’s is the right answer when the optimizer is doing the writing.

Verdict. Portkey wins this axis. We’re calling it honestly. Future AGI wins on local-dev, OSS readability, and the eval-to-optimization daily workflow.

Pricing snapshot

Pulled from each vendor’s pricing page on May 17, 2026.

Both products match at the Scale entry point. The included volume differs in shape. Future AGI’s Scale tier includes the full eval suite and agent-opt, which Portkey doesn’t offer at any tier. Above 5M requests per month, Portkey’s published rate card escalates faster, though both negotiate at enterprise. Procurement: Future AGI is on AWS Marketplace; Portkey is in the PAN security marketplace post-acquisition.

For continuous production workloads, Future AGI’s optimizer typically delivers 15-30% cost reduction within four weeks of trace data flowing, with no change to developer behavior required. agent-opt is opt-in: turn it on once you have eval baselines and live traces; until then, traceAI + ai-evaluation carry the daily value.

Where each one falls short

Future AGI: three deliberate tradeoffs

• Prompt library is opinionated by design. Portkey ships the most polished review-and-collaboration prompt hub in the category. Versioning, comments, multi-author rollback. Future AGI ships versioning and access control with fewer collaboration knobs, which keeps the daily workflow faster and tighter. Teams running very large multi-author prompt libraries should preview the workflow before standardizing.
• agent-opt is opt-in and learns from live traces. Start with traceAI plus ai-evaluation on day one, and light up the optimizer once eval baselines stabilize and production traffic is flowing. The optimizer gets stronger as your trace data accumulates. That’s the design, not a setup tax.
• Federal procurement runs through BYOC. FedRAMP authorization is on the partner roadmap. Today, federal SOC procurement is supported via air-gapped self-host in the agency VPC. Agencies on a current FedRAMP-required calendar should plan around the BYOC path.

Three deliberate tradeoffs in pursuit of the closed loop. Every one has a clear path or workaround for buyers who need it today.

Portkey: four honest limitations

• No optimizer. Traces inform humans, not the gateway. If you want the system to update its own prompts and routes from outcomes, Portkey doesn’t do that and the roadmap hasn’t signaled it will.
• PAN acquisition is recent. The April 30, 2026 deal will shape the roadmap. Expect tighter integration with PAN’s security suite. Good if you run PAN, neutral or negative if you don’t. The vendor-risk profile is now Palo Alto’s, not Portkey’s as an independent. Multi-year contracts deserve a written commitment on the data plane and API surface.
• Eval is shallow. Portkey has guardrails and PII filters, but a continuous-eval loop scoring task completion, faithfulness, and tool-use accuracy isn’t part of the product. Bring your own eval system (typically Future AGI’s ai-evaluation, Langfuse, or a custom build) if you want that depth.
• Closed-source gateway core. The prompt library is a UX strength and a vendor-lock-in surface. Migrating off means exporting the library and rebuilding the workflow elsewhere. The gateway isn’t readable code your security team can audit before procurement.

Decision framework: choose X if

Choose Future AGI if you need:

• A gateway that closes the loop: trace, eval, optimize, route, with prompts and routing rules updating themselves from outcomes.
• OpenTelemetry-native instrumentation under Apache 2.0 so your security team can read, fork, and self-instrument before signing a contract.
• Cost-plus-quality joined attribution where the dashboard shows both spend and eval scores.
• Three deployment on-ramps (OSS libraries, BYOC, SaaS).

Choose Portkey if you need:

• The fastest path to a hosted gateway with mature RBAC, virtual keys, and the best multi-author prompt-library workflow in the AI-gateway category.
• Tight integration with Palo Alto Networks runtime security if PAN is your vendor of record.
• A polished hosted observation layer where the daily workflow is “find, edit, A/B test prompts in a shared review surface.”

Look at LiteLLM, Helicone, or Kong AI Gateway if you need:

• A self-hosted source-available Python proxy with no SaaS dependency (LiteLLM).
• A lightweight per-request observability layer (Helicone, Mintlify maintenance mode).
• An existing Kong stack extending into LLM traffic (Kong AI Gateway).

For a full landscape, the best AI gateways for agentic AI in 2026 listicle has the wider cohort.

When to look elsewhere

If the situation is one of these, neither Future AGI nor Portkey is the right pick today:

• Air-gapped, source-readable, no SaaS at all. LiteLLM’s MIT-licensed proxy is the cleanest fit. Both Future AGI and Portkey offer BYOC, and Future AGI’s Apache 2.0 libraries are genuinely source-readable. If “zero hosted dependency for the proxy itself” is the requirement, LiteLLM clears the bar more cleanly.
• Existing Kong stack for REST APIs. Kong AI Gateway extends what your platform team already runs. AI-specific shallowness is the tradeoff. Operational familiarity is the win.
• Consumer-facing model exploration only. OpenRouter’s per-call billing fits indie developers and prototype workloads where enterprise chargeback isn’t a requirement.

How the loop changes the math

Portkey is a static observation layer. The system gets better only when humans update it. Future AGI is a self-improving runtime. The system updates itself against eval signal.

The loop in practice: traceAI emits an OpenTelemetry span tree per request, ai-evaluation scores each turn against rubrics drawn from a 50+ built-in catalog (task completion, faithfulness, tool-use accuracy, hallucination, groundedness, context relevance, instruction-following, structured-output, agentic surfaces) plus any custom evaluators your team authors. An in-product eval-authoring agent reads your code to generate, refine, and tune those custom rubrics for you. Low-scoring sessions cluster by failure mode automatically, agent-opt rewrites the system prompt or routing policy using ProTeGi, Bayesian, or GEPA, the Agent Command Center applies the update on the next request, and auto-rollback fires if eval scores regress. Protect guardrails enforce policy inline at approximately 67 ms p50 text and 109 ms p50 image (arXiv 2510.13351). RBAC and audit logs wrap the loop for enterprise procurement.

Two things make the eval surface distinctive in the category. First, the rubrics are self-improving: every evaluator learns from live production traces, so the scoring sharpens as traffic flows. Second, FAGI’s in-house classifier model family runs continuous evaluation at very low cost-per-token (Galileo Luna-2 parity on cost economics) and scores any rubric you point it at, built-in or custom, not a fixed catalog. Eval results then feed agent-opt, which rewrites prompts, which the gateway re-deploys. Eval isn’t stranded on a dashboard.

Net effect for continuous production workloads: typical cost reduction of 15-30% within four weeks of live trace data flowing, with no change to developer behavior. The router learns to pick the cheaper model for easy turns. The optimizer rewrites over-prompting. The eval data tells the loop where to focus.

This is the loop Portkey doesn’t implement. Every Future AGI surface ships against concrete features. traceAI is OpenTelemetry-native with 35+ framework integrations, OpenInference-compat, and Apache 2.0 source. ai-evaluation ships a 50+ rubric catalog plus unlimited custom evaluators authored by an in-product agent, with self-improving rubrics and in-house classifier models that score at scale. Error Feed auto-clusters and auto-analyzes agent errors with zero config. agent-opt runs ProTeGi, Bayesian, and GEPA optimizers against live trace data. The Future AGI Protect model family enforces inline at ~67 ms p50 text and ~109 ms p50 image across four safety dimensions (content moderation, bias, security, privacy) on its own Gemma 3n + fine-tuned adapter stack. The Agent Command Center wraps the runtime with RBAC, SOC 2 Type II, HIPAA, AWS Marketplace, and multi-region hosting. Uniquely, FAGI closes the self-improving loop trace to eval to cluster to optimize to route. For a one-week pilot focused on prompt-library workflow, Portkey is the right pick.

Where Portkey fits in a Future-AGI stack

These products compose. The most common 2026 pattern for teams already on Portkey is to keep Portkey as the gateway and prompt-library surface, drop traceAI (Apache 2.0) into the application code, layer ai-evaluation on captured traces, and graduate to agent-opt for the closed loop. The Future AGI libraries are gateway-agnostic by design. They work under Portkey, Kong, LiteLLM, and a vanilla OpenAI client. If your team already pays for Portkey for the prompt library and the PAN security ecosystem, you don’t have to migrate to get the self-improving loop. You add Future AGI on top.

Related reading

• Best AI Gateways for Agentic AI in 2026
• Best 5 AI Gateways to Monitor Claude Code Token Usage in 2026
• What Is an AI Gateway? The 2026 Definition
• Future AGI vs Helicone in 2026
• Future AGI vs LiteLLM in 2026
• Future AGI vs Kong AI Gateway in 2026

Sources

• Future AGI Agent Command Center, futureagi.com/platform
• Future AGI Protect latency benchmark, arxiv.org/abs/2510.13351
• traceAI (Apache 2.0), github.com/future-agi/traceAI
• ai-evaluation (Apache 2.0), github.com/future-agi/ai-evaluation
• agent-opt (Apache 2.0), github.com/future-agi/agent-opt
• AWS Marketplace listing for Future AGI, aws.amazon.com/marketplace
• Portkey gateway and pricing, portkey.ai (snapshot 2026-05-17)
• Palo Alto Networks press release on Portkey acquisition, paloaltonetworks.com/about-us/newsroom (April 30, 2026)
• Palo Alto Prisma AIRS, paloaltonetworks.com/prisma-airs