dreadnode 2.0.26__tar.gz → 2.0.27__tar.gz

{dreadnode-2.0.26 → dreadnode-2.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.26
+Version: 2.0.27
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/app/api/client.py

@@ -363,9 +363,13 @@ class ApiClient:
         response = self.request("GET", "/user/preferences", params=params)
         return t.cast("dict[str, t.Any]", response.json())
 
-    def provision_inference_key(self, org_key: str) -> dict[str, t.Any]:
+    def provision_inference_key(self, org_key: str, client_id: str) -> dict[str, t.Any]:
         """POST /api/v1/org/{org}/inference/keys - Provision a litellm virtual key."""
-        response = self.request("POST", f"/org/{org_key}/inference/keys")
+        response = self.request(
+            "POST",
+            f"/org/{org_key}/inference/keys",
+            json_data={"client_id": client_id},
+        )
         return t.cast("dict[str, t.Any]", response.json())
 
     # =========================================================================

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/app/tui/app.py

@@ -257,6 +257,7 @@ class _AppModelUiHost:
         platform_models: list[dict[str, t.Any]],
         byok_models: list[dict[str, t.Any]],
         current_model: str,
+        inference_credits_per_dollar: int | None,
         access_restricted: bool,
         search_models: t.Callable[..., t.Any],
         on_selected: t.Callable[[str | None], None],
@@ -268,6 +269,7 @@ class _AppModelUiHost:
                 platform_models=platform_models,
                 byok_models=byok_models,
                 current_model=current_model,
+                inference_credits_per_dollar=inference_credits_per_dollar,
                 access_restricted=access_restricted,
                 search_models=search_models,
             ),
@@ -280,6 +282,7 @@ class _AppModelUiHost:
         platform_models: list[dict[str, t.Any]],
         byok_models: list[dict[str, t.Any]],
         current_model: str,
+        inference_credits_per_dollar: int | None,
         access_restricted: bool,
     ) -> None:
         from dreadnode.app.tui.screens import ModelBrowserScreen
@@ -291,6 +294,7 @@ class _AppModelUiHost:
                         platform_models=platform_models,
                         byok_models=byok_models,
                         current_model=current_model,
+                        inference_credits_per_dollar=inference_credits_per_dollar,
                         access_restricted=access_restricted,
                     )
                     break

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/app/tui/model_manager.py

@@ -9,6 +9,7 @@ import typing as t
 from dataclasses import dataclass, field
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
+from uuid import uuid4
 
 import httpx
 from loguru import logger
@@ -25,6 +26,7 @@ LITELLM_REFRESH_WINDOW = timedelta(minutes=5)
 PROXY_MODELS_CACHE_FILE = Path.home() / ".dreadnode" / "proxy-models.json"
 MODEL_BROWSER_FEATURED_LIMIT = 12
 MODEL_BROWSER_SEARCH_LIMIT = 50
+DEFAULT_INFERENCE_CREDITS_PER_DOLLAR = 1000
 
 
 @dataclass(slots=True)
@@ -32,6 +34,7 @@ class ModelCatalogState:
     platform_models: list[dict[str, t.Any]] = field(default_factory=list)
     user_model_ids: list[str] = field(default_factory=list)
     preference_platform_model_ids: list[str] = field(default_factory=list)
+    inference_credits_per_dollar: int | None = None
     access_restricted: bool = False
     proxy_model_ids_synced: bool = False
     litellm_key_expires_at: datetime | None = None
@@ -72,6 +75,7 @@ class ModelUiHost(t.Protocol):
         platform_models: list[dict[str, t.Any]],
         byok_models: list[dict[str, t.Any]],
         current_model: str,
+        inference_credits_per_dollar: int | None,
         access_restricted: bool,
         search_models: t.Callable[..., t.Any],
         on_selected: t.Callable[[str | None], None],
@@ -83,6 +87,7 @@ class ModelUiHost(t.Protocol):
         platform_models: list[dict[str, t.Any]],
         byok_models: list[dict[str, t.Any]],
         current_model: str,
+        inference_credits_per_dollar: int | None,
         access_restricted: bool,
     ) -> None: ...
 
@@ -122,6 +127,7 @@ class ModelManager:
         self._runner = runner
         self._notifier = notifier
         self._actions = actions
