App: App admin and operator pages: Hub, compute, account and administration.
# Chat models
> Choose from platform-configured inference models and add provider models that use your own API keys.
import { Aside } from '@astrojs/starlight/components';
Chat models shows everything you can pick in the assistant picker, the TUI model switcher, and any other surface that asks "which model do you want to run this on?". Platform (`dn/*`) models are supplied by your deployment and follow your organization's access rules. This surface also manages your **account-scoped BYOK list**: models from other providers that you add and run with your own API keys.
```text
Account Settings → Chat Models
```
```
Platform models
┃ Model ┃ Provider ┃
┇ dn/claude-opus-4-6 ┇ Dreadnode ┇
┇ dn/gpt-5.2 ┇ Dreadnode ┇
Your models
┃ Model ID ┃ Provider ┃ API Key ┃
┇ anthropic/claude-opus-4-6 ┇ Anthropic ┇ Set ANTHROPIC_API_KEY in the shell where you run the TUI ┇
```
## What the preference controls
Your BYOK additions are separate from platform `dn/*` models. Platform models come from admin-configured deployments and are scoped by the [organization member allowlist](#organization-member-model-access-owners). Every surface that picks a model shows the platform set plus your BYOK additions:
- The web assistant picker and the TUI's `Ctrl+K` picker group platform models first, then your BYOK models.
- The TUI's `/models` command can search the broader catalog for one-offs outside your list.
An empty BYOK list is the default — you get the platform models available to your account and nothing else. A fresh self-hosted deployment may not have platform models yet.
## Model namespaces
| Namespace | Where it runs | What you need |
| ----------------------------------------------------------------- | ----------------------------------------- | -------------------------------------------------------------------------------------- |
| `dn/` | Platform-configured inference | An active admin-managed deployment; SaaS usage consumes [credits](/platform/credits/). |
| `openai/`, `anthropic/`, `openrouter/`, etc. | The provider's API, using your key (BYOK) | The provider's API key available where your session runs. |
When an admin adds or removes a `dn/*` deployment, Chat models updates automatically.
BYOK models resolve their provider key from the environment your chat session runs in — for TUI chat that's your local shell (e.g. `export ANTHROPIC_API_KEY=...`). The settings surface tells you which key each BYOK model needs; it can't verify your local environment. It does show whether the key is saved in [Secrets](/platform/secrets/) for **remote agent runs** — keys stored there never reach local chat sessions; they're injected only into the remote runs you select them for (`secret_ids`). If a remote agent run uses one of your BYOK models, add the provider key as a Secret (each row links straight there) and select it when provisioning.
## Organization member model access (owners)
Organization owners can optionally restrict which `dn/*` models specific members can run from:
```text
Settings → Members → Model access
```
- **Allow all platform models** gives the member access to every configured platform model
- Turning that toggle off lets owners pick an explicit per-member `dn/*` allowlist
- Saving with no models selected denies access to platform-hosted models for that member
Owners always keep access to all configured platform models and cannot be restricted from the member table.
When restrictions are active for your account, the TUI `/models` browser shows:
> Your org has restricted available models. Contact your org owner for changes.
## Add, remove, or reset
Use the model browser in the Chat Models section of Account Settings to search the full catalog server-side — typing runs the query against all published models, not a local slice. Enable the ones you want; remove a model from **Your models** when you stop using it. Platform models can't be removed here; organization owners manage member access to them.
**Reset to defaults** clears your BYOK list entirely, returning you to the configured platform set.
Adding a model validates the ID against the catalog, so typos and unrecognized IDs are rejected. Ad-hoc IDs that aren't in the catalog must pass the compatibility check in the model browser.
When a model is missing upstream metadata, Dreadnode generates a readable name from the ID and preserves dotted version segments (for example, `claude-opus-4-5` displays as `Claude Opus 4.5`).
## Chat models vs the registry
These are different resources that share a noun:
| Surface | Scope | What it manages |
| ------------------------------------ | --------------- | -------------------------------------------------------------------------- |
| Chat models (this page) | User preference | Which **BYOK inference** model IDs appear in your picker alongside `dn/*`. |
| [Models registry](/models/overview/) | Org registry | Versioned **weight artifacts** published from training or curation. |
A registry push (`dn model push ./support-assistant`) doesn't automatically make the artifact available as a chat model — those are stored weights, not hosted inference endpoints. Serve an artifact yourself (vLLM, Ray Serve, a managed endpoint) before it becomes a `--model` target.
## Chat models vs session picking
Chat models sets what's **available**. Session-time picking chooses from it:
- [Agent & model](/tui/agent-and-model/) covers `Ctrl+K`, `/model`, per-agent overrides, and thinking-effort tuning.
- Evaluation and runtime launches pass `--model ` and select from the available set.
- The TUI's `/models` command can still search the broader catalog for one-off testing outside your list.
## Related
- [Self-hosted model deployments](/self-hosting/model-deployments/) — how platform admins create and route `dn/*` models
- [Secrets](/platform/secrets/) — provider keys for remote agent runs
- [Credits](/platform/credits/) — hosted inference pricing, usage, and organization balances
- [Agent & model](/tui/agent-and-model/) — picking a model for the session in front of you
- [Models](/models/overview/) — versioned artifact registry (distinct from inference)
# Credits
> Calculate hosted inference costs, track usage, and keep SaaS workloads running with organization credits.
import { Aside } from '@astrojs/starlight/components';
Credits are the shared balance your organization uses for metered workloads on Dreadnode SaaS. A
hosted model call, a running sandbox, or another metered service deducts from the same balance.
## What consumes credits
| Workload | How usage is measured |
| ----------------------------------- | ---------------------------------------------------------------- |
| Dreadnode-hosted inference (`dn/*`) | Successful model calls, using their input and output token rates |
| Sandboxes | Runtime while a sandbox is active |
| Hosted web search | Successful search calls |
| Telemetry | Ingested spans and stored telemetry data |
Models that use your own provider key (BYOK), such as `openai/*` or `anthropic/*`, do **not** use
Dreadnode credits. The provider bills those calls to your account instead.
## Calculate an inference call
Each `dn/*` model has separate rates for input and output tokens. Rates are quoted per 1 million
tokens. Convert both token counts to their dollar cost, add them together, then convert the total at
**1,000 credits per $1 of inference cost**:
```text
input cost = input tokens / 1,000,000 × input rate
output cost = output tokens / 1,000,000 × output rate
credits = round up((input cost + output cost) × 1,000)
```
Every successful hosted inference call costs at least 1 credit.
For example, `dn/claude-sonnet-4-6` is priced at **$3 per 1M input tokens** and **$15 per 1M output
tokens**. A call using 2,000 input tokens and 500 output tokens costs:
```text
input: 2,000 / 1,000,000 × $3 = $0.0060
output: 500 / 1,000,000 × $15 = $0.0075
total: $0.0135
credits: round up($0.0135 × 1,000) = 14 credits
```
Use the rate shown for your selected model rather than treating the example rates as a price list.
Hosted inference is charged after a successful call, using its actual input and output token counts.
Failed and zero-cost calls do not consume inference credits.
## Find rates and usage
Use the product surfaces for current rates and recorded usage:
- Open **Account Settings → Chat Models** to compare model input and output rates in dollars per 1
million tokens.
- Press `Ctrl+K` or run `/models` in the TUI. `dn/*` rows show input/output rates in credits per 1
million tokens; BYOK rows show provider rates in dollars.
- Open **Settings → Billing** to see your remaining organization balance and low-balance warning.
- In **Inference Usage**, choose a date range to see requests, input tokens, output tokens, credits,
and cost by model. Organization owners can also inspect each member's usage.
- Use **Transaction History** for credit purchases, allocations, auto-refills, refunds, and other
balance changes. The Billing page also summarizes sandbox and hosted web search usage.
The Billing page displays the current sandbox runtime rate. At the default SaaS rate, **1,000 credits
is about 5 hours of sandbox runtime**.
## Keep the organization funded
Your organization has one credit balance shared by every member. Purchases and signup allocations
add to that balance; metered workloads deduct from it. Purchased credits do not expire.
Signup credits depend on your account's signup eligibility. An account under review remains active
and can sign in, view billing, and purchase credits, but it receives no signup allocation and cannot
start or restart metered work. Approval or a successful credit purchase makes the account eligible
and claims the current signup allocation once. This restriction applies to the person who starts the
work, so another eligible member can still use the organization's shared balance.
Organization owners can set one **Org-level member credit cap** under **Settings → Billing**. The
lifetime cap applies automatically to every current and future non-owner member across sandbox
runtime, hosted inference, and hosted web search. The member usage table shows consumed credits and
the remaining allowance. Owners are exempt.
When a cap applies, each capped member sees their own remaining allowance on their **Settings →
Billing** page alongside the shared organization balance, so they know how much of the cap is left
without owner access.
Removing the cap restores access to the shared organization balance without resetting recorded
member usage. Re-enabling the cap resumes from that usage, including when a member leaves and later
rejoins. Usage that would exceed the cap is rejected, and the affected member's running sandboxes
pause without blocking other members.
### Control credit defaults
Platform administrators can change the signup allocation that eligible SaaS users claim under
**Platform Admin → Billing**. Enter a non-negative whole number and a reason, then confirm the
change. Set the allocation to `0` to stop new claims immediately without changing existing balances
or transactions.
Each eligible account can claim this allocation once for its personal organization. Later allocation
changes affect only accounts that have not completed a claim; they do not change existing balances.
The page shows whether the active value comes from deployment configuration or an administrator
override. It also shows the last change, including the administrator, reason, previous value, and
new value. The configured `CREDITS_SIGNUP_ALLOCATION` value applies until the first override is
saved; later changes take effect across API instances without a restart.
Platform administrators can also change the low-balance warning threshold from the same page. The
configured `CREDITS_LOW_BALANCE_THRESHOLD` value applies until the first override is saved. Enter a
non-negative whole number and reason, then confirm the change. New balance checks use the updated
threshold across API instances without a restart; existing balances do not change.
To take back free signup credits that organizations have not spent, platform administrators with
the account remediation scope can use **Remove unused signup credits** in the same **Signup Credit
Allocation** section. The dialog lists how many organizations still hold unused signup credits and
how many credits that is. **Download as CSV** saves the list with each organization's owner emails.
Type the organization count to confirm the removal.
The action removes only what is left of each organization's signup grant. Purchased credits and
credits granted by an administrator stay, because free credits count as spent first. Each affected
organization gets one `admin_adjustment` entry in its transaction history. If the list changes
before you confirm, the dialog shows the new count and removes nothing. The removal has no bulk
undo. Grant credits back to a single organization if you remove them by mistake.
### Close credit purchases
Platform administrators can turn on **Close credit purchases** under **Platform Admin → Billing**.
The change applies on the next request, with no deploy or restart. While it is on:
- **Settings → Billing** shows a **Credit purchases are closed** note, no **Buy Credits** button,
and no **Auto-Refill** section. The sidebar credits button reads **Credits** instead of
**Buy credits**.
- Checkout returns `403` with `Credit purchases are closed.`
- Auto-refill makes no charge. Each organization keeps its saved auto-refill setting.
Balances, usage, the transaction list, and receipts work as before. Turn the switch off to reopen
purchases.
A Stripe checkout page opened before the switch was turned on stays payable for up to 24 hours. If
the buyer pays, Stripe charges the card and the organization still receives the credits.
### Control signup abuse decisions
Platform administrators can edit the active signup abuse policy under **Platform Admin → Security →
Signup Abuse Policy**. The editor controls score thresholds, local signal rules, Account Defender
mappings, fail-safe actions, and the master soft-enforcement switch.
Disabling soft enforcement stops policy-driven scoring and actions. Independent hard blocks, such
as explicit network denies and invalid challenge tokens, continue to apply.
The signup IP policy API also controls the first-party signup-session throttle. SaaS defaults to five
admitted attempts per signed browser session in 15 minutes. Failed admitted attempts count toward
the limit, and a blocked credential or OAuth signup returns `429` with a `Retry-After` header. Shared
office networks and browser families provide review context but do not block signup by themselves.
Use `PUT /api/v1/admin/auth/signup-ip-policy` to change `session_throttle_enabled`,
`max_attempts_per_session`, or `session_window_seconds`. The API accepts 1–100 attempts and windows
from 60–86,400 seconds. These session controls apply only to SaaS. Enterprise signup skips local
signal admission but retains CIDR policy and the rolling 24-hour IP limit.
Enter a publication reason and confirm the complete policy before publishing it. Each successful
publication creates an immutable version and audit entry. If another administrator publishes first,
reload the active policy and review it before applying your changes again; the editor never
overwrites a newer version automatically.
The signup abuse policy editor is available only on Dreadnode SaaS. Enterprise deployments do not
show or apply this policy.
### Auto-refill
Enable auto-refill under **Settings → Billing** to add credits when the balance falls below a chosen
threshold. Organization owners choose the threshold, refill quantity, and monthly cap. Auto-refill
requires a saved payment method from an earlier purchase.
If a refill payment fails, auto-refill turns off. Update the payment method and enable it again from
the Billing page.
## When credits run out
A zero balance stops new `dn/*` inference requests and prevents sandboxes from starting or resuming.
Running durable sandboxes pause so you can resume them after adding credits; running ephemeral
sandboxes stop. Telemetry ingestion and package uploads also remain blocked until the balance is
positive.
Because the platform calculates hosted inference usage from the completed response, the final call
can cost more credits than remained before it started. The organization balance still stops at zero.
# Export your data
> Download your capabilities, task environments, datasets, models, chat sessions, evaluations, and AI red teaming findings.
Each kind of data has its own export path. This page shows one representative command or action for
each, and links to the page that has the details.
## Before you start
[Install the CLI and run `dn login`](/getting-started/quickstart/). For sign-in options, see
[Authentication](/getting-started/authentication/).
## Capabilities and task environments
Pull every capability and task environment in your organization into local directories:
```bash
dn capability sync https://app.dreadnode.io ./capabilities
dn task sync https://app.dreadnode.io ./tasks
```
If you self-host Dreadnode, use your own platform URL.
Export a task set with its member task environments:
```bash
dn task-set pull ./task-sets --with-members
```
See [Loading Hub content](/self-hosting/loading-hub-content/), [`dn capability`](/cli/capability/),
[`dn task`](/cli/task/), and [`dn task-set`](/cli/task-set/).
## Datasets
```bash
dn dataset list
dn dataset pull --output
```
Datasets have no bulk export. Pull them one at a time. See [`dn dataset`](/cli/dataset/).
## Models
```bash
dn model list
dn model pull --output
```
Models have no bulk export. Pull them one at a time. See [`dn model`](/cli/model/).
## Chat sessions
In the App, open the session, choose **More actions**, then copy or download the transcript. From
the CLI:
```bash
dn session export
```
Sessions export one at a time. See [Sessions](/chat/sessions/) and
[`dn session`](/cli/session/).
## Evaluations
In the App, open the evaluation and click **Download all logs**. From the CLI:
```bash
dn evaluation export
```
Evaluations export one at a time. See [Running evaluations](/evaluations/running/) and
[`dn evaluation`](/cli/evaluation/).
## AI red teaming
In the App, click **Download Parquet** on the findings table. For PDF and CSV reports, open
**AI Red Teaming > Reports**.
Findings export one project at a time. See [Export](/ai-red-teaming/platform/export/) and
[Reports](/ai-red-teaming/platform/reports/).
## Secrets
Secret values can't be exported. See [Secrets](/platform/secrets/).
# New navigation (beta)
> Use the app's new navigation, where each project has its own row of tabs, and find where the sidebar's pages moved.
import { Aside, Icon } from '@astrojs/starlight/components';
In the new navigation, a project has everything you need in one row of tabs: its Overview, chat,
sessions, Labs runs, workflows, AIRT assessments, memories and staged findings. The left sidebar goes
away, which gives you more room to work. A top bar holds the organization menu, which takes you to
Workbench, Hub and Settings, along with search, documentation, feedback and your account settings.
## Where Dreadnode opens
When you sign in or go to the app's URL, Dreadnode opens in the new navigation, unless you've
switched back to the current one. Every other link, bookmark or reload opens the page it points to,
in the navigation that page belongs to. Your choice is saved on your account, so it applies on every
browser and device.
## Switch navigations
Select **Try it** on the announcement, or turn on **Use the new navigation** in **Account settings ›
Preferences**. To go back, use **Back to current experience** on the
announcement or turn the switch off.
Until late November 2026, you can switch either way and keep one of each open in separate tabs.
For self-hosted deployments, your navigation experience is dependent on when your version is
updated by your administrator.
## Send feedback
Say what's missing, or harder to find than in the current navigation. Select
**Feedback**, the speech-bubble icon at the right of the top bar, to open **Send Feedback**. The
page you're on is sent with it. In the current navigation, **Feedback** is at the bottom of the
sidebar.

If you don't see **Feedback**, your deployment doesn't have this feature turned on. Instead email
your feedback to [support@dreadnode.io](mailto:support@dreadnode.io).
## Where things moved
| In the current navigation | In the new navigation |
| ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Home | A project's **Overview** tab |
| Chat | A project's **Chat** tab |
| Agents: Sessions, Output, Staged Findings and Memories | A project's **Sessions**, **Output**, **Staged Findings** and **Memories** tabs |
| Workflows | A project's **Workflows** tab |
| AI Red Teaming | A project's **AIRT** tab, a menu of Overview, Assessments, Traces and Reports |
| Evaluations, Optimization, Training, Worlds' Manifests, Trajectories and Jobs | A project's **Labs** tab, which lists every kind of run together |
| Capabilities, Environments, Datasets and Models | **Hub**, from the organization menu |
| Settings, Sandboxes and Agent Policies | **Settings**, from the organization menu |
| Platform Admin | The organization menu, for platform admins |
| Analytics: Query and Notebook | Not in the new navigation. They go with the current navigation. |
## Search and keyboard shortcuts
Press ⌘K (Ctrl+K on Windows and Linux) or ?, or select **Search** in
the top bar, to jump to a page or run an action. On a project's **Labs** tab, search lists that tab's
actions first, each with the key that runs it from the page: r refreshes, n
starts a new run, / searches runs, and j and k move to the next and
previous run. In the current navigation, Evaluations, Optimization, Training and Worlds list their
keys in a **Keyboard shortcuts** dialog instead.
## Take the tour
The first time you open the new navigation, a short tour points at each of these controls, then at the
ways to start a session from a project's **Overview**. Press Esc or select **Skip tour** to
leave it at any step. It won't start again on another device. If you open a menu the tour is pointing
at, the tour moves beside it until you close it.
Replay it any time from the organization menu with **Take the tour**, or search for "Take the tour".
# Organizations
> Understand how organizations group users, workspaces, and billing on Dreadnode.
Organizations are the top-level ownership boundary on Dreadnode. Everything else starts here:
membership, workspaces, credits, billing, and most platform URLs.
If you only need the hierarchy and boundary model, start with the [Manage
overview](/platform/overview/). This page is the organization deep dive.
## What an organization is
An organization represents a team, company, or group that shares access to the platform. Each organization has:
- A unique `key` (URL slug) used in API paths and URLs
- A display `name`
- A member list with role-based access
- Workspaces that contain projects
- Billing and usage context in SaaS mode
In practice, the organization is the answer to "who owns this work?" The workspace then answers
"who inside that owner should collaborate on it?"
## Workflow: how organizations enter daily work
Organizations show up earlier in the product than many users realize.
1. During onboarding, Dreadnode validates your username and, in SaaS mode, your organization name.
2. The app redirects you into an organization-scoped URL.
3. Settings, membership, workspaces, registry pages, and billing all use that active organization
context.
4. TUI and CLI profiles carry a default organization so later commands can resolve workspaces and
projects underneath it.
If you are debugging a context mismatch, the organization is the first thing to verify.
## Membership and roles
Users are added to an organization as members. Each member has a role that determines their permissions:
| Role | What they can do |
| ----------- | ------------------------------------------------------- |
| Owner | Full access — manage members, workspaces, billing, keys |
| Contributor | Create and manage workspaces and projects |
| Reader | View workspaces, projects, and traces |
Organization role is not the same thing as workspace permission. A user can be a broad org-level
member and still have limited access inside a specific shared workspace.
### Invitations
Organization owners can invite users by email. By default, Dreadnode sends an invite email with an acceptance link in the format `/accept/:inviteId`. Recipients can use the same link whether they already have an account or need to sign up first. New users are prompted to create an account and verify their email before accepting the invitation. When signups are closed, existing accounts can still sign in, and invitations work only for emails that already have an account.
Invitations have an expiration window and can be accepted or rejected by the recipient. API callers can disable email delivery (`send_email=false`) when they only need to generate or copy an invite link. External invites can be toggled on or off per organization.
Organization invitations and member management (role updates, removals) are available on all plans and require the **Owner** role.
Removing a member revokes their access to the organization and its workspaces, and deletes the
workspaces they solely own in that organization. Their Dreadnode account and completed onboarding
state remain intact. If they have no other organization memberships, the app shows **No active
organizations** until an owner invites them to another organization.
### Member status
Each row on the **Members** page carries a status. Members you have invited show as **invited**
until they accept, and as **expired** or **declined** if they never do.
A member marked **suspended** has had their Dreadnode account suspended by a platform
administrator. They keep their membership and role, but they cannot sign in, and their API keys
have been revoked. Suspension is account-wide rather than per organization, so it is not something
an organization owner can lift — contact your platform administrator. You can still remove a
suspended member from the organization if you no longer want them on the roster.
### Member model access
Organization owners can also set per-member access to platform-hosted `dn/*` models from the **Members** page.
- Use the **Model access** action on a member row.
- Leave **Allow all platform models** on for unrestricted access (`null` allowlist).
- Turn it off to choose a specific allowlist.
- Saving an empty allowlist denies all platform-hosted models for that member.
Owners always have access to all platform models, so owner rows (and your own row) are read-only for model-access editing.
### Teams
Teams are the bridge between organization membership and workspace access.
- You organize members into reusable groups at the organization level.
- You grant those teams access to shared workspaces.
- Workspace access then flows from that team assignment instead of having to be managed user by
user every time.
## Organization limits
Each organization has a configurable maximum member count (default: 500).
## Managing organizations
- **Display name:** Update the organization display name from Settings (owner role required).
- **Avatar:** Owners can choose one of five fixed colors or upload a PNG, JPEG, or SVG up to 2 MB. An uploaded image appears alongside the color swatches as one more option, and the option you pick is marked with a check. Whatever is marked is what the avatar shows; the preview beside the options reflects it. After selecting a file, the crop opens fitted to the whole image — move the square selection and drag its corners to crop in, then select **Apply crop**. SVG crops stay in vector format; PNG and JPEG crops are saved as 512 × 512 PNGs. Select **Save** to upload the crop, apply a color, or confirm image removal. Canceling keeps the current avatar. The organization selector updates as soon as the save succeeds. Switching between a color and an image only changes which one is shown — the other is kept, so you can switch back at any time without re-picking or re-uploading. Select **Remove image** to delete the image, which leaves the avatar on your chosen color, or on the organization-name initial if you have none.
- **Default sandbox runtime:** Owners can set or clear an organization default runtime for new sandbox sessions. Leaving it empty inherits the org maximum.
- **Members:** Manage members, update roles, adjust per-member model access, and remove members from the organization settings page.
- **Teams:** Organize members into teams for workspace access control.
- **Workspaces:** Create and manage workspaces within the organization.
The App settings shell is the main operator surface here:
- `General` for org identity and default sandbox runtime
- `Members` to Manage members
- `Workspaces` to shape collaboration boundaries
- `Billing` for SaaS credit-backed usage
### Availability checks
During onboarding, the platform validates usernames and organization keys in real time. Organization keys only need to be unique among other organization keys (they can overlap with usernames).
The organization key `beta` is reserved and cannot be selected during onboarding. Keys such as `beta-team` are allowed.
### Hub pages
The org sidebar includes a **Hub** section for org-scoped package types:
- [Capabilities](/capabilities/overview/) for published agent, tool, skill, and MCP bundles
- [Security Tasks](/evaluations/tasks/) for reusable execution environments and verification logic
- [Datasets](/datasets/overview/) for versioned dataset artifacts
- [Models](/models/overview/) for versioned model artifacts
These pages are scoped to the active organization URL and show the versions currently published into that org.
## Relationship to other concepts
```
Organization
├── Members (users with roles)
├── Invitations (pending)
├── Workspaces
│ ├── Projects
│ │ ├── Sessions
│ │ └── Traces
│ └── Permissions (user + team)
├── Sandboxes (org-scoped)
└── Credits (SaaS mode)
```
# Manage
> The org, workspace, and project context behind the platform, plus the settings, secrets, and credits that govern it.
import { Aside } from '@astrojs/starlight/components';
Manage is where the platform's boundary model and operator controls come together.
Use it when the question is:
- which organization, workspace, or project am I actually working in?
- who can access this area?
- where do settings, chat models, secrets, and credits live?
## Context chain
```text
Organization
-> Workspace
-> Project
-> Workflow surfaces
```
| Layer or control surface | Primary role |
| ------------------------ | ---------------------------------------------------------------- |
| Organization | top-level ownership, membership, and billing boundary |
| Workspace | access boundary and collaboration area |
| Project | grouping context for runs, traces, evaluations, and related work |
| Settings | org-facing configuration pages in the app |
| Chat Models | user-scoped assistant model preferences |
| Secrets | user-owned credentials injected into compute |
| Credits | SaaS usage and billing controls |
## Common workflows
- confirm the correct org, workspace, and project before launching work
- update access boundaries and sharing rules
- manage provider credentials, model preferences, and billing controls
- answer "why can this person see this?" or "why did this workload run here?"
## What agents should assume
- organization, workspace, and project materially change what artifacts and runs are visible
- projects are context, not permission boundaries
- settings is a shell that groups several operator surfaces rather than one API object
For the individual control surfaces, use [Settings](/platform/settings/),
[Organizations](/platform/organizations/), [Workspaces](/platform/workspaces/),
[Projects](/platform/projects/), [Secrets](/platform/secrets/),
[Chat models](/platform/chat-models/), and [Credits](/platform/credits/).
# Projects
> Learn how projects anchor Studio work, runtimes, and grouped execution records inside a workspace.
import { Aside, CardGrid, LinkCard } from '@astrojs/starlight/components';
Projects are the named work contexts inside a workspace. They anchor the hosted Studio route, group
interactive runtime state and execution records, and give app, CLI, TUI, and API workflows a stable
project key to target without becoming the permission or billing boundary.
Access, billing, and membership still come from the surrounding
[workspace](/platform/workspaces/) and [organization](/platform/organizations/). If you only need the
hierarchy and boundary model, start with the [Manage overview](/platform/overview/). This page is the project
deep dive.
## What a project is
A project lives inside a workspace and represents a focused piece of work — a red team engagement, a pentesting target, an evaluation suite, or an experiment.
Projects provide:
- **A stable Studio route** — project keys appear in URLs such as `/{org}/studio/{workspace}/{project}`
- **Grouping** — a common bucket for attached runtimes, sessions, sandboxes, evaluations, AIRT assessments, and traces related to that work
- **A default context** — when a create flow omits `project_id`, Dreadnode resolves the workspace's default project
- **Runtime association** — a project can group zero or more durable runtimes for interactive work
Projects do **not** replace the real boundaries around that work. Workspaces still control access,
storage, and collaboration. Organizations still control membership and billing.
## Project keys
Every project has a `key` — a URL-safe slug that uniquely identifies it within its workspace. Keys
appear in URLs, CLI output, and Studio route resolution.
Unlike some older docs implied, project keys are not strictly immutable. Non-default projects can be
renamed as long as the new key stays unique within the workspace. That changes the Studio URL, so
bookmarks and saved links should be updated when you rename a project.
## Hosted project surface
In the hosted app, the concrete project surface is the Studio route:
```text
/{org}/studio/{workspace}/{project}
```
That route is the interactive shell for the current project.
The base Studio view keeps chat and the composer in project context. From there, the current layout
opens three pinned project panels:
- **`Files`** — browse files produced or persisted through the current runtime/sandbox workflow
- **`Summary`** — review recent runs, model and tool usage, token totals, and estimated cost for the current project
- **`Runtime`** — inspect the interactive runtime and sandbox state behind the project
Other routed surfaces such as traces, evaluations, optimization, or studies are adjacent
workflow views. They use the same project context, but they are not the fixed pill tabs in the
current Studio layout.
## Default project resolution
Every workspace has a default project. This prevents new runtimes, sessions, evaluations, or world
jobs from becoming ungrouped when the client does not specify a `project_id`.
That default is used in two common places:
- backend create flows that omit `project_id`
- web app redirects when there is no explicit project in the URL yet
When you open a page that needs a project and the URL does not name one, the frontend resolves one
for you, in this order:
1. the project you last worked in, for that organization and workspace
2. the workspace's default project
3. the first project in the workspace, by name
Your last-used project is stored in a browser cookie, so it survives a reload and carries across
tabs on the same browser. It is scoped per organization and workspace, so working in `main` in one
organization does not move you in another. Clearing site data resets you to the workspace default.
## Projects and runtimes
Interactive compute is still modeled through explicit runtime and sandbox objects, but projects no
longer own a single durable runtime slot.
Creating a project does not create a runtime record automatically. Instead, runtimes are created as
independent workspace resources and may optionally be attached to a project for grouping. Capability
bindings, current sandbox state, and session continuity live on the runtime, not directly on the
project row.
Runtime metadata is also independent. Renaming a project does not rewrite the runtime's `key`,
`name`, or `description`.
That is why project docs and runtime docs have to be read together:
- the **project** is the user-facing context and grouping shell
- the **runtime** is the durable interactive control point
- the **sandbox** is the provider-backed compute instance
## Traces and telemetry
Traces, sessions, evaluations, and analytics remain workspace-scoped records that use `project_id`
as a grouping and filtering dimension. Use workspace-scoped trace and evaluation routes, then pass
`project_id` when you want a project-specific view.
Projects therefore shape the working set you see in the app, but they are not a separate read
permission boundary for telemetry APIs.
## Managing projects
Projects are managed through workspace-scoped app and API flows, then reused throughout CLI, TUI,
SDK, and hosted workflows.
In the hosted app, open a project and use the project header on the sessions view to edit a
non-default project's display title and description. That header edit does not change the project
key, so existing URLs and CLI/TUI targets keep working.
Important lifecycle rules:
- creating or updating a project requires workspace contributor access or higher
- deleting a project requires workspace owner access
- the default project cannot be renamed, modified, or deleted
- deleting a project first stops any running or paused project sandboxes, then cascades through
sessions, sandboxes, evaluations, AIRT assessments, and world resources before removing the project itself
## Related pages
Use this page together with the compatibility landing page and the adjacent execution-resource
docs:
Follow the durable interactive resources that projects can group.
Understand the provider-backed compute that runs underneath the project's runtime.
See how packaged environments and evaluations land in project context.
Review how project grouping narrows judged runs without becoming the permission boundary.
See how hosted training jobs relate to the same workspace and project model.
Follow how manifests, trajectories, and world jobs inherit project context.
Return to the hierarchy and boundary model when the question is about ownership, permissions, or
surface selection rather than project behavior.
# Secrets
> Name, store, and inject provider API keys and other sensitive credentials into remote sandboxes.
`OPENROUTER_API_KEY` is more than a label. When you select that secret for a remote run, Dreadnode
creates an environment variable named `OPENROUTER_API_KEY` inside the sandbox. The software running
there uses that exact name to find the credential.
Secrets are encrypted, user-owned credentials. Dreadnode stores the value without returning it in
normal API reads, then injects it only into the remote runtimes and evaluations you select.
## What secrets are
- **Private to you:** secrets are owned by your user and never shared by default.
- **Encrypted at rest:** plaintext values are never returned by read APIs.
- **Injected at runtime:** selected values are decrypted and injected when a sandbox is provisioned.
The key idea is that "stored" and "in use" are different states. Saving a secret makes it available
for later selection. It does not automatically push that value into every runtime you launch.
One common misread: saving a provider key here does **not** power your BYOK chat models. Local TUI
chat reads provider keys from your shell environment — secrets only reach the remote agent runs you
select them for. See [Chat models](/platform/chat-models/).
## Name secrets for the software that reads them
A custom secret name must match the environment variable expected by your model provider, tool, or
application. Dreadnode does not translate a custom name such as `MY_OPENROUTER_KEY` into
`OPENROUTER_API_KEY`.
Secret names:
- may contain letters, numbers, and underscores
- must start with a letter or underscore
- are normalized to uppercase when saved
### LiteLLM provider keys
LiteLLM resolves the provider from the model ID prefix, then looks for that provider's environment
variable. These common model prefixes use the following names:
| Model prefix | Secret name |
| -------------------- | ------------------------------------ |
| `openai/` | `OPENAI_API_KEY` |
| `anthropic/` | `ANTHROPIC_API_KEY` |
| `openrouter/` | `OPENROUTER_API_KEY` |
| `gemini/`, `google/` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` |
| `mistral/` | `MISTRAL_API_KEY` |
| `groq/` | `GROQ_API_KEY` |
| `together_ai/` | `TOGETHERAI_API_KEY` |
For example, an `openrouter/anthropic/claude-sonnet-4` model still needs
`OPENROUTER_API_KEY`, not `ANTHROPIC_API_KEY`, because LiteLLM sends the request through
OpenRouter. Choose **Custom** when the provider is not available as a preset, enter the expected
name, and paste the provider key as the value. The [Chat models](/platform/chat-models/) screen also
shows which key each BYOK model expects.
## Create and select a secret
The normal secret workflow looks like this:
1. Open Account Settings in the App, then select **Secrets**.
2. Choose a provider preset or **Custom**, enter the expected environment variable name, and save
the credential.
3. Verify the configured state in the App or with `/secrets` in the TUI.
4. Select the specific secrets you want when you create a runtime or evaluation.
5. Reprovision or rerun when a rotated value needs to take effect.
Saving a secret makes it available for selection. It does not inject the value into every remote
run.
### Provider presets
Provider presets fill in the canonical environment variable name for you:
| Provider | Secret name |
| --------- | ------------------- |
| OpenAI | `OPENAI_API_KEY` |
| Anthropic | `ANTHROPIC_API_KEY` |
| GitHub | `GITHUB_TOKEN` |
| Tinker | `TINKER_API_KEY` |
A preset changes only how you create the secret. You still select its ID when you provision a
runtime or create an evaluation. For providers without a preset, choose **Custom** and use the name
the provider's client expects.
## Scoping and injection
Secrets are **user-owned**. You maintain a personal library of secrets and choose which ones to
inject when you provision a sandbox for a project.
When you provision an interactive runtime, pass the secret IDs in `secret_ids`. That selection
applies to that runtime request; the project only groups the resulting resource.
When you create an evaluation, you can also pass `secret_ids`. The platform injects those secrets
into both compute units created for each evaluation sample:
- the runtime sandbox that hosts the agent loop
- the task environment sandbox derived from the task build
From the CLI, `dn evaluation create` lets you choose secrets by environment variable name with
repeatable `--secret` flags. Exact names such as `OPENROUTER_API_KEY` are strict. Glob selectors
such as `OPENROUTER_*` are best-effort. The CLI resolves those selectors to concrete `secret_ids`
before submitting the request. See [Running evaluations](/evaluations/running/#injecting-secrets)
for examples.
Secrets are injected when the sandbox is created. To change the selection or apply a rotated value,
restart or reprovision the runtime. For an evaluation, create a new run with the updated selection.
There is not currently a standalone CLI secret CRUD command group. Manage secret values in the App
or through the API and SDK; use the TUI to inspect configured secrets.
## Lifecycle and management
| Surface | Best use |
| --------- | ----------------------------------------------------------------- |
| App | create, rotate, and delete saved secrets |
| TUI | inspect configured secrets and provider presets with `/secrets` |
| CLI | pass evaluation `--secret` selectors that resolve to `secret_ids` |
| API / SDK | full secret CRUD and preset discovery |
| Step | What happens |
| --------- | ----------------------------------------------------------- |
| Create | The value is encrypted and shown with a masked preview |
| Select | You choose which secrets to inject for a runtime request |
| Provision | Dreadnode decrypts the selected values and injects them |
| Rotate | You update the value and reprovision or restart to apply it |
## Common pitfalls
- A correctly stored key with the wrong name is still the wrong environment variable. Use the name
required by the software that reads it.
- Provider presets report whether the canonical secret exists, not whether a running sandbox uses
it.
- Secret values are never returned by normal read APIs. You see metadata and a masked preview.
- Evaluations inject selected secrets into both the agent runtime and the task environment.
# Settings
> Understand what the app settings area controls, who can change it, and how it relates to other administration pages.
import { Aside } from '@astrojs/starlight/components';
Settings is the app's entry point for organization and user configuration. It is not one single
resource — it is the shell that groups the configuration pages for general org settings, members,
workspaces, secrets, chat models, and billing.
## How settings maps to the app
| Section | Route role in the app | Primary operator question | Deep-dive page |
| ----------- | ----------------------------------------------- | ------------------------------------------------------------- | ----------------------------------------- |
| General | org identity and top-level configuration | how should this organization appear and who can manage it? | [Organizations](/platform/organizations/) |
| Members | membership and role management | who belongs here and what can they manage? | [Organizations](/platform/organizations/) |
| Workspaces | workspace creation and sharing | where should work happen and who gets access? | [Workspaces](/platform/workspaces/) |
| Secrets | personal provider credentials | which keys do I want available for my runs and evaluations? | [Secrets](/platform/secrets/) |
| Chat Models | chat UI model availability | which inference models should appear in my assistant picker? | [Chat models](/platform/chat-models/) |
| Preferences | navigation, notification and marketing controls | which navigation and communication preferences should I keep? | this page |
| Billing | SaaS credits and payment controls | how do we pay for usage and keep workloads running? | [Credits](/platform/credits/) |
## What lives in settings
| Section | What it controls |
| ----------- | ------------------------------------------------------------------------------------------------------------------------- |
| General | organization display name, description, URL key visibility, and max-member visibility |
| Members | organization membership, invitations, and permission management |
| Workspaces | workspace creation, sharing, and per-workspace access management |
| Secrets | provider API keys and custom environment variables |
| Chat Models | your own BYOK model additions alongside the platform's configured `dn/*` models |
| Preferences | which navigation Dreadnode opens in, desktop notification toggles, and marketing email subscription (`Dreadnode Updates`) |
| Billing | credits, auto-refill, transactions, and usage in SaaS mode |
The settings shell also surfaces an invite banner when an organization appears to be solo and the
current user can manage members. In the app, that banner uses the `Invite Team` action to send you
directly into membership management.
## Common operator tasks
| If you need to... | Go to | Why |
| ------------------------------------------------------------ | ------------- | ----------------------------------------------------------------- |
| rename the org or review org-level limits | `General` | this is the top-level org metadata surface |
| invite coworkers and adjust roles | `Members` | org membership and permission changes happen here |
| create a shared delivery area for a team or engagement | `Workspaces` | workspace creation and access live here |
| add your own provider key for future runs | `Secrets` | secrets are user-owned even though they are managed from settings |
| decide which chat models appear in your chat UI | `Chat Models` | this is a user preference surface, not the artifact registry |
| subscribe or unsubscribe from product-update marketing email | `Preferences` | this controls `Dreadnode Updates` only, not transactional email |
| configure payment methods, auto-refill, or usage guardrails | `Billing` | this is the SaaS billing and credits surface |
## Important distinctions
### Settings versus platform resources
Settings is the place where operators configure the platform. It is not where they execute work.
- Use registry pages such as [Capabilities](/capabilities/overview/), [Datasets](/datasets/overview/),
and [Models](/models/overview/) when you are browsing shared artifacts.
- Use execution pages such as [Evaluations](/evaluations/overview/) or [Runtimes](/runtimes/overview/)
when you are running work.
- Use settings when you are changing who can use the platform, what credentials exist, or what
defaults appear in the UI.
### Chat models versus model artifacts
`Chat Models` inside settings is about which inference models appear in your chat UI and whether
the required provider keys are configured — see [Chat models](/platform/chat-models/) for the
full mechanic.
That is different from [Models](/models/overview/), which is the registry for stored versioned model
artifacts.
## Section-by-section workflows
### General
Use `General` when you are changing organization identity and operator-facing defaults.
- update the display name and descriptive metadata people see in the app
- review the stable organization key used in URLs and API paths
- review organization-level limits that affect collaboration and membership growth
- note that the current app exposes the key for reference, but does not let you rename it here
- treat this as the top-level org control surface, not a place to manage projects or runtime state
### Members
Use `Members` when you are changing who belongs to the organization and what they can do.
- invite teammates by email and manage pending invitations
- change organization roles when responsibilities change
- remove members who should no longer have access
- expect the UI to encourage invites when the org looks like a solo workspace and the current user
can manage membership
### Workspaces
Use `Workspaces` when you are deciding where work should live and who can collaborate on it.
- create a workspace for a client, team, or engagement
- grant direct user access or share through teams
- use default workspaces for private individual work and shared workspaces for collaborative work
- in SaaS mode, expect plan checks around workspace creation and updates
### Secrets
Use `Secrets` when you are storing credentials that you personally want to inject into runs.
- add provider keys with canonical preset names such as `OPENAI_API_KEY`
- rotate or delete credentials without exposing plaintext values in API responses
- remember that secrets remain **user-owned**, even though settings is where they are managed
- choose `secret_ids` when you start a runtime or create an evaluation because settings does not
automatically inject every saved secret everywhere
### Chat Models
Use `Chat Models` when you are adding your own BYOK models to the interactive assistant UI —
available platform models appear alongside your additions. See [Chat models](/platform/chat-models/)
for the full mechanic, including which provider key each BYOK model needs.
### Preferences
Use `Preferences` when you are managing account-level navigation and communication controls.
- choose which navigation Dreadnode opens in with `Use the new navigation`; see
[New navigation (beta)](/platform/new-navigation/)
- toggle desktop notifications for long-running task completion alerts
- subscribe or unsubscribe from the `Dreadnode Updates` marketing list
- note that transactional emails (verification, password reset, operational notices) are independent
from marketing preference
### Billing
Use `Billing` when you are managing credits-backed usage in SaaS deployments.
- review the current balance, warning state, and transaction history
- configure auto-refill thresholds and monthly caps
- inspect saved payment method details
- follow the Enterprise link when the deployment uses invoicing or custom reporting instead of
credits-backed self-serve billing
## Permissions and deployment behavior
- Organization owners can edit general settings and membership-related configuration.
- Secrets remain user-owned even though the settings shell is where they are managed.
- Billing is available only when credits are enabled. On Enterprise installs, opening an organization
billing URL redirects you to that organization’s General settings, including from a saved bookmark.
- The Enterprise link appears only when credits are enabled.
## Permission guide
| Section | Scope | Safe default assumption |
| ----------- | ---------------------------------- | ------------------------------------------------------------------ |
| General | organization | org-admin action |
| Members | organization | org-admin action with invite and role management |
| Workspaces | organization plus workspace access | org-level creation plus workspace-sharing controls |
| Secrets | user | each user manages their own credentials |
| Chat Models | user | treat as a per-user model-picker preference, not a registry write |
| Preferences | user | per-user communication preferences for notifications and marketing |
| Billing | organization, SaaS only | owner-level billing action |
## SaaS versus Enterprise
| Deployment mode | What to expect in settings |
| --------------- | ------------------------------------------------------------------------------------------------ |
| SaaS | `Billing` is visible, credits are active, and auto-refill or payment-method workflows may appear |
| Enterprise | Billing is hidden; direct organization billing links redirect to General settings |
## What agents should assume
- Settings is a grouping surface, not one API object.
- Different sections have different permission checks.
- `Chat Models` and registry `Models` are separate concepts.
- `Chat Models` is user-scoped even though it is presented inside the settings shell.
- Billing visibility depends on deployment configuration, so do not assume it exists everywhere.
- Settings tells you where configuration is managed, but execution-time choices such as `secret_ids`
still happen when a runtime or evaluation is created.
# Workspaces
> Learn how workspaces organize projects and control access within an organization.
Workspaces are the main collaboration boundary inside an organization. They group projects, control
who can see them, and determine the default execution context across the app, TUI, and CLI.
If you only need the hierarchy and boundary model, start with the [Manage
overview](/platform/overview/). This page is the workspace deep dive.
## Session data access
Workspace read access permits reading session transcripts, traces, and artifacts, including sessions marked unlisted. Session visibility controls discovery in lists; it does not provide confidentiality from other workspace members. Use separate workspaces when people must not read each other's work.
Runtime control and user-owned credentials retain their own ownership checks. Reading a teammate's session does not grant access to their runtime or secrets.
## What a workspace is
A workspace lives inside an organization and provides:
- A boundary for grouping related projects (e.g. by team, engagement, or client)
- Fine-grained access control via user and team permissions
- A unique `key` (URL slug) within the organization
If the organization answers "who owns this work," the workspace answers "who should collaborate on
this slice of it?"
Each user gets a **default workspace** that is private to them. Additional workspaces can be created and shared with other members.
## Workflow: how workspaces shape execution
Workspaces are not just folders in the App. They drive context resolution across the product.
1. Onboarding or first login gives you a default workspace.
2. The App settings area is where operators create and share additional workspaces.
3. The TUI and CLI resolve the workspace from the saved profile unless you override it.
4. Projects, runtimes, evaluations, and traces then inherit that workspace context.
That is why switching workspaces changes what "current project," "current runtime," and "current
data" mean downstream.
## How workspaces show up across surfaces
| Surface | What you use it for |
| ------- | ----------------------------------------------------------------------------------------- |
| App | create shared work areas, manage access, review workspace details |
| TUI | `/workspace `, `/workspaces`, `/projects [workspace]`, or `Ctrl+W` to switch context |
| CLI | `--workspace` and `--project` overrides on top of the active profile |
| API | `/org/{org}/ws/...` routes for create, update, delete, sharing, and storage access |
## Permissions
Workspace access is controlled separately from organization roles. Permissions can be granted to individual users or to teams.
| Permission | What it allows |
| ----------- | ------------------------------------------- |
| Owner | Full access — manage permissions, delete |
| Contributor | Create and manage projects within workspace |
| Reader | View projects and traces |
### User permissions
Individual users can be added to a workspace with a specific permission level. The workspace creator is automatically assigned the `owner` permission.
### Team permissions
Teams (groups of users within the organization) can also be granted workspace access. All members of the team inherit the team's permission level for that workspace.
## Default workspaces
When a user joins an organization, they receive a default workspace that is private to them. Default workspaces:
- Are automatically created and cannot be deleted
- Are not shared with other members unless explicitly configured
- Provide a personal space for individual projects
The exact default workspace key depends on deployment mode, but the public behavior is the same:
every user gets a private starting place and the platform treats it as special.
## Managing workspaces
- **Create and manage:** Create, update, and delete workspaces from the organization settings or via the API.
- **Plan requirement:** In SaaS mode, creating or updating workspaces requires a Pro plan or higher. Enterprise deployments bypass plan checks.
- **Sharing:** Add users and manage their permissions from the workspace settings.
- **Storage credentials:** Request temporary storage credentials for programmatic access to workspace data.
## Nuances that matter
- Workspace permission is narrower than organization role. Org membership alone does not guarantee
access to every workspace.
- TUI workspace switching restarts the runtime because runtime state is workspace-scoped.
- CLI validation will auto-resolve the default workspace when possible, but explicit automation
should still set `--workspace` when reproducibility matters.
- Default workspaces cannot be deleted, even by owners.