Key facts
| Interface | One OpenAI-compatible endpoint for all agent teams and models |
| Control plane | Policy, tool registry, evaluation gates and budgets live in your architecture |
| Identity | Scoped API keys per service, RBAC and SSO/SCIM for people |
| Residency | EU (Frankfurt), GCC (UAE), APAC (Singapore), US (Virginia) region-locked planes |
| Deployment tiers | Plugsky cloud, VPC private endpoint, on-prem and air-gapped |
| Audit | Authentication, key, admin and inference metadata exportable to SIEM |
| Model routing | 30+ models behind one alias system; route by step, not by team preference |
| Endpoint status | Chat completions and function calling are live; assistants and responses endpoints are coming soon |
TL;DR
- Standardise on one gateway and one audit pipeline before the second agent ships.
- Treat tools as governed assets with owners, risk tiers and versioned schemas.
- Keep authorisation outside the model; the model proposes, your policy disposes.
- Pin each workspace to a region and align log residency with data residency.
- Route across 30+ models to match cost and latency to each step.
How it works, step by step
- Inventory candidate agent workflows across business units and score them by data sensitivity and reversibility.
- Stand up a shared model gateway in front of the OpenAI-compatible endpoint so no team calls the API with unmanaged keys.
- Build a tool registry: each tool gets an owner, a versioned JSON schema, a risk tier and a maximum blast radius.
- Define policy in code — which agent may call which tool with which identity — and enforce it in the gateway, not the prompt.
- Pin workspaces and log streams to the region required by each data class, and choose cloud, VPC, on-prem or air-gapped per workload.
- Instrument a single audit pipeline and dashboard covering agent runs, tool calls, escalations and human overrides.
- Set an evaluation gate: no prompt, tool or model change reaches production without passing a regression suite.
Try it yourself
Open the agent workflow designer →
Reference architecture in one page
Four layers. Experience: the product surface where a user or service asks for an outcome. Orchestration: your agent loop, which owns state, retries, budgets and human approval. Gateway: a single service that authenticates to Plugsky with scoped keys, applies policy, selects the model and emits audit events. Tools: registry-backed functions with schemas, owners and risk tiers.
Plugsky contributes an OpenAI-compatible API, 30+ models, scoped keys, RBAC/SSO, region-locked planes and SIEM export. Everything above — tenancy, policy, evaluation, budgets — is yours to own. That split is deliberate: provider-neutral interfaces keep agents portable, while enterprise concerns stay where your governance already lives.
Governance that scales past the pilot
Most agent programmes fail on sprawl, not capability. Control it with artefacts: a tool registry that makes shadow functions visible, policy as code that reviewers can read, and evaluation suites that turn prompt changes into reviewable diffs. Assign each agent a named owner, a data classification and a kill switch.
- Blast radius: default tools to read-only; write and execute tools require explicit approval and a recorded justification.
- Budgets: cap steps and tokens per run so a looping agent cannot consume a quarter's capacity in an afternoon.
- Review cadence: treat agent prompts and tool schemas as versioned artefacts with the same change control as code.
Residency, audit and exit
Map every data class to a plane and keep inference, embeddings and logs together: EU (Frankfurt), GCC (UAE), APAC (Singapore) or US (Virginia), with VPC, on-prem and air-gapped tiers where required. Because the interface is OpenAI-compatible, exit is a base URL change plus model mapping — a strong negotiating position and a resilience property worth testing in a game day.
Instrument once: authentication and key events, administrative changes and per-run inference metadata stream to your SIEM, so an auditor can reconstruct who asked what, which tools ran and which human approved the outcome. Prove the pipeline on a pilot agent before it becomes the organiser of record for the whole programme.
Honest comparison
| Architecture concern | Plugsky | Typical managed agent platform | Building in-house |
|---|---|---|---|
| Interface | OpenAI-compatible endpoint across all models | Vendor-specific runtime | You define and version it |
| Model sourcing | 30+ models behind one alias system | Vendor catalogue | You serve each model |
| Policy enforcement | Scoped keys, RBAC/SSO; policy in your gateway | Vendor controls inside its runtime | Entirely your build |
| Residency | Region-locked planes plus VPC, on-prem, air-gapped | Limited region choices | Wherever you deploy |
| Audit | Key, admin and inference events exportable to SIEM | Vendor logs and dashboards | Your pipelines |
| Portability | Change base URL and model mapping | Rewrite against vendor runtime | Full control |
Frequently asked questions
Should every team call the API directly?
No. Put one gateway in front so keys, policy, model routing and audit events are centralised. Teams consume the gateway; they do not manage provider credentials.
How do we prevent agent sprawl?
Treat prompts, tools and evaluations as versioned artefacts with named owners. A registry plus a deployment gate surfaces shadow agents before they touch production data.
Where does authorisation belong?
Outside the model. The model proposes tool calls; your gateway and services decide whether the caller is permitted, and log the decision.
How should we choose between deployment tiers?
By data class and regulation, not convenience. Cloud for low-sensitivity workloads, VPC for most enterprise data, on-prem or air-gapped where processing must not leave your perimeter.
Can we mix models per workflow?
Yes. The same endpoint serves plugsky-micro, plugsky-lite, plugsky-pro and frontier models, so routing decisions are configuration rather than platform choices.
What makes exit realistic?
The OpenAI-compatible interface. Migrating means changing a base URL and mapping model names, so you can test portability without a rewrite.
How do we audit agent decisions?
Export authentication, key lifecycle, admin and inference metadata to your SIEM and correlate with application-level approval records. Prompt retention is configurable per workload.