Key facts
| SaaS fit | Per-customer workspaces, scoped keys and per-key usage analytics |
| Live endpoints | Chat completions with streaming, function calling, JSON mode and embeddings |
| Coming soon | Audio, images, files and batch endpoints are labelled coming soon |
| Streaming | Server-sent events for token-by-token UX; function calling works with streaming |
| Models | 30+ models behind one OpenAI-compatible API |
| Pricing | Flat monthly self-serve plans with unlimited fair-use usage; no per-token billing |
| Free plan | plugsky-micro and plugsky-lite, no card; 14-day full-access trial |
| Retention | Configurable prompt retention; review the DPA for your product terms |
TL;DR
- Ship one multimodal workflow — upload Q&A, screenshot triage or call summaries — before generalising.
- Keep extraction behind an adapter; audio, images and files endpoints are still coming soon.
- Stream model output over SSE so long responses feel instant in your UI.
- Namespace embeddings per customer and issue scoped keys per environment.
- Flat monthly pricing keeps gross margin stable as usage grows across tenants.
How it works, step by step
- Choose a single high-value feature with a measurable outcome, such as document Q&A or support-ticket triage, and define its success metric.
- Add an upload and extraction service that normalises PDFs, images and audio to text; keep the OCR or speech engine behind a swappable interface.
- Call chat completions with a JSON-mode schema for structured fields and stream tokens over SSE for anything a user waits on.
- Create a per-customer vector namespace with the embeddings API and retrieve before prompting to ground answers in tenant data.
- Issue scoped API keys per environment and route cheap classification to plugsky-micro or plugsky-lite through the same endpoint.
- Gate rollout behind a feature flag, log model and token usage per customer for billing, and expand only when evaluations hold.
Try it yourself
Open the RAG architecture builder →
Multimodal features users actually pay for
The features that convert share a shape: a user brings messy input, the product returns structured value. Document Q&A over contracts and invoices, screenshot understanding for support triage, call and meeting summaries, and claim or expense extraction all follow it. Each combines an extraction step with a reasoning step, and each can be measured — time saved, deflection rate, fields auto-filled.
Pick one, instrument adoption, and resist shipping four at once. The architecture below is the same for all of them, so the second feature is mostly a prompt and schema change rather than new infrastructure.
Reference architecture inside a multi-tenant product
Your upload service stores the file, an extraction adapter converts it to text, and JSON mode turns that text into the fields your product needs. Because audio, images and files endpoints are still coming soon on Plugsky, keep that adapter behind an interface you control; you can swap the OCR or speech engine without touching the reasoning core.
Ground answers with the live embeddings API into a namespace per customer, then generate with chat completions. Stream over server-sent events so users see progress, and use function calling for anything that needs to write to your own APIs — creating a ticket, updating a record, scheduling a callback. All of it travels through one OpenAI-compatible endpoint, so your SDK and retry logic stay unchanged.
Latency, cost and honest limits
Multimodal requests are slower than text-only, so queue long jobs and stream anything interactive. Route classification, routing and short summaries to plugsky-micro or plugsky-lite and reserve larger models for reasoning over long documents. Flat monthly self-serve plans avoid per-token billing, which keeps pricing predictable as tenants grow; see the live pricing page for plan details.
Be explicit internally about what is live — chat, streaming, JSON mode, function calling and embeddings — and what is still roadmap, so product promises match the docs. Review retention terms in the DPA and keep tenant data in the region you committed to.
Honest comparison
| Concern | Plugsky | Single-vendor model API | Building in-house |
|---|---|---|---|
| Product integration | OpenAI-compatible SDK, streaming and JSON mode | Vendor SDK and formats | Custom serving stack |
| Tenant isolation | Workspace per customer, scoped keys, RBAC | Shared keys unless you build it | You design everything |
| Multimodal coverage | Text live; audio, images and files coming soon | Varies by vendor | Each pipeline is your problem |
| Cost model | Flat monthly plans, no per-token on self-serve | Per-token, forecast-sensitive | GPU capacity plus ops |
| Residency | Region-locked planes plus VPC, on-prem and air-gapped | Usually a few global regions | Self-deployed |
Frequently asked questions
How do we isolate each customer's data?
Create a workspace per customer, issue scoped API keys per environment, and namespace embeddings per tenant so retrieval can never cross accounts.
Is streaming supported for chat responses?
Yes. Chat completions support server-sent event streaming, and OpenAI-style function calling works alongside it, so you can stream text while tools run server-side.
Can we handle uploads today if audio and image endpoints are coming soon?
Yes. Keep extraction in your own adapter — document parser, OCR or speech service — and use Plugsky for reasoning, retrieval and actions on the resulting text.
How do we keep per-customer costs predictable?
Route routine work to plugsky-micro or plugsky-lite, reserve larger models for hard cases, and monitor usage per API key. Self-serve plans are flat monthly with fair-use usage.
Do we need our own vector database?
You can bring one. The live embeddings API produces the vectors; storage, tenancy and re-ranking stay in your stack.
Can we offer this to enterprise customers with residency requirements?
Yes — pin workspaces to region-locked planes, and use VPC, on-prem or air-gapped deployment when a customer requires in-country processing.
How fast can a SaaS team get to a prototype?
Most teams reach a working prototype in days on the free plan with plugsky-micro and plugsky-lite and no card, then move to a paid plan or the 14-day full-access trial.