Key facts
| Model class | Compact profile in the Plugsky catalogue |
| Best for | Schema extraction, classification, rewriting and utility prompts |
| Context class | 128K-class window; live limits are published per model |
| Capabilities | Streaming, function calling and JSON mode |
| Pricing tier | Paid-plan model; free plan covers plugsky-micro and plugsky-lite |
| API | OpenAI-compatible /v1/chat/completions — no SDK changes |
| Resilience | Backup upstream plus same-profile fallback peers |
| Product status | Live |
TL;DR
- A compact tier for narrow, well-specified tasks.
- Strong fit for schema extraction, classification and rewriting.
- JSON mode and function calling keep pipelines simple.
- Escalate to a larger tier when a task needs real reasoning.
- Benchmark on your own prompts; compact models differ by domain.
How it works, step by step
- Read the live model card at /models for the window, output limit and feature flags.
- Shortlist tasks with a single clear output: labels, fields or short rewrites.
- Benchmark plugsky-phi against the free tiers on those tasks.
- Lock output shape with JSON mode and a schema validator.
- Escalate validator failures to a larger tier with one capped retry.
- Track cost per successful task and widen the task list only when it holds up.
Try it yourself
What plugsky-phi is
plugsky-phi is the compact profile in the Plugsky catalogue: a small model for jobs that are narrow and well specified. It keeps the standard OpenAI-compatible surface — streaming, function calling and JSON mode — and is listed as 128K-class on the live model card.
Compact models are easy to underestimate. On a clearly defined task with a fixed output shape they can be excellent and cheap; on ambiguous or multi-step work they struggle. The evaluation set, not the profile name, decides which side of that line your task falls on. Check /models for live routing and limits.
When to choose it
Good fits are tasks where the instruction can be fully specified: extracting fields from text, assigning labels, normalising formats, rewriting for tone, generating short summaries and producing tool arguments. These are the workloads teams often run on a much larger model by default, paying for reasoning they never use.
If your task depends on context across many messages, mathematical reasoning or synthesis across sources, start a tier or two higher — for example with plugsky-minimax or the free plugsky-micro — and use phi for the parts that are structured.
Compact-model trade-offs
Small size changes failure modes more than it changes average quality. Expect confident wrong answers on ambiguous prompts and occasional drift outside your schema. Mitigations are straightforward:
- Constrain output with JSON mode plus a schema validator.
- Keep instructions short and unambiguous; add examples only where they visibly help.
- Use a refusal instruction and test adversarial inputs.
- Slice metrics by task — one failing task should not discredit the rest.
Self-serve plans are flat monthly with fair-use usage, so check the live pricing page when sizing utility-call volume.
How to switch to plugsky-phi
Switching is one model name on the same endpoint: {"model": "plugsky-phi", "response_format": {"type": "json_object"}, "messages": [{"role": "user", "content": "Extract vendor, amount and due date as JSON."}]}.
Run it over a labelled sample first, measure exact-match on the fields you care about, and keep a larger model as the escalation path for validation failures.
Honest comparison
| Dimension | plugsky-phi | Free models (micro, lite) | Larger workhorse tiers |
|---|---|---|---|
| Best fit | Narrow extraction and utility tasks | General free experimentation | Reasoning and synthesis |
| Quality ceiling | Good on specified tasks | Good for simple tasks | Higher |
| Latency profile | Fast tier | Fast tier | Moderate |
| Context class | 128K-class | 128K-class | 128K-class |
| Use as | Utility-call default | Zero-cost baseline | Escalation target |
| Plan | Paid | Free, no card | Paid |
Frequently asked questions
Is plugsky-phi free?
No — it is a paid-plan model. The free plan covers plugsky-micro and plugsky-lite with no card required, and a 14-day full-access trial lets you evaluate paid tiers first.
What is plugsky-phi best at?
Narrow tasks with a clear output: schema extraction, classification, tagging, format normalisation, short rewrites and tool-argument generation.
What context window does it have?
It is 128K-class today, but the exact live window and output limit are published per model on the catalogue. Use that page as the source of truth.
Does it support JSON mode and function calling?
Yes — both are part of the OpenAI-compatible surface, which makes it a natural fit for structured extraction and tool loops.
When should I use a bigger model instead?
When the task needs multi-step reasoning, ambiguity handling or synthesis across documents. Start higher, or keep phi for the structured parts and escalate the rest.
How do I get reliable structured output?
Use JSON mode with a schema, validate the response in code, and retry or escalate on validation failure rather than trusting the model's formatting.
How is pricing structured?
Self-serve plans are flat monthly with fair-use usage rather than per-token billing. See the live pricing page for current plans.