Comparison
Nexus vs Portkey
Portkey is an AI gateway with built-in observability. Nexus is an observability tool without a gateway. Here is an honest look at when each approach makes more sense for AI agent developers.
TL;DR
Choose Nexus if you...
- ✓ Need deep agent trace/span observability with span waterfall views
- ✓ Want flat-rate predictable pricing ($9/mo — no per-request charges)
- ✓ Are monitoring multi-step agents with complex tool use and sub-agents
- ✓ Want TypeScript-first SDK with zero proxy dependencies
- ✓ Need email alerts when agents fail in production (Pro)
Choose Portkey if you...
- ✓ Need model routing, fallbacks, or load balancing across LLM providers
- ✓ Want automatic request-level logging without SDK instrumentation
- ✓ Require multi-provider LLM switching (OpenAI, Anthropic, Gemini, etc.)
- ✓ Need rate limiting, caching, or virtual keys for API management
- ✓ Want a single gateway for all LLM provider calls across your stack
The fundamental difference: observability vs gateway
Portkey is gateway-first: your LLM calls route through Portkey's proxy, which automatically logs every request and response. This zero-instrumentation approach captures all LLM calls without code changes, but the mental model is a request/response log — not an agent trace with nested spans, tool calls, and multi-step reasoning.
Nexus is observability-first: you instrument your agent code with the SDK to create traces and spans that map directly to agent behavior. Each trace is a complete agent run; each span is a specific step (LLM call, tool use, sub-agent invocation). The result is a waterfall view that shows exactly what happened inside a complex, multi-step agent workflow.
The result: Portkey captures what you send to LLM APIs; Nexus captures what your agent actually does. If your application is primarily direct LLM calls (not multi-step agents), Portkey's proxy logging is simpler. If you are running complex agents with branching logic, tool use, and sub-agents, Nexus gives you the trace depth that proxy logging cannot.
Pricing
Nexus
$9/mo
Flat-rate — no per-request charges
- ✓ Free tier: 1,000 traces/month
- ✓ Pro: 50,000 traces, unlimited agents
- ✓ No per-token or per-request fees
- ✓ Email alerts on failure (Pro)
- ✓ TypeScript + Python SDK (MIT)
Portkey
Usage-based
Free tier; paid tiers scale with request volume
- ✓ Free tier: 10,000 requests/month
- ✓ Growth: usage-based per request
- ✓ AI gateway + routing + fallbacks
- ✓ Virtual API keys, caching, rate limiting
- ✓ TypeScript + Python (proxy-based)
Feature comparison
| Feature | Nexus | Portkey |
|---|---|---|
| Agent trace & span model | ✓ Purpose-built | — (request logs only) |
| Span waterfall view | ✓ | — |
| Multi-step agent debugging | ✓ Deep | Limited |
| Real-time error alerts | ✓ (Pro) | — |
| TypeScript SDK | ✓ Open-source | ✓ (proxy-based) |
| Python SDK | ✓ Open-source | ✓ (proxy-based) |
| Flat-rate pricing | ✓ $9/mo | — (usage-based) |
| AI model routing / fallbacks | — | ✓ Core feature |
| Multi-provider LLM switching | — | ✓ |
| Virtual API keys | — | ✓ |
| LLM response caching | — | ✓ |
| Rate limiting | — | ✓ |
| Zero-code instrumentation | — (SDK needed) | ✓ (proxy-based) |
| Setup time | < 2 min | 5–10 min (proxy setup) |
| Self-hosted option | — | ✓ (open-source) |
The honest take
Portkey is genuinely useful for AI gateway concerns. If you need to route between GPT-4o and Claude based on cost or latency, fall back to a secondary model when your primary is down, or manage API keys centrally across a team, Portkey solves these problems well. The proxy approach means zero code changes to your existing LLM calls — just swap the base URL.
The gap is depth of observability for agent workflows. Portkey logs LLM requests and responses, which is useful for debugging individual calls. But when your agent makes 15 LLM calls, 8 tool invocations, and spawns 3 sub-agents over a 45-second run, a flat request log cannot tell you which step caused the failure or how long each segment took relative to the others. That is what Nexus's trace/span model was built for.
They can be complementary. Some teams use Portkey for gateway concerns (routing, fallbacks, cost optimization) and Nexus for agent-level observability (trace waterfall, error alerts, per-agent health). The SDKs do not conflict — you can route through Portkey while instrumenting your agent logic with Nexus spans. That said, if budget is tight, prioritize based on your primary pain point: gateway routing or agent debugging.
The pricing model also differs meaningfully: Nexus at $9/mo flat is predictable regardless of how many requests your agent makes. Portkey's usage-based pricing can be cheaper at low volume but scales with request count — which can add up for high-throughput production agents.
Related
- All AI agent monitoring alternatives — compare every tool side by side
- OpenTelemetry for AI Agents: Why Standard APM Falls Short
- Nexus pricing — free plan or $9/mo Pro
Try Nexus free — no credit card needed
1,000 traces/month free. Drop in 3 lines of code and see your first trace in under a minute.