Key facts
| Access control | Scoped API keys with rotation; enterprise SSO and RBAC options |
| Repo scoping | Separate keys and indexes per repository or team |
| Deployment | Cloud, VPC, on-prem or air-gapped for proprietary code |
| Auditability | Request, model and response logging for review trails |
| Data grounding | Embeddings and RAG are live for internal docs and code knowledge |
| Structured output | JSON mode returns review and triage records in fixed schemas |
| Models | 30+ models behind one OpenAI-compatible API |
| Pricing model | Flat monthly self-serve plans; no per-token billing on self-serve |
TL;DR
- Classify source code, secrets and customer data as separate concerns.
- Never let coding agents see secrets; scan and rotate if they do.
- Scope keys per repository so one team cannot read another's code.
- Keep AI-written code behind the same review as human code.
- Log model, prompt version and reviewer for release-relevant changes.
How it works, step by step
- Inventory AI use cases across coding, review, triage, docs and support.
- Classify content by IP value, credential content and customer-data exposure.
- Choose deployment per class: cloud, VPC, on-prem or air-gapped.
- Issue per-repository and per-tool keys with rotation and central inventory.
- Define log fields and retention: request ID, model, sources, output, reviewer, commit.
- Scan prompts and repositories for secrets, and rotate anything exposed.
- Keep AI-assisted code behind standard review, tests and provenance notes.
Try it yourself
Open the best model for coding selector →
Source code, SDLC and IP classification
Software content divides into open-source dependencies, internal libraries, proprietary product code, infrastructure configuration and credentials. Each class needs its own rule, and credentials should never enter an AI context at all.
Most teams start with public documentation and internal style guides, then extend to proprietary repositories only on deployments that keep prompts, code and embeddings inside the company boundary.
Keys, repositories and least privilege
Issue a distinct API key per repository, developer tool and environment, and keep retrieval indexes scoped so one team cannot query another's code. Store keys in a secrets manager, rotate on a schedule, and add secret scanning to pre-commit hooks and CI so credentials are caught before they reach a prompt or an index.
Treat any secret that entered a third-party model context as exposed and rotate it immediately, which is cheaper than debating whether it was logged.
Residency, retention and build audit trails
Decide where processing happens and how long records live. Region selection covers many needs; VPC, on-prem and air-gapped deployment covers companies with strict IP or customer-contract requirements. Retention applies to prompts, outputs, logs and retrieval indexes, and design decisions worth keeping should live in the repository, not in chat history.
Log enough to explain a release-relevant change: request ID, model and version, retrieved sources, output, reviewer and commit reference. See AI audit logs for a schema.
Model governance and code review
Keep an approved model list per task, with evaluation evidence for coding quality and instruction following, and re-test when versions change. AI-generated code passes the same review, test and licence checks as human code, and provenance notes help future maintainers. Keep release decisions with named engineers, and keep an eye on dependency and licence risk when assistants suggest packages.
Honest comparison
| Control area | Plugsky capability | Common gap | Owner |
|---|---|---|---|
| Repo scoping | Separate keys and indexes per repository | Cross-team code exposure | Platform security |
| Secret hygiene | Scoped keys plus scanning in CI | Secrets pasted into prompts | Security engineering |
| Data boundary | Cloud, VPC, on-prem or air-gapped deployment | Proprietary code sent to public tools | Engineering leadership |
| Audit trail | Request, model, reviewer and commit logging | AI changes untraceable | Release management |
| Licence risk | Human review of suggested dependencies | Copied code with unclear licence | Legal and OSS |
| Review | Citations and structured output for reviewers | Unreviewed AI pull requests | Tech lead |
Frequently asked questions
Does using Plugsky make us compliant?
No. Compliance is your program. Plugsky provides deployable controls - scoped keys, repo separation, private deployment, logging - that you document and audit against your own IP and customer obligations.
Can proprietary code stay inside our network?
Yes. VPC, on-prem and air-gapped deployment keeps prompts, code and embeddings inside your environment, and the API stays OpenAI-compatible.
What if a developer pastes a secret into a prompt?
Treat it as exposed: rotate the credential, check logs for misuse, and add secret scanning to pre-commit and CI so the next case is blocked before it leaves the developer machine.
Should AI code skip review?
No. AI-assisted changes pass the same review, tests and licence checks as any other code, with provenance noted for maintainers.
Can we index internal documentation?
Yes, in a separate index from code with permissions matching how the documentation is shared today.
Is fine-tuning available for our codebase?
Fine-tuning and batch endpoints are coming soon. Today, use retrieval over approved repositories and documentation with citations.
Where should a pilot start?
Pilot on public documentation and style guides with the free plan, verify quality and logging, then extend to proprietary code on private deployment.