+        self._tui_client_id = uuid4().hex
 
     def open_model_picker(self) -> None:
         """Show the inline model picker overlay."""
@@ -152,6 +158,7 @@ class ModelManager:
             platform_models=list(self._state.platform_models),
             byok_models=self.browser_seed_models(),
             current_model=self._context.current_model(),
+            inference_credits_per_dollar=self._state.inference_credits_per_dollar,
             access_restricted=self._state.access_restricted,
             search_models=self.search_model_browser_models,
             on_selected=self.apply_model_selection,
@@ -253,6 +260,7 @@ class ModelManager:
             platform_models=list(self._state.platform_models),
             byok_models=self.browser_seed_models(),
             current_model=self._context.current_model(),
+            inference_credits_per_dollar=self._state.inference_credits_per_dollar,
             access_restricted=self._state.access_restricted,
         )
 
@@ -281,12 +289,25 @@ class ModelManager:
         self._state.platform_models = []
         self._state.user_model_ids = []
         self._state.preference_platform_model_ids = []
+        self._state.inference_credits_per_dollar = None
         self._state.access_restricted = False
         self._state.proxy_model_ids_synced = False
         self._state.litellm_key_expires_at = None
         os.environ.pop(DREADNODE_LLM_BASE_ENV, None)
         os.environ.pop(DREADNODE_LLM_API_KEY_ENV, None)
 
+    @staticmethod
+    def parse_inference_credits_per_dollar(value: t.Any) -> int | None:
+        if value is None:
+            return DEFAULT_INFERENCE_CREDITS_PER_DOLLAR
+        if isinstance(value, bool):
+            return None
+        if isinstance(value, int) and value > 0:
+            return value
+        if isinstance(value, float) and value > 0:
+            return int(value)
+        return None
+
     @staticmethod
     def normalize_platform_model_ids(model_ids: list[str] | None) -> list[str]:
         if not model_ids:
