Key facts
| Function calling | Structured tool requests with arguments your code validates and executes |
| Streaming | Token-by-token output so long runs show progress and can be cancelled |
| JSON mode | Constrained output for parsers, routers and state updates |
| Embeddings and RAG | Vector representation plus retrieval grounding for memory |
| Agents | Agent patterns run on the chat and tool-calling endpoints |
| Platform controls | Scoped keys, RBAC, SSO/SCIM and audit logs are live |
| Pricing model | Flat monthly self-serve plans; free tier with two models |
| Coming soon | Assistants, responses, batch, files, fine-tuning, audio, image and moderation endpoints |
TL;DR
- An agent API supports loops: tools, streaming, JSON mode and retrieval.
- Your code owns the loop, state, tool execution and guardrails.
- OpenAI compatibility keeps clients, frameworks and skills portable.
- Check status labels: some assistant-style endpoints are still coming soon.
- Start free with plugsky-micro and plugsky-lite, then scale.
How it works, step by step
- Confirm the endpoint supports function calling, streaming and JSON mode.
- Define tools with strict argument schemas and validate every value before execution.
- Implement the loop: call, execute tools, append results, repeat until done.
- Add limits: maximum turns, token budget, retry ceiling and timeout.
- Store state in your own database or a checkpointer you control.
- Add embeddings and retrieval for memory and grounding where needed.
- Log every step for evaluation, cost tracking and incident review.
Try it yourself
Open the AI agent comparison →
The pieces that make an API agent-ready
A plain completions endpoint returns text. Agent work needs more. Function calling lets the model emit a structured request — a tool name and arguments — that your code executes and feeds back. Streaming exposes tokens as they arrive, which matters for long runs, progress display and cancellation. JSON mode constrains output so downstream parsers and routers can rely on the shape.
Retrieval completes the picture: embeddings turn text into vectors so the agent can search memory, documents and past conversations instead of relying on a growing prompt. Together these capabilities let you build a loop where the model reasons and your code acts.
The loop is still your responsibility
An agent API does not run your agent. It serves model calls. The loop, the tools, the state, the retries and the guardrails live in your code, which is what makes behaviour inspectable and portable. That division matters: the API provides reasoning and structure; you provide action and accountability.
- Tool execution: validate arguments, enforce permissions, sandbox side effects.
- State: persist threads and checkpoints where your policies require.
- Limits: caps on turns, tokens, retries and runtime.
- Observability: traces of every call, tool result and decision.
How to compare agent APIs
Compare on four axes. Interface: is it OpenAI-compatible, so your SDKs and frameworks keep working? Capability: are function calling, streaming, JSON mode, embeddings and RAG live, and which assistant-style endpoints are still coming soon? Platform: do you get scoped keys, RBAC, audit logs and deployment choices? Economics: is pricing predictable for long-running, multi-step work?
Plugsky answers these with 30+ models on one OpenAI-compatible key, live function calling, streaming, JSON mode, embeddings, RAG and agents, plus scoped keys, RBAC, SSO/SCIM and audit logs, and deployment from shared cloud to VPC, on-prem and air-gapped. Assistants, responses, batch, files, fine-tuning, audio, image and moderation endpoints are coming soon. Self-serve plans are flat monthly and the free tier covers plugsky-micro and plugsky-lite; current plans are on the live pricing page.
Honest comparison
| Capability | Plain chat endpoint | Agent-ready API | Hosted agent product |
|---|---|---|---|
| Function calling | None | Live, structured tool requests | Handled internally |
| Streaming | Sometimes | Live token streaming | Yes |
| Retrieval | You add separately | Embeddings and RAG live | Built in |
| Loop control | You build it | You build it | Vendor controls it |
| Portability | High | High with OpenAI compatibility | Low |
Frequently asked questions
Is an agent API the same as an assistant API?
No. Assistant-style endpoints typically store threads and files server-side. An agent API exposes model capabilities such as tool calling, and you keep state and orchestration in your code.
Do I need a separate API for agents?
No. Agents run on standard chat completion calls with function calling, streaming and JSON mode. The difference is how you use the endpoint, not a special model class.
What does OpenAI compatibility mean here?
Your existing OpenAI-format SDKs, frameworks and tooling keep working after a base URL change, which lowers migration effort and exit cost.
Where does memory live?
In your systems. Use embeddings and a vector store for semantic recall, and your own database for structured threads and checkpoints.
Which endpoints are not agent-ready yet?
On Plugsky, assistants, responses, batch, files, fine-tuning, audio, image and moderation endpoints are coming soon. Chat, streaming, JSON mode, function calling, embeddings, RAG and agents are live.
How do I keep an agent safe?
Validate tool arguments, run tools with least privilege, sandbox side effects, cap turns and budget, and require approval for irreversible actions.
How do I start?
Create an API key on the free plan with plugsky-micro and plugsky-lite, run a two-tool loop, then use the 14-day full-access trial to evaluate the wider catalogue.