What changed:

services/translation.py

TranslationService.translate()/translate_many() now take an api_key parameter, checked fresh on every call — no instance state holds it.
Key present → routes to the Claude backend, using ANTHROPIC_TARGET_LANGUAGES (the full 11-language list: French, English, German, Persian, Spanish, Italian, Portuguese, Dutch, Arabic, Russian, Turkish).
Key absent → routes to MarianMT (MARIAN_TARGET_LANGUAGES: English, German, Persian, Spanish — the set where direct/English-pivot coverage is solid).
_anthropic_client(api_key) builds a fresh client per call and is not cached — the key lives only for the duration of that one translation call, never persisted in module state, never logged in error messages, never written anywhere.

app.py

New password-masked "Anthropic API Key (optional)" field with inline copy explaining the trade-off.
The Outputs checkbox list updates live as the key field changes (.change() handler): typing a key expands the list to all 11 languages while preserving any selections already made; clearing the key shrinks it back to the 4 Marian-safe ones and silently drops anything no longer valid (verified: German stays selected, Italian gets dropped).
All 11 translation tabs are pre-built (hidden by default) so toggling the key never adds/removes components — only visibility changes.
Each selected translation now fails independently — if one language errors out (bad key, rate limit, model gap), its tab shows ⚠️ Translation failed: ... instead of aborting the whole "Generate Outputs" click and losing transcript + the translations that did succeed.

I tested all of this with mocked services: choice-switching in both directions, the key flowing through to the translation call untouched, and the per-language failure isolation — all confirmed working as intended.
One judgment call worth flagging: I kept a quiet fallback to a server-side ANTHROPIC_API_KEY environment variable if the UI field is left blank — useful if you're self-hosting this for yourself and don't want to paste a key every session, without affecting the "never saved" guarantee for anyone else's typed-in key. If you'd rather not have that fallback at all (stricter "no key anywhere unless the user typed it" semantics), I can remove it — it's a one-line change in TranslationService.translate().

app.py

@@ -8,6 +8,18 @@ Implements the frozen v1.0 workflow:
 Services are instantiated lazily (on first use) rather than at import time,
 so the app can start up without needing model weights on disk yet, and so
 this module stays import-safe in environments without network access.
