# Cyber-tuned models like GPT-6-Cyber: who should get access?

URL: https://infro.io/blog/cyber-tuned-models-like-gpt-6-cyber-who-should-get-access
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-10
Last modified: 2026-11-10
Last reviewed: 2026-11-10 (next review due 2027-02-08)
Topic: Security and governance
Format: Guide

> Give a restricted cyber model to a named security team with a written mandate, in a dedicated project, environment and key set, with exact-ID allowlists everywhere else blocking it. Log who used it and why, and keep the payload-logging decision explicit.

Key takeaways:
- Decide eligibility by mandate and named people, not by team size or seniority; vendor-side vetting is a separate gate you cannot skip.
- Gating works by composition: an empty allowlist restricts nothing, so every ordinary project needs an explicit list or a block entry for the cyber model.
- Hold access by exact model ID; wildcards and block-only lists quietly extend access to models added later, including a retiring model's successor.
- Put the gated connection in its own environment and project, with its own keys, so usage and audit events are separable.
- Decide the payload-logging question for cyber prompts deliberately: they can hold unpatched vulnerability detail, so logging them is itself a risk.

## What this guide covers, and what it does not

Restricted cyber models are a new request type for governance teams. A developer asks for GPT-6-Cyber, someone else asks for Daybreak Red on Bedrock, and a third team is still calling a cyber preview model that is being retired. The general question of which models a project may call is covered in [model access governance](https://infro.io/blog/model-access-governance). This guide covers what is different when the model is gated by its vendor and its purpose is offensive or defensive security work.

One limit up front. The vendor pages for these models were not readable when this was written: OpenAI's page returned a 403, and I did not read a vendor page for Daybreak Red or the retiring preview. So nothing below states what any vendor requires, charges or retires on. Where a vendor rule matters, the step is to ask for it in writing and put the answer in the approval record. The controls that follow are the ones you own at your gateway and your cloud account, and they work whatever the vendor's terms turn out to be.

## Who should get access

Treat the vendor's gate and your gate as two separate decisions. The vendor may verify your organization, or particular accounts or people. Whatever it does, that check does not tell you which of your engineers should hold the capability. Ask the vendor three things and record the answers: what is verified, whether the approval attaches to the organization, the account or the individual, and what happens to access when a person leaves or the use changes.

For your own decision, use a mandate test. A request qualifies when all of these hold:

- A named team has a written security function that needs the model: vulnerability research, detection engineering, malware analysis, red-team tooling, or incident response.
- The people are named, not "the platform team". Access is a list of individuals with a manager's sign-off.
- The work happens in a scoped project with its own environment, not inside a product's production traffic.
- A human reviews outputs before they touch a system you do not own.

Three patterns should be refused by default. First, customer-facing features: if end users can prompt the model, you have handed a gated capability to people you have not vetted. Second, unattended agents in CI or scheduled jobs with no named owner, since nobody is accountable for a 3 a.m. run. Third, "just in case" access for a whole engineering org. A cyber model is not a better general model; it is a model with a different risk profile, and the approval should say what the person will do with it.

## Fence it by composition, not by one switch

An allowlist only restricts when it is non-empty. INFRO's documented rule is that each non-empty allowlist narrows access, a model must satisfy every applicable organization, project and key policy, and an empty list at one scope imposes no additional restriction.[1] Two consequences follow for gated models.

1. **You cannot grant at the project what the organization list blocks.** A model has to pass all scopes, so an organization-level block on the cyber model also blocks your security project. Leave the organization list permissive for this model and do the fencing at project level.
2. **A new project with an empty list can call everything the organization allows.** If an ordinary product team creates a project and never sets a list, the cyber model is in reach. The fence has to be on every project, not only on the one that should use the model.

So the pattern is: the security project carries a positive list naming the cyber model by exact ID; every other project carries either a positive list of the models it was approved for, or an explicit block entry. Block entries use a `!` prefix and always win over allow entries in the same list.[1] A block-only list allows every other model, including models added to the catalog later, so a positive list is the safer default for ordinary projects.[1]

```json
["<vendor>/<cyber-model-id>"]
```

```json
["<vendor>/<approved-general-model>", "!<vendor>/<cyber-model-id>"]
```

The IDs above are placeholders; use the catalog IDs your organization sees. The same field, `model_allowlist` with up to 500 entries, can be set on organization settings, projects and gateway keys through the management API and the Terraform provider.[1] Set it in code at project creation so no project exists without one, and run a scheduled check for projects whose list is empty.

A denied model returns HTTP 403 with `error.code: "model_not_allowed"`, and the message names which list refused it.[1] That message is useful evidence. Route targets are checked against the same lists, and a route whose every target is outside them is refused with a 503 `no_available_provider`.[1] A named route is therefore not a way around the fence, but do not rely on that: keep the cyber model out of general routes altogether.

### Hold access by exact ID

Avoid wildcards such as a whole-vendor entry for anything near this model. A vendor wildcard grants every model the vendor ships later, including a successor cyber model you have not reviewed. This matters for the retiring preview: its replacement is a new approval, with its own record, not an inherited entitlement. If your gateway records vendor deprecations and refuses a model from its shutdown date while naming the replacement, as INFRO's model lifecycle does for models it tracks, that tells the caller what changed. It does not tell your governance team that the replacement is approved. Confirm the retirement date of the preview from the vendor's own deprecation page before you plan the cutover.

## Scope keys, projects and environments

Allowlists say which model; the rest of the structure says who and where.

- **A dedicated environment.** INFRO environments start with production, staging and development and allow your own beside them; a connection serves one, several or every environment, and each gateway key belongs to exactly one and never reaches a connection outside it. Create a separate environment for security research and attach the cyber model's provider connection only to it. A production key then cannot reach the model even if someone edits an allowlist wrongly.
- **A dedicated project and keys.** One project for the security team, with gateway keys per tool or per person where practical. Apps use gateway keys, not the provider credential.
- **Project-restricted members.** An owner or admin can limit a developer or analyst to some projects, so that they read those projects' requests and manage keys in them while the gateway refuses everything organization-wide. Reviewers outside the security team can be given the same read-only slice.
- **Key controls and budgets.** Restrict keys to chosen providers or IP ranges, rotate with an overlap, and set a hard cap per project and key. A cyber tool that loops costs money like any other agent.
- **Separation of duties.** Anyone who can create a gateway key can set that key's own allowlist.[1] The approver of the request should not be the admin who creates the key.

### If the model is on Bedrock

Bedrock adds its own account-level gate. The AWS documentation says some models need additional account-level access that activation steps such as a subscription do not grant, that access is determined separately for each AWS account so accounts in one AWS Organization can differ, and that an `AccessDeniedException` after completing activation means contacting AWS Sales.[2] I could not confirm whether Daybreak Red falls in that category, so ask AWS and record the answer.

AWS also describes a control pattern worth using for any new gated model: organizations that need to review a license agreement before use should block model access with service control policies or IAM policies first, review the terms, and enable access only if they agree.[2] For third-party models that have a product ID, the Subscribe permission can be restricted by that product ID. Some providers' models have no product key, and for those AWS says to deny by model ID in the resource field instead.[2] Do this in the account that will hold the model, not the organization root, and keep that account separate from the ones product teams use.

## What the reviewer will want

A reviewer, internal audit or an outside assessor, will not ask whether the model is "secure". They will ask who could use it, who did, and how you know the answers are complete. Prepare these artifacts before the first request is approved.

| Question | Evidence | Source |
| --- | --- | --- |
| Why does this person have access? | Approval record: named person, mandate, manager sign-off, vendor's verification answer, expiry date | Your ticketing system |
| Who could call the model? | Export of every project and key allowlist; list of projects with empty lists (should be none) | Management API reads, Terraform state |
| Who changed that? | Audit events for key, project and policy changes, with actor and timestamp | INFRO audit log |
| Who actually called it? | Request log filtered to the security project: model, key, timestamps, estimated cost | Request and usage exports |
| Was it called from outside the fence? | Denied requests with `model_not_allowed`; provider-side usage for the account | Request log, provider console |
| Did access end when it should? | Key revocations and member removals matched to the expiry dates | Audit log |

Table: Evidence for a gated cyber model, and where it comes from.

The INFRO audit log records changes to gateway keys, provider connections, routes, projects, policies and memberships, with actor, action, target and timestamp, and it is separate from request traces.[3] It can be read from your own tooling with `GET /manage/v1/audit_events` and a token holding the `audit:read` scope, with filters including `q`, `action`, `actor`, `from` and `to`.[3] The same documentation says there is no CSV file of the audit log, so plan for a scripted JSON pull on the review date.[3] Request records can be read through `GET /requests` with the `analytics:read` scope; the management API never returns prompt or completion content whatever the capture setting.[4]

Notice what is missing: audit events describe administrative changes, not inference.[3] The reviewer's question "what was the model used for?" is answered by the approval record and the request metadata, not by the audit log.

## The logging decision

Prompts to a cyber model can contain unpatched vulnerability details, exploit code, customer network data or credentials found during an engagement. A payload log that keeps them is a new sensitive store. Prompt and completion logging in INFRO is off by default, with a retention window you choose, so the default leaves you with metadata only: who, when, which model, how many tokens, what it cost. Decide per project:

- **Metadata only** for most teams. It answers who used what, and when, and it is enough for most reviews.
- **Payload logging with short retention and restricted readers** only where a defined investigation need exists, such as a red team that must reproduce what a tool sent. Write down the retention window, who may read it and who approved it.
- **Never** in a shared project that also holds ordinary traffic.

Write the decision in the approval record. A reviewer who finds payload logging on without a stated reason will treat it as a finding; one who finds it off will ask how you investigate, so have the answer ready. The [prompt logging policy guide](https://infro.io/blog/llm-prompt-logging-policy) covers the general case.

## Revocation, retirement and drift

Access to a cyber model should expire. Put an expiry on every approval and tie it to a review, not to goodwill. When it passes, remove the person from the project and rotate or revoke their keys; both land in the audit log.

Watch the vendor side too. INFRO reads the model list your own provider key returns every three hours and stops offering a model your key has stopped listing, with the date it stopped. If a vendor withdraws your account's access, that date is a record you can attach. For the retiring preview, set an internal cutoff earlier than the vendor's date, move named users to the replacement only after its approval is complete, and check the request log for callers still sending the old ID.

> **Note: Scope of this guide**
> Eligibility, rates and retirement dates for GPT-6-Cyber, Daybreak Red and gpt-5.5-cyber-preview are vendor facts that were not confirmed here. Get them from the vendor in writing and keep the answer with the approval.

## Where a gateway helps, and where it does not

A gateway is one enforcement point for the allowlists, key scopes, budgets and request records above, instead of relying on each codebase to read a policy. INFRO provides model allowlists by organization, project and key, environments, project-restricted members, key limits, budgets, an audit log and request exports, on the provider accounts you already hold. It does not verify your people to the vendor, decide eligibility, or judge what a model's output does once it leaves your tooling. Those stay with your security leadership and the vendor.

A short checklist to close the review:

- [ ] Vendor verification answer recorded, including what it attaches to.
- [ ] Named people, mandate and expiry in the approval record.
- [ ] Dedicated environment, project and keys; connection attached to that environment only.
- [ ] Every other project has a positive allowlist or a block entry; none is empty.
- [ ] Exact model IDs only; no vendor wildcards near the model.
- [ ] Payload-logging decision written down.
- [ ] Audit and request exports scripted and tested before the review date.
- [ ] Cutoff date set for the retiring preview, with the replacement approved separately.

## Questions

### Should the cyber model be a fallback target for a general security route?

No. A failover that lands a request on a model with different behavior and different access terms is a change nobody approved. Keep the cyber model in its own route, with its own fallback policy, and let the route's targets be subject to the same allowlists as direct calls.

### Can one person hold both the approval and the key-creation rights?

Avoid it. Anyone who can create a gateway key can set that key's own allowlist, so key creation is a real permission. Separate the approver of the access request from the admin who creates the key, and let the audit log show both steps.

## Sources

1. Model allowlists — INFRO Docs. https://infro.io/docs/org/model-allowlists (accessed 2026-11-10)
2. Request access to models - Amazon Bedrock User Guide — Amazon Web Services. https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html (accessed 2026-11-10)
3. Audit log — INFRO Docs. https://infro.io/docs/org/audit-log (accessed 2026-11-10)
4. Management API resources — INFRO Docs. https://infro.io/docs/manage/resources (accessed 2026-11-10)
