Key facts
| Endpoint | One OpenAI-compatible API replaces multiple provider integrations (live) |
| Router model | plugsky-fusion fans out and escalates across tiers (live) |
| Strategies | cost_saver, balanced, max_quality and custom rules per key |
| Models | 30+ models from free to frontier behind one endpoint |
| Pricing | Flat monthly self-serve plans with no per-token charges on self-serve |
| Free tier | plugsky-micro and plugsky-lite on the free plan, no card required |
| Governance | Scoped keys, usage analytics and audit logs per key |
| Deployment | Cloud, VPC, on-prem and air-gapped options |
TL;DR
- Consolidate providers behind one compatible endpoint and one SDK.
- Centralise retries, fallbacks and limits so every workload inherits them.
- Route per task, not per team habit; keep critical paths pinned.
- Use one key per workload for clean usage attribution.
- Measure orchestration overhead in latency and maintenance, not just spend.
How it works, step by step
- Inventory every model provider, SDK and key currently in production.
- Move calls behind one OpenAI-compatible endpoint and one internal gateway.
- Map each workload to a tier and set a fusion strategy per key.
- Centralise retries, timeouts, fallbacks and rate limits in the gateway.
- Pin compliance-sensitive paths to strong models with custom rules.
- Attribute usage by key and feature, and retire unused providers and keys.
- Review gateway metrics monthly: error rates, fallback frequency and model mix.
Try it yourself
Open the AI API pricing tracker →
What orchestration really costs
Every additional provider adds an SDK, a credential store, a retry policy, a fallback path and a monitoring surface. The direct model spend is visible; the maintenance cost is not. Teams usually discover it when an outage in one provider requires changes in six services.
Consolidation behind one OpenAI-compatible endpoint removes duplicate integration code without reducing model choice. Plugsky exposes 30+ models through the same request shape as OpenAI, so a gateway can route by task while callers keep one client, one retry policy and one observability path.
Routing inside the gateway
The gateway decides the tier, enforces limits and owns fallback. Keep that logic in one place and version it:
- Default tiers per workload, set with fusion strategies such as
cost_saverorbalanced. - Pinned paths for compliance or high-value work that must never downgrade.
- Fallbacks for provider errors and timeouts, applied consistently instead of per service.
- Limits per key so one runaway loop cannot starve other workloads.
Scoped keys per workload also make usage analytics meaningful: you can see which product, team or pipeline spends what, without building parallel metering.
The savings beyond the model bill
Consolidation reduces the cost of change. One SDK upgrade, one retry policy, one audit trail. That compounds: engineering time that went into provider plumbing goes into product, and incident response has a single surface to inspect.
Tiering then reduces the model bill itself by keeping routine traffic on cheap tiers and reserving strong models for the tail. Evaluate each tier against a fixed task set before widening, and keep high-stakes paths pinned. On self-serve plans there are no per-token charges, so the remaining work is latency and throughput tuning — see the live pricing page for current plans. Start on the free plan with plugsky-micro and plugsky-lite, and use the 14-day full-access trial to evaluate frontier tiers.
Honest comparison
| Overhead | Consolidated on Plugsky | Multi-provider mesh | Single vendor lock-in |
|---|---|---|---|
| Integrations | One OpenAI-compatible endpoint | One SDK per provider | One vendor SDK |
| Retries and fallback | Centralised in your gateway | Per service, duplicated | Provider-specific |
| Model choice | 30+ models behind one API | Whatever each provider offers | Vendor catalogue only |
| Usage attribution | Scoped keys and analytics | Per-provider dashboards | Vendor reporting |
| Cost of change | One client to upgrade | Many services to touch | Wait for vendor |
Frequently asked questions
How does consolidation reduce cost?
It removes duplicated SDKs, credentials, retry policies and monitoring surfaces, and it makes usage attribution possible. One gateway is cheaper to run and to change than a mesh of provider integrations.
Do I lose model choice by consolidating?
No. Plugsky exposes 30+ models behind one OpenAI-compatible endpoint, so the gateway can route by task while callers keep a single client and a single contract.
What belongs in the gateway?
Tier selection, retries, timeouts, fallbacks, rate limits, key management and usage tagging. Keeping these in one place means every workload inherits the same behaviour.
How should I scope API keys?
One key per workload or team. That makes usage analytics meaningful and limits the blast radius of a leaked or runaway key.
Is there a classifier router?
Classifier routing with model=auto is coming soon. Today, fusion strategies and per-key custom rules handle tier selection.
What about latency from routing?
Tier selection itself is lightweight; fan-out strategies add overhead. Measure against your latency budget and keep interactive workloads on simpler policies.
Does flat pricing help orchestration?
Self-serve plans are flat monthly with no per-token charges, which removes the metered-billing reconciliation work from your orchestration layer. See the live pricing page for details.
Can I trial this cheaply?
Yes. The free plan includes plugsky-micro and plugsky-lite with no card, and the 14-day full-access trial covers stronger models for a migration pilot.