@@ -355,8 +376,13 @@ class ModelManager:
             if name:
                 result["name"] = name
             for extra_field in (
+                "order",
                 "cost",
                 "limits",
+                "cost_input",
+                "cost_output",
+                "context_window",
+                "max_output",
                 "capabilities",
                 "modalities",
                 "knowledge",
@@ -744,6 +770,9 @@ class ModelManager:
         self._state.preference_platform_model_ids = self.normalize_platform_model_ids(
             platform_model_ids
         )
+        self._state.inference_credits_per_dollar = self.parse_inference_credits_per_dollar(
+            preferences.get("inference_credits_per_dollar")
+        )
         self._state.access_restricted = bool(preferences.get("access_restricted"))
         self.apply_restricted_current_model_fallback()
         if not self._state.platform_models:
@@ -787,7 +816,11 @@ class ModelManager:
             return None
         try:
             t0 = time.monotonic()
-            result = await asyncio.to_thread(api.provision_inference_key, org)
+            result = await asyncio.to_thread(
+                api.provision_inference_key,
+                org,
+                self._tui_client_id,
+            )
             logger.debug(
                 "LiteLLM key provisioned | elapsed={:.0f}ms",
                 (time.monotonic() - t0) * 1000,

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/app/tui/screens/models.py

@@ -63,6 +63,7 @@ class ModelEntry:
     knowledge: str | None = None
     release_date: str | None = None
     open_weights: bool | None = None
+    order: int | None = None
 
 
 @dataclass(slots=True, frozen=True)
@@ -129,9 +130,48 @@ def _format_context(value: int | None) -> str:
     return _format_compact_int(value)
 
 
-def _format_price(input_cost: float | None, output_cost: float | None) -> str:
+def _format_compact_number(value: float) -> str:
+    rounded_value = round(value, 6)
+    if abs(rounded_value) >= 1_000_000:
+        return f"{rounded_value / 1_000_000:g}m"
+    if abs(rounded_value) >= 1_000:
+        return f"{rounded_value / 1_000:g}k"
+    if rounded_value.is_integer():
+        return str(int(rounded_value))
+    return f"{rounded_value:g}"
+
+
+def _format_price(
+    input_cost: float | None,
+    output_cost: float | None,
+    *,
+    source: t.Literal["dreadnode", "byok"],
+    inference_credits_per_dollar: float | None,
+) -> str:
     if input_cost is None and output_cost is None:
         return "-"
+
+    if source == "dreadnode":
+        if not (
+            isinstance(inference_credits_per_dollar, int | float)
+            and inference_credits_per_dollar > 0
+        ):
+            return "-"
+        input_credits = (
+            _format_compact_number(input_cost * inference_credits_per_dollar)
+            if input_cost is not None
+            else None
+        )
+        output_credits = (
+            _format_compact_number(output_cost * inference_credits_per_dollar)
+            if output_cost is not None
+            else None
+        )
+        if input_credits is not None and output_credits is not None:
+            return f"{input_credits}/{output_credits} cr"
+        value = input_credits if input_credits is not None else output_credits
+        return f"{value} cr"
+
     if input_cost is not None and output_cost is not None:
         return f"${input_cost:g}/${output_cost:g}"
     value = input_cost if input_cost is not None else output_cost
@@ -146,27 +186,57 @@ def _format_open_weights(value: bool | None) -> str:
     return "-"
 
 
+def _parse_float_value(raw: t.Any) -> float | None:
+    if isinstance(raw, bool):
+        return None
+    if isinstance(raw, int | float):
+        return float(raw)
+    return None
+
+
+def _parse_int_value(raw: t.Any) -> int | None:
+    if isinstance(raw, bool):
+        return None
+    if isinstance(raw, int | float):
+        return int(raw)
+    return None
+
+
 def _parse_cost_fields(entry: dict[str, t.Any]) -> tuple[float | None, float | None]:
     cost = entry.get("cost")
-    if not isinstance(cost, dict):
-        return (None, None)
-    input_cost = cost.get("input")
-    output_cost = cost.get("output")
+    input_cost = cost.get("input") if isinstance(cost, dict) else None
+    output_cost = cost.get("output") if isinstance(cost, dict) else None
+
+    parsed_input_cost = _parse_float_value(input_cost)
+    if parsed_input_cost is None:
+        parsed_input_cost = _parse_float_value(entry.get("cost_input"))
+
+    parsed_output_cost = _parse_float_value(output_cost)
+    if parsed_output_cost is None:
+        parsed_output_cost = _parse_float_value(entry.get("cost_output"))
+
     return (
-        float(input_cost) if isinstance(input_cost, int | float) else None,
-        float(output_cost) if isinstance(output_cost, int | float) else None,
+        parsed_input_cost,
+        parsed_output_cost,
     )
 
 
 def _parse_limit_fields(entry: dict[str, t.Any]) -> tuple[int | None, int | None]:
     limits = entry.get("limits")
-    if not isinstance(limits, dict):
-        return (None, None)
-    context_window = limits.get("context")
-    max_output = limits.get("output")
+    context_window = limits.get("context") if isinstance(limits, dict) else None
+    max_output = limits.get("output") if isinstance(limits, dict) else None
+
+    parsed_context_window = _parse_int_value(context_window)
+    if parsed_context_window is None:
+        parsed_context_window = _parse_int_value(entry.get("context_window"))
+
+    parsed_max_output = _parse_int_value(max_output)
+    if parsed_max_output is None:
+        parsed_max_output = _parse_int_value(entry.get("max_output"))
+
     return (
-        int(context_window) if isinstance(context_window, int | float) else None,
-        int(max_output) if isinstance(max_output, int | float) else None,
+        parsed_context_window,
+        parsed_max_output,
     )
 
 
@@ -373,6 +443,19 @@ def _build_entries(
     hosted: dict[str, ModelEntry] = {}
     byok: dict[str, ModelEntry] = {}
 
+    def parse_order(value: object) -> int | None:
+        if isinstance(value, bool):
+            return None
+        if isinstance(value, int) and value >= 1:
+            return value
+        if isinstance(value, str) and value.strip():
+            try:
+                parsed = int(value)
+            except ValueError:
+                return None
+            return parsed if parsed >= 1 else None
+        return None
+
     for entry in platform_models:
         if not isinstance(entry, dict):
             continue
@@ -411,6 +494,7 @@ def _build_entries(
             open_weights=entry.get("open_weights")
             if isinstance(entry.get("open_weights"), bool)
             else None,
+            order=parse_order(entry.get("order")),
         )
 
     for entry in byok_models:
@@ -469,18 +553,19 @@ def _build_entries(
             source="dreadnode" if current_model.startswith("dn/") else "byok",
         )
 
-    def sort_key(entry: ModelEntry) -> tuple[int, int, str, str]:
-        return (
-            0 if entry.source == "dreadnode" else 1,
-            0 if entry.model_id == current_model else 1,
-            entry.name.lower(),
-            entry.model_id.lower(),
-        )
-
-    return sorted([*hosted.values(), *byok.values()], key=sort_key)
+    ordered_hosted = sorted(
+        enumerate(hosted.values()),
+        key=lambda item: (item[1].order is None, item[1].order or 0, item[0]),
+    )
+    return [*(entry for _index, entry in ordered_hosted), *byok.values()]
 
 
-def _matches_text(entry: ModelEntry, query: str) -> bool:
+def _matches_text(
+    entry: ModelEntry,
+    query: str,
+    *,
+    inference_credits_per_dollar: float | None,
+) -> bool:
     if not query:
         return True
     haystack = " ".join(
@@ -492,7 +577,12 @@ def _matches_text(entry: ModelEntry, query: str) -> bool:
             _source_label(entry.source),
             entry.status or "",
             _format_context(entry.context_window),
-            _format_price(entry.cost_input, entry.cost_output),
+            _format_price(
+                entry.cost_input,
+                entry.cost_output,
+                source=entry.source,
+                inference_credits_per_dollar=inference_credits_per_dollar,
+            ),
             _format_open_weights(entry.open_weights),
             entry.knowledge or "",
             entry.release_date or "",
@@ -505,7 +595,12 @@ def _matches_text(entry: ModelEntry, query: str) -> bool:
     return query.lower() in haystack
 
 
-def _filter_entries(entries: list[ModelEntry], search: ModelSearch | str) -> list[ModelEntry]:
+def _filter_entries(
+    entries: list[ModelEntry],
+    search: ModelSearch | str,
+    *,
+    inference_credits_per_dollar: float | None = None,
+) -> list[ModelEntry]:
     """Filter model entries by free text and structured metadata filters."""
     normalized = _parse_search_query(search) if isinstance(search, str) else search
 
@@ -534,7 +629,11 @@ def _filter_entries(entries: list[ModelEntry], search: ModelSearch | str) -> lis
             continue
         if normalized.max_price is not None and (price is None or price > normalized.max_price):
             continue
-        if not _matches_text(entry, normalized.text):
+        if not _matches_text(
+            entry,
+            normalized.text,
+            inference_credits_per_dollar=inference_credits_per_dollar,
+        ):
             continue
         results.append(entry)
     return results
@@ -563,6 +662,7 @@ class ModelBrowserScreen(Screen[str | None]):
         platform_models: list[dict[str, t.Any]],
         byok_models: list[dict[str, t.Any]],
         current_model: str,
+        inference_credits_per_dollar: float | None = None,
         access_restricted: bool = False,
         search_models: SearchModelsCallback | None = None,
         **kwargs: t.Any,
@@ -572,6 +672,7 @@ class ModelBrowserScreen(Screen[str | None]):
         self._seed_byok_models = list(byok_models)
         self._catalog_byok_models = list(byok_models)
         self._current_model = current_model
+        self._inference_credits_per_dollar = inference_credits_per_dollar
         self._access_restricted = access_restricted
         self._search_models = search_models
         self._search_loading = False
@@ -631,12 +732,14 @@ class ModelBrowserScreen(Screen[str | None]):
         platform_models: list[dict[str, t.Any]],
         byok_models: list[dict[str, t.Any]],
         current_model: str,
+        inference_credits_per_dollar: float | None = None,
         access_restricted: bool,
     ) -> None:
         """Refresh the browser contents from app state."""
         self._platform_models = list(platform_models)
         self._seed_byok_models = list(byok_models)
         self._current_model = current_model
+        self._inference_credits_per_dollar = inference_credits_per_dollar
         self._access_restricted = access_restricted
         self._rebuild_entries()
         if not self._search_query:
@@ -842,7 +945,11 @@ class ModelBrowserScreen(Screen[str | None]):
         self.query_one("#models-header", Static).update(text)
 
     def _render_table(self) -> None:
-        self._visible = _filter_entries(self._entries, _parse_search_query(self._search_query))
+        self._visible = _filter_entries(
+            self._entries,
+            _parse_search_query(self._search_query),
+            inference_credits_per_dollar=self._inference_credits_per_dollar,
+        )
         self._cursor = min(self._cursor, max(0, len(self._visible) - 1))
         self._render_query_bar()
         table = self.query_one("#models-table", DataTable)
@@ -865,7 +972,12 @@ class ModelBrowserScreen(Screen[str | None]):
                 entry.provider or "-",
                 source,
                 _format_context(entry.context_window),
-                _format_price(entry.cost_input, entry.cost_output),
+                _format_price(
+                    entry.cost_input,
+                    entry.cost_output,
+                    source=entry.source,
+                    inference_credits_per_dollar=self._inference_credits_per_dollar,
+                ),
                 _format_open_weights(entry.open_weights),
                 entry.model_id,
                 key=entry.model_id,
@@ -950,7 +1062,11 @@ class ModelBrowserScreen(Screen[str | None]):
         self._catalog_byok_models = list(results)
         self._rebuild_entries()
         self._cursor = self._current_index(
-            _filter_entries(self._entries, _parse_search_query(self._search_query))
+            _filter_entries(
+                self._entries,
+                _parse_search_query(self._search_query),
+                inference_credits_per_dollar=self._inference_credits_per_dollar,
+            )
         )
         if self.is_mounted:
             self._render_all()

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/app/tui/widgets/context_bar.py

@@ -5,7 +5,7 @@ SessionContextBar (Zone 1, 2 lines):
   Line 2: ^A agent                                ^K model, ^⇧K reasoning
 
 PageStatus (Zone 3, 1 line):
-                              53.4k/200k tok · ⚒ 12 · $0.34 · ? help
+                         ctx 53.4k/200k tok · ⚒ 12 · usage $0.34 · ? help
 
 The token gauge shows ``last_input_tokens / model_max_tokens`` — i.e., the
 size of the prompt the model just saw against the model's context window.
@@ -18,6 +18,13 @@ The ``⚒`` and ``$X.XX`` segments only render when their values are known
 and non-zero; on a session with at least one generation that lacked a cost
 rate the dollar segment is suppressed entirely (matching the backend's
 null-propagation for ``total_cost_usd``) — partial sums are misleading.
+
+The ``ctx`` prefix labels the token gauge as a context-window meter (not a
+quota); the ``usage`` prefix labels the dollar figure as cumulative cost
+for this session only (not balance, not account-wide spend). The dollar
+segment also carries an OSC 8 hyperlink to the public pricing docs so a
+confused user can resolve the unit mismatch with one click in any modern
+terminal — terminals without OSC 8 support simply render plain text.
 """
 
 from __future__ import annotations
@@ -181,6 +188,13 @@ class ContextBar(SessionContextBar):
 
 _ISSUE_DISPLAY_SECONDS = 60
 
+# Public docs page that explains credits, the USD-to-credits rate, what
+# consumes credits, and how the usage-cost figure relates to the org
+# balance. Hard-coded by design: the TUI ships independently of docs and a
+# config lookup would just add a network hop for a value that almost never
+# changes. If this URL moves, the previous one should redirect.
+PRICING_DOCS_URL = "https://docs.dreadnode.io/platform/credits/"
+
 
 class PageStatus(Static):
     """Zone 3 — single-line page status below the composer.
@@ -232,6 +246,7 @@ class PageStatus(Static):
         right = Text(no_wrap=True)
         if self.last_input_tokens > 0:
             limit = self.model_max_tokens if self.model_max_tokens > 0 else None
+            right.append("ctx ", style=FG_FAINTEST)
             right.append_text(render_tokens(self.last_input_tokens, limit))
             right.append(" · ", style=FG_FAINTEST)
         if self.tool_call_count > 0:
@@ -239,7 +254,11 @@ class PageStatus(Static):
             right.append(str(self.tool_call_count), style=FG_MUTED)
             right.append(" · ", style=FG_FAINTEST)
         if not self.cost_unknown and self.cost_usd > 0:
-            right.append(_format_cost_usd(self.cost_usd), style=FG_MUTED)
+            right.append("usage ", style=FG_FAINTEST)
+            right.append(
+                _format_cost_usd(self.cost_usd),
+                style=f"{FG_MUTED} link {PRICING_DOCS_URL}",
+            )
             right.append(" · ", style=FG_FAINTEST)
         right.append("? help", style=FG_FAINTEST)
 

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/app/tui/widgets/help_panel.py

@@ -10,6 +10,7 @@ from rich.text import Text
 
 from dreadnode.app.tui.commands import SLASH_COMMANDS
 from dreadnode.app.tui.theme import ACCENT, BORDER_LIGHT, FG_MUTED, FG_SUBTLE
+from dreadnode.app.tui.widgets.context_bar import PRICING_DOCS_URL
 
 _CMD_LOOKUP = {cmd.name: cmd for cmd in SLASH_COMMANDS}
 
@@ -52,6 +53,16 @@ _SCREENS: list[tuple[str, str]] = [
     ("F5", "console"),
 ]
 
+# Inline explanation of the page-status figures. Phrased so a user reading
+# `?` after seeing `ctx 53.4k/200k tok · ⚒ 12 · usage $0.34` can identify
+# each segment and understand that `usage` cost is in-session-only USD,
+# not balance and not account-wide spend — the unit-mismatch resolution.
+_STATUS_BAR: list[tuple[str, str]] = [
+    ("ctx N/M tok", "prompt size relative to the model's context limit"),
+    ("⚒ N", "tool calls this session"),
+    ("usage $X.XX", "total inference spend this session"),
+]
+
 _COMMAND_GROUPS: list[tuple[str, list[str]]] = [
     (
         "Session",
@@ -105,6 +116,11 @@ def render_help() -> Text:
     _section(t, "Agent", _AGENT)
     t.append("\n")
     _section(t, "Screens", _SCREENS)
+    t.append("\n")
+    _section(t, "Status", _STATUS_BAR)
+    t.append("    Credits and pricing  ", style=_DESC)
+    t.append(PRICING_DOCS_URL, style=f"{_CMD} link {PRICING_DOCS_URL}")
+    t.append("\n")
 
     t.append("\n")
     t.append("  Commands\n", style=f"bold {_HEADING}")

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/getting-started/overview.md

@@ -13,7 +13,7 @@ Dreadnode is a terminal-native platform for offensive security agents. You insta
 
 After the [Quickstart](./quickstart.md), you have:
 
-* a logged-in TUI with starter credits attached to your default workspace and project
+* a logged-in TUI with [pre-loaded credits](../platform/credits.md) attached to your default workspace and project
 * the `web-security` capability installed and runnable against any target you’re authorized to test
 * a session you can replay end-to-end via `/sessions`
 * a markdown vulnerability report in `reports/` for any confirmed findings the agent produced
@@ -24,6 +24,7 @@ That’s the first-value path. Everything below extends it.
 
 * **[Quickstart](./quickstart.md)** — install, log in, install `web-security`, run your first pentest.
 * **[Authentication](./authentication.md)** — profiles, workspaces, BYOK provider keys, machine credentials for CI.
+* **[Pricing & credits](../platform/credits.md)** — what credits are, what consumes them, and how to reload before you run your first heavy session.
 * **[AI Red Teaming](https://docs.dreadnode.io/ai-red-teaming/getting-started/tui/)** — different audience, different flow. If you’re testing model targets, start there.
 * **[Self-hosting](https://docs.dreadnode.io/self-hosting/)** — deploy the platform on your own Kubernetes cluster.
 

{dreadnode-2.0.26 → dreadnode-2.0.27}/dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/getting-started/quickstart.md

@@ -127,4 +127,8 @@ The natural fast-follow is **building your own capability** — same shape as `w
 
 [Build your own capability](https://docs.dreadnode.io/capabilities/quickstart/)
 
+Before you go heavy, track what a session costs. Your organization is billed in **credits**, a shared balance that covers inference and sandbox runtime. The `usage $X.XX` figure in the TUI status bar shows your current session’s inference cost in USD. View the Credits page for rates, what consumes credits, and how to reload.
+
+[Learn more about credits and pricing](../platform/credits.md)
+
 Looking for something else? Browse the [full capability catalog](../capabilities/installing.md) for network ops, recon, and AI red teaming bundles, or read the [AI Red Teaming guide](https://docs.dreadnode.io/ai-red-teaming/) for model-target work.