Key facts
| Loop primitive | POST /v1/chat/completions with a tools array (live) |
| Free tier | plugsky-micro and plugsky-lite free, no card required |
| Trial | 14-day full-access trial for heavier prototyping |
| Memory | Message history plus /v1/embeddings with plugsky-embed for recall |
| Model routing | 30+ models behind one endpoint; start cheap, escalate when quality demands it |
| Infrastructure | No GPUs to provision or serve; the API handles scaling |
| Portability | OpenAI-compatible, so the codebase survives provider changes |
| Endpoint status | Chat completions, streaming and function calling are live; assistants and responses are coming soon |
TL;DR
- Build the loop yourself in a few dozen lines; skip agent frameworks until they earn their place.
- Start on plugsky-micro and plugsky-lite, then escalate specific steps to stronger models.
- Keep memory in your own database so you stay portable.
- Spend engineering time on your workflow and evals, not on inference infrastructure.
- Upgrade path is a plan change and a model alias, not a rewrite.
How it works, step by step
- Pick one narrow workflow a user will pay for — triage, drafting, extraction or search — and define the single output that proves value.
- Create a free Plugsky account and key; run the first version against plugsky-micro or plugsky-lite.
- Implement the tool loop with two or three tools that touch your own product data.
- Add the lightest useful memory: conversation history first, embeddings with plugsky-embed when recall is genuinely needed.
- Instrument runs with request IDs, model alias, latency and outcomes so you can see what users actually do.
- Test against a small set of real examples and fix failure modes before adding features.
- When quality or volume demands it, map specific steps to stronger models or move to a paid plan. See the live pricing page for plan details.
Original data
Try it yourself
Ship the loop, not the platform
The fastest path is the simplest one: send messages and a tools array to /v1/chat/completions, execute returned tool calls, append results, repeat. That is an afternoon of work, and it produces a real agent rather than a prototype of one. Resist the urge to build a framework, a routing layer or a memory service before the workflow works.
You also skip infrastructure entirely. There are no GPUs to provision, no serving stack to tune and no capacity plan to write. The API scales with you, and because it is OpenAI-compatible, the code you write today keeps working if you change providers or models later.
Spend tokens where users notice
Early budgets go furthest when routing is deliberate. Use plugsky-micro or plugsky-lite for classification, extraction and formatting — the high-volume, low-judgement steps. Reserve stronger models for planning, synthesis or anything a user would judge harshly. With 30+ models behind one endpoint, changing the tier is a string change.
- Cap the loop: a maximum step count prevents a stuck agent from burning a day's budget.
- Cache aggressively: identical classifications and lookups do not need a model call.
- Watch per-feature usage: request IDs and token counts tell you which feature is expensive before your invoice does.
From MVP to paid, without a rewrite
The transition from free tier to production should be configurational. A paid plan adds capacity and support; model aliases change which tier serves each step; scoped keys separate environments. Because the interface stays OpenAI-compatible, growth does not force an architecture change — and enterprise customer requirements such as region-locked planes, customer-managed keys or VPC deployment are available when you need them, not before.
Keep one discipline from day one: an evaluation set of real examples. It is the difference between shipping improvements and shipping regressions, and it is the artefact investors and customers can read when they ask how you know the agent works.
Honest comparison
| Startup concern | Plugsky | Typical model API | Self-hosted GPUs |
|---|---|---|---|
| Upfront cost | Free plan, no card | Pay-as-you-go | Hardware commitment |
| Infrastructure | None to operate | None | Provisioning and serving |
| Model choice | 30+ models behind one endpoint | One vendor catalogue | One model per deployment |
| Cost shape | Flat monthly with fair-use usage | Per-token | Fixed capacity, variable utilisation |
| Scaling | API handles it | API handles it | You plan and buy capacity |
| Enterprise readiness | Region-locked planes, VPC, BYOK available later | Varies | Whatever you build |
Frequently asked questions
Do we need an agent framework?
No. A tool loop on chat completions is small and readable, and it keeps your dependency surface tiny. Adopt a framework when it removes real work, not before.
What does the free plan include?
plugsky-micro and plugsky-lite with no card required, enough to build and demo a real workflow. A 14-day full-access trial exists for heavier prototyping. Check the live pricing page for details.
How do we keep costs down as usage grows?
Route routine steps to smaller models, cap loop iterations, cache deterministic lookups and watch per-feature usage. Flat monthly plans with fair-use usage keep self-serve costs predictable.
When should we add embeddings and memory?
When the product genuinely needs recall across sessions or documents. Start with conversation history; add /v1/embeddings and a vector store when users hit that wall.
What if we raise money and need enterprise controls?
The same API supports region-locked planes, customer-managed keys and VPC deployment when customers demand them. Your integration does not change.
Is our code portable?
Yes. The endpoint is OpenAI-compatible, so switching providers or adding a second one is a base URL and model mapping change, not a rewrite.
What should we build first?
The narrowest workflow that produces a visible outcome for a real user. One working agent with telemetry beats a platform roadmap.