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. ![The right end of the new navigation's top bar: Search, Documentation, Feedback with its tooltip showing, and your avatar.](./_images/new-navigation-feedback.png)
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.