+
+Translation languages on offer depend on whether the person supplies their
+own Anthropic API key for that session:
+
+- No key: translation runs on the local, offline MarianMT backend, so only
+  the languages it can reliably reach are offered (services.translation.
+  MARIAN_TARGET_LANGUAGES).
+- Key supplied: translation runs through Claude, which has no missing-
+  language-pair problem, so the full language list is offered (services.
+  translation.ANTHROPIC_TARGET_LANGUAGES). The key is used only for the
+  request(s) made during this session and is never written to disk,
+  logged, or cached anywhere server-side.
 """
 
 from __future__ import annotations
@@ -22,10 +34,20 @@ from models.transcript import Transcript
 from services.audio import AudioError, extract_window, resolve_window, validate_extension
 from services.subtitles import generate_srt, generate_vtt
 from services.transcription import SUPPORTED_LANGUAGES, TranscriptionService
-from services.translation import SUPPORTED_TARGET_LANGUAGES, TranslationService
+from services.translation import (
+    ANTHROPIC_TARGET_LANGUAGES,
+    MARIAN_TARGET_LANGUAGES,
+    TranslationError,
+    TranslationService,
+)
 
 # ---------------------------------------------------------------------------
 # Lazy service singletons
+#
+# Safe to share across requests/users: TranscriptionService holds no
+# per-request state, and TranslationService resolves its backend (and
+# takes the API key, if any) fresh on every translate() call rather than
+# storing it -- see services/translation.py.
 # ---------------------------------------------------------------------------
 
 _transcription_service: Optional[TranscriptionService] = None
@@ -59,15 +81,23 @@ def get_translation_service() -> TranslationService:
 _NAME_TO_CODE = {name: code for code, name in SUPPORTED_LANGUAGES.items()}
 SOURCE_LANGUAGE_CHOICES = ["Auto Detect"] + list(SUPPORTED_LANGUAGES.values())
 
-# "Outputs" checkboxes: display label -> ISO 639-1 code for translations.
+# "Outputs" checkbox labels, for each of the two language sets. The
+# Anthropic set is a superset of the Marian one, so switching a key in/out
+# only ever adds or removes options -- it never renames existing ones.
+_MARIAN_OUTPUT_CHOICES = ["Transcript"] + [f"{name} Translation" for name in MARIAN_TARGET_LANGUAGES.values()]
+_ANTHROPIC_OUTPUT_CHOICES = ["Transcript"] + [f"{name} Translation" for name in ANTHROPIC_TARGET_LANGUAGES.values()]
+DEFAULT_OUTPUTS = ["Transcript", "English Translation"]
+
+# Label -> ISO 639-1 code, built from the full (Anthropic) superset so it
+# resolves correctly regardless of which list is currently offered.
 _TRANSLATION_LABEL_TO_CODE = {
-    f"{name} Translation": code for code, name in SUPPORTED_TARGET_LANGUAGES.items()
+    f"{name} Translation": code for code, name in ANTHROPIC_TARGET_LANGUAGES.items()
 }
-OUTPUT_CHOICES = ["Transcript"] + list(_TRANSLATION_LABEL_TO_CODE.keys())
-DEFAULT_OUTPUTS = ["Transcript", "English Translation"]
 
-# Order in which translation tabs are laid out (fixed; visibility toggles).
-_TRANSLATION_TAB_ORDER = ["English Translation", "German Translation", "Persian Translation", "Spanish Translation"]
+# Tabs are pre-built for every language in the full superset (hidden by
+# default) so that toggling the API key never needs to add/remove
+# components -- only which ones are visible changes.
+_TRANSLATION_TAB_ORDER = list(_TRANSLATION_LABEL_TO_CODE.keys())
 
 
 def _format_duration(seconds: float) -> str:
@@ -83,6 +113,20 @@ def _write_text_file(text: str, tmp_dir: Path, filename: str) -> str:
     return str(path)
 
 
+def _update_output_choices(api_key: str, current_value: list[str]):
+    """Swap the Outputs checkbox list when the API key field changes.
+
+    With a key: offer the full Anthropic language list. Without: restrict
+    to what the offline MarianMT backend can reliably translate. Any
+    currently-selected language that's no longer offered is dropped from
+    the selection (this only happens when a key is removed).
+    """
+    has_key = bool((api_key or "").strip())
+    choices = _ANTHROPIC_OUTPUT_CHOICES if has_key else _MARIAN_OUTPUT_CHOICES
+    filtered_value = [v for v in (current_value or []) if v in choices] or ["Transcript"]
+    return gr.update(choices=choices, value=filtered_value)
+
+
 # ---------------------------------------------------------------------------
 # Main processing callback
 # ---------------------------------------------------------------------------
@@ -93,6 +137,7 @@ def process_audio(
     end_value: str,
     source_language_label: str,
     selected_outputs: list[str],
+    api_key: str,
 ):
     if not audio_path:
         raise gr.Error("Please upload an audio file first.")
@@ -143,14 +188,21 @@ def process_audio(
     translation_service = get_translation_service()
     translation_updates = {}  # label -> (text, file_path)
     for label in _TRANSLATION_TAB_ORDER:
-        if label in selected_outputs:
-            code = _TRANSLATION_LABEL_TO_CODE[label]
-            translation = translation_service.translate(transcript, code)
+        if label not in selected_outputs:
+            translation_updates[label] = (None, None)
+            continue
+
+        code = _TRANSLATION_LABEL_TO_CODE[label]
+        try:
+            translation = translation_service.translate(transcript, code, api_key=api_key)
             text = translation.text
             file_path = _write_text_file(text, tmp_dir, f"{code}.txt")
-            translation_updates[label] = (text, file_path)
-        else:
-            translation_updates[label] = (None, None)
+        except TranslationError as exc:
+            # Surface the failure in that tab rather than aborting every
+            # other output that already succeeded.
+            text = f"\u26a0\ufe0f Translation failed: {exc}"
+            file_path = None
+        translation_updates[label] = (text, file_path)
 
     # --- Subtitles (always derived from the transcript, the canonical
     # source of truth -- never regenerated from audio) ---
@@ -206,12 +258,29 @@ with gr.Blocks(title="EchoScript") as demo:
                 label="Source Language",
             )
 
+            api_key_input = gr.Textbox(
+                label="Anthropic API Key (optional)",
+                type="password",
+                placeholder="sk-ant-...",
+                info=(
+                    "Provide your own key to translate into many more languages via Claude. "
+                    "Without one, translation uses local offline models (English, German, "
+                    "Persian, Spanish only). Used for this session only -- never stored."
+                ),
+            )
+
             outputs_input = gr.CheckboxGroup(
-                choices=OUTPUT_CHOICES,
+                choices=_MARIAN_OUTPUT_CHOICES,
                 value=DEFAULT_OUTPUTS,
                 label="Outputs",
             )
 
+            api_key_input.change(
+                fn=_update_output_choices,
+                inputs=[api_key_input, outputs_input],
+                outputs=[outputs_input],
+            )
+
             process_button = gr.Button("Generate Outputs", variant="primary")
 
         with gr.Column(scale=2):
@@ -263,7 +332,7 @@ with gr.Blocks(title="EchoScript") as demo:
 
     process_button.click(
         fn=process_audio,
-        inputs=[audio_input, start_input, end_input, language_input, outputs_input],
+        inputs=[audio_input, start_input, end_input, language_input, outputs_input, api_key_input],
         outputs=click_outputs,
     )
 

services/__init__.py

@@ -2,7 +2,8 @@ from services.audio import AudioError, extract_window, resolve_window, validate_
 from services.subtitles import generate_srt, generate_vtt
 from services.transcription import SUPPORTED_LANGUAGES, TranscriptionService
 from services.translation import (
-    SUPPORTED_TARGET_LANGUAGES,
+    ANTHROPIC_TARGET_LANGUAGES,
+    MARIAN_TARGET_LANGUAGES,
     TranslationError,
     TranslationService,
 )
@@ -16,7 +17,8 @@ __all__ = [
     "generate_vtt",
     "SUPPORTED_LANGUAGES",
     "TranscriptionService",
-    "SUPPORTED_TARGET_LANGUAGES",
+    "ANTHROPIC_TARGET_LANGUAGES",
+    "MARIAN_TARGET_LANGUAGES",
     "TranslationError",
     "TranslationService",
 ]

services/translation.py

@@ -13,22 +13,23 @@ afterwards picks up the fix automatically, and every translation stays in
 sync with the same segment timings as the transcript (so subtitles still
 work for translated output).
 
-Two interchangeable backends are available:
+Two interchangeable backends are available, chosen per-request based on
+whether an Anthropic API key was supplied -- never stored:
 
-- "anthropic": sends transcript text to the Claude API for translation.
-  Used automatically when an ANTHROPIC_API_KEY is configured (the same
-  BYOK pattern Archon uses). No missing-language-pair failure mode --
+- "anthropic": the caller supplies their own API key (e.g. typed into the
+  UI for that session). Used whenever a key is present. Sends transcript
+  text to Claude for translation. No missing-language-pair failure mode --
   every supported language translates directly to every other one in a
-  single call, with no local model downloads.
+  single call, with no local model downloads. The key is passed straight
+  through to the Anthropic client for that one call and is never written
+  to disk, logged, or cached in any module-level state.
 - "marian": fully offline, no API key needed. Uses local Helsinki-NLP
-  MarianMT models via `transformers`. Helsinki-NLP doesn't publish a
-  direct model for every language pair (Persian in particular only has
-  reliable direct models paired with English), so this backend pivots
-  through English when no direct model exists for a pair.
-
-Set ECHOSCRIPT_TRANSLATION_BACKEND=anthropic|marian to force one; if
-unset, "anthropic" is used when ANTHROPIC_API_KEY is present, otherwise
-"marian".
+  MarianMT models via `transformers`, restricted to the small set of
+  languages where direct or English-pivoted coverage is reliable.
+
+The UI is expected to only offer the larger ANTHROPIC_TARGET_LANGUAGES
+list once a key has been entered, and MARIAN_TARGET_LANGUAGES otherwise --
+see app.py.
 """
 
 from __future__ import annotations
@@ -39,25 +40,43 @@ from functools import lru_cache
 
 from models.transcript import Segment, Transcript, Translation
 
-# Display names for every language EchoScript can act as a source or
-# target -- used both for the UI's language dropdown/checkboxes (via
-# services/transcription.py) and for prompting the Anthropic backend.
+# Display names for every language EchoScript knows about -- used both for
+# the source-language dropdown (services/transcription.py) and to name
+# languages in the Anthropic translation prompt. Falls back to the raw
+# code for anything not listed (e.g. a language Whisper auto-detected
+# that isn't in this table).
 LANGUAGE_NAMES: dict[str, str] = {
     "fr": "French",
     "en": "English",
     "de": "German",
     "fa": "Persian",
     "es": "Spanish",
+    "it": "Italian",
+    "pt": "Portuguese",
+    "nl": "Dutch",
+    "ar": "Arabic",
+    "ru": "Russian",
+    "tr": "Turkish",
 }
 
-# Target languages exposed as the "Outputs" checkboxes in the UI.
-SUPPORTED_TARGET_LANGUAGES: dict[str, str] = {
+# Target languages offered in the "Outputs" checkboxes when NO Anthropic
+# API key is supplied -- restricted to the set MarianMT can reliably
+# reach (directly, or via an English pivot; see _resolve_marian_engines).
+MARIAN_TARGET_LANGUAGES: dict[str, str] = {
     "en": "English",
     "de": "German",
     "fa": "Persian",
     "es": "Spanish",
 }
 
+# Target languages offered once the person supplies their own Anthropic
+# API key -- Claude has no missing-pair problem, so this list is just
+# "every language EchoScript knows the name of".
+ANTHROPIC_TARGET_LANGUAGES: dict[str, str] = dict(LANGUAGE_NAMES)
+
+# Backwards-compatible alias (kept in case other modules import this name).
+SUPPORTED_TARGET_LANGUAGES = MARIAN_TARGET_LANGUAGES
+
 # Anthropic model used for translation -- Haiku is fast and inexpensive,
 # which fits well for what is otherwise a mechanical translation task.
 _ANTHROPIC_MODEL = "claude-haiku-4-5-20251001"
@@ -68,13 +87,6 @@ class TranslationError(RuntimeError):
     """Raised when no translation backend/model is available for a pair."""
 
 
-def _resolve_backend() -> str:
-    forced = os.environ.get("ECHOSCRIPT_TRANSLATION_BACKEND", "").strip().lower()
-    if forced in ("anthropic", "marian"):
-        return forced
-    return "anthropic" if os.environ.get("ANTHROPIC_API_KEY") else "marian"
-
-
 # ---------------------------------------------------------------------------
 # Anthropic backend
 # ---------------------------------------------------------------------------
@@ -82,15 +94,20 @@ def _resolve_backend() -> str:
 _NUMBERED_LINE_RE = re.compile(r"^\s*(\d+)[.\)]\s?(.*)$")
 
 
-@lru_cache(maxsize=1)
-def _anthropic_client():
+def _anthropic_client(api_key: str):
+    """Build a fresh Anthropic client for this one call.
+
+    Deliberately not cached: the key is supplied per-request by the
+    person using the app and must not linger in any module-level state
+    after the call that needed it returns.
+    """
     import anthropic  # heavy import, deferred until needed
 
-    return anthropic.Anthropic()
+    return anthropic.Anthropic(api_key=api_key)
 
 
 def _translate_batch_via_anthropic(
-    texts: list[str], source_language: str, target_language: str
+    texts: list[str], source_language: str, target_language: str, api_key: str
 ) -> list[str]:
     """Translate a batch of lines in one Claude call, preserving order/count."""
     source_name = LANGUAGE_NAMES.get(source_language, source_language)
@@ -99,7 +116,7 @@ def _translate_batch_via_anthropic(
     numbered_input = "\n".join(f"{i + 1}. {text}" for i, text in enumerate(texts))
 
     try:
-        response = _anthropic_client().messages.create(
+        response = _anthropic_client(api_key).messages.create(
             model=_ANTHROPIC_MODEL,
             max_tokens=4096,
             system=(
@@ -114,6 +131,7 @@ def _translate_batch_via_anthropic(
             messages=[{"role": "user", "content": numbered_input}],
         )
     except Exception as exc:  # pragma: no cover - depends on network/API key
+        # Deliberately do not include the key itself in this message.
         raise TranslationError(
             f"Anthropic translation request failed for "
             f"'{source_language}' -> '{target_language}': {exc}"
@@ -140,7 +158,7 @@ def _translate_batch_via_anthropic(
 
 
 def _translate_segments_via_anthropic(
-    segments: list[Segment], source_language: str, target_language: str
+    segments: list[Segment], source_language: str, target_language: str, api_key: str
 ) -> list[Segment]:
     non_empty = [(i, seg) for i, seg in enumerate(segments) if seg.text]
     translated_text_by_index: dict[int, str] = {}
@@ -148,7 +166,7 @@ def _translate_segments_via_anthropic(
     for start in range(0, len(non_empty), _ANTHROPIC_BATCH_SIZE):
         chunk = non_empty[start : start + _ANTHROPIC_BATCH_SIZE]
         texts = [seg.text for _, seg in chunk]
-        translated = _translate_batch_via_anthropic(texts, source_language, target_language)
+        translated = _translate_batch_via_anthropic(texts, source_language, target_language, api_key)
         for (i, _), text in zip(chunk, translated):
             translated_text_by_index[i] = text
 
@@ -175,6 +193,7 @@ def _try_load_marian_engine(source_language: str, target_language: str):
     Returns (tokenizer, model), or None if no such model exists on the Hub
     (e.g. Helsinki-NLP doesn't publish every pair directly). Cached either
     way so a missing pair isn't re-checked over the network on every call.
+    Safe to cache: these are public model weights, not secrets.
 
     Loads the model/tokenizer directly via AutoModelForSeq2SeqLM rather
     than transformers.pipeline("translation", ...): as of transformers v5,
@@ -251,15 +270,19 @@ def _translate_segments_via_marian(
 class TranslationService:
     """Translates a Transcript into one or more target languages.
 
-    Backend ("anthropic" or "marian") is resolved once at construction
-    time -- pass `backend` explicitly to override the
-    ECHOSCRIPT_TRANSLATION_BACKEND / ANTHROPIC_API_KEY auto-detection.
+    The backend is resolved per call from `api_key`, not stored on the
+    instance: pass an Anthropic API key to use Claude for that call, or
+    omit it to use the offline MarianMT backend. This means a single
+    long-lived TranslationService is safe to share across requests/users --
+    nothing about any particular key sticks to it.
     """
 
-    def __init__(self, backend: str | None = None) -> None:
-        self.backend = backend or _resolve_backend()
-
-    def translate(self, transcript: Transcript, target_language: str) -> Translation:
+    def translate(
+        self,
+        transcript: Transcript,
+        target_language: str,
+        api_key: str | None = None,
+    ) -> Translation:
         """Translate every segment of `transcript`, preserving timing."""
         if target_language == transcript.language:
             # Already in the target language -- relabel, don't re-translate.
@@ -269,9 +292,11 @@ class TranslationService:
                 segments=list(transcript.segments),
             )
 
-        if self.backend == "anthropic":
+        effective_key = (api_key or "").strip() or os.environ.get("ANTHROPIC_API_KEY")
+
+        if effective_key:
             translated_segments = _translate_segments_via_anthropic(
-                transcript.segments, transcript.language, target_language
+                transcript.segments, transcript.language, target_language, effective_key
             )
         else:
             translated_segments = _translate_segments_via_marian(
@@ -288,10 +313,13 @@ class TranslationService:
         self,
         transcript: Transcript,
         target_languages: list[str],
+        api_key: str | None = None,
     ) -> dict[str, Translation]:
         """Translate into several target languages at once.
 
         Returns a dict keyed by target-language code, in line with how the
         UI's multi-select "Outputs" checkboxes will want to fan out.
         """
-        return {lang: self.translate(transcript, lang) for lang in target_languages}
+        return {
+            lang: self.translate(transcript, lang, api_key=api_key) for lang in target_languages
+        }