diff --git a/v2/src/pages/MissionWorkspace.tsx b/v2/src/pages/MissionWorkspace.tsx
index 6ed3622..34c6bce 100644
--- a/v2/src/pages/MissionWorkspace.tsx
+++ b/v2/src/pages/MissionWorkspace.tsx
@@ -49,7 +49,7 @@ import {
   loadDraft,
   saveDraft,
 } from "@/services/draft-store";
-import { runMissionCode } from "@/services/runner";
+import { runManualCode, runMissionCode } from "@/services/runner";
 import {
   runMissionAdmin,
   type MissionSolution,
@@ -62,6 +62,7 @@ import {
   type Attempt,
   type AttemptKind,
   type Language,
+  type ManualRunResult,
   type RunResult,
 } from "@/types";
 
@@ -70,6 +71,7 @@ const MonacoEditor = lazy(() => import("@monaco-editor/react"));
 type MobilePane = "brief" | "code" | "results";
 type BriefTab = "problem" | "hints" | "history" | "solution";
 type SaveState = "loading" | "saving" | "synced" | "local" | "error";
+type ManualRunState = "idle" | "running";
 
 const RESULTS_WIDTH_KEY = "tomatin.v3.workspace-results-width";
 const MIN_RESULTS_WIDTH = 290;
@@ -432,6 +434,10 @@ export function Component() {
   const [saveState, setSaveState] = useState<SaveState>("loading");
   const [saveMessage, setSaveMessage] = useState("");
   const [result, setResult] = useState<RunResult | null>(null);
+  const [manualOpen, setManualOpen] = useState(false);
+  const [manualExpression, setManualExpression] = useState("");
+  const [manualResult, setManualResult] = useState<ManualRunResult | null>(null);
+  const [manualRunning, setManualRunning] = useState<ManualRunState>("idle");
   const [running, setRunning] = useState<AttemptKind | null>(null);
   const [briefTab, setBriefTab] = useState<BriefTab>(
     linkedAttemptId || linkedReviewId ? "history" : "problem",
@@ -817,6 +823,19 @@ export function Component() {
     setRunning(null);
   }
 
+  async function executeManualTest() {
+    if (language === "cpp" || manualRunning === "running") return;
+    setManualRunning("running");
+    setManualResult(null);
+    const manual = await runManualCode({
+      language,
+      code: currentCode,
+      expression: manualExpression,
+    });
+    setManualResult(manual);
+    setManualRunning("idle");
+  }
+
   function clampResultsWidth(nextWidth: number) {
     const workbenchWidth = workbenchRef.current?.clientWidth ?? 0;
     const maxWidth = Math.max(
@@ -1428,6 +1447,23 @@ export function Component() {
                   ? "Pyodide Worker"
                   : "Web Worker"}
             </span>
+            <button
+              className="button secondary"
+              type="button"
+              disabled={Boolean(running) || isStudentPreview || language === "cpp"}
+              title={
+                language === "cpp"
+                  ? "El probador manual está disponible solo para JavaScript y Python"
+                  : undefined
+              }
+              onClick={() => {
+                setManualOpen(true);
+                setManualResult(null);
+              }}
+            >
+              <TerminalSquare aria-hidden="true" />
+              Test Manual
+            </button>
             <button
               className="button secondary"
               type="button"
@@ -1478,6 +1514,125 @@ export function Component() {
           </div>
           </section>
 
+          {manualOpen ? (
+            <div className="manual-test-backdrop" role="presentation">
+              <section
+                className="manual-test-dialog"
+                aria-labelledby="manual-test-title"
+                role="dialog"
+                aria-modal="true"
+              >
+                <header>
+                  <div>
+                    <span className="eyebrow">PRUEBA MANUAL</span>
+                    <h2 id="manual-test-title">
+                      Ejecutar expresión en {LANGUAGE_META[language].label}
+                    </h2>
+                    <p className="manual-test-desc">
+                      Prueba aquí tus funciones con valores personalizados
+                    </p>
+                  </div>
+                  <button
+                    className="icon-button"
+                    type="button"
+                    aria-label="Cerrar prueba manual"
+                    title="Cerrar"
+                    onClick={() => setManualOpen(false)}
+                  >
+                    <X aria-hidden="true" />
+                  </button>
+                </header>
+                <label className="manual-test-field">
+                  <span>Expresión</span>
+                  <input
+                    type="text"
+                    value={manualExpression}
+                    placeholder={
+                      language === "python" ? "mi_funcion(42)" : "miFuncion(42)"
+                    }
+                    onChange={(event) => setManualExpression(event.target.value)}
+                    onKeyDown={(event) => {
+                      if (event.key === "Enter") {
+                        event.preventDefault();
+                        void executeManualTest();
+                      }
+                    }}
+                    autoFocus
+                  />
+                </label>
+                {manualSignatureHints.length > 0 ? (
+                  <p className="manual-test-hint">
+                    Funciones evaluadas en este ejercicio:{" "}
+                    {manualSignatureHints.map((signature, index) => (
+                      <span key={signature}>
+                        {index > 0 ? ", " : ""}
+                        <code>{signature}</code>
+                      </span>
+                    ))}
+                  </p>
+                ) : null}
+                <div className="manual-test-actions">
+                  <button
+                    className="button secondary"
+                    type="button"
+                    onClick={() => setManualOpen(false)}
+                  >
+                    Cancelar
+                  </button>
+                  <button
+                    className="button primary"
+                    type="button"
+                    disabled={manualRunning === "running"}
+                    onClick={() => void executeManualTest()}
+                  >
+                    {manualRunning === "running" ? (
+                      <LoaderCircle className="spin" aria-hidden="true" />
+                    ) : (
+                      <Play aria-hidden="true" />
+                    )}
+                    Ejecutar expresión
+                  </button>
+                </div>
+                {manualResult ? (
+                  <section
+                    className={`manual-test-result result-${manualResult.status}`}
+                    aria-live="polite"
+                  >
+                    <strong>
+                      {manualResult.status === "passed"
+                        ? "Resultado"
+                        : "No se pudo ejecutar"}
+                    </strong>
+                    <dl>
+                      <div>
+                        <dt>Expresión</dt>
+                        <dd>
+                          <code>{manualResult.expression}</code>
+                        </dd>
+                      </div>
+                      {manualResult.value !== undefined ? (
+                        <div>
+                          <dt>Valor</dt>
+                          <dd>
+                            <code>{manualResult.value}</code>
+                          </dd>
+                        </div>
+                      ) : null}
+                    </dl>
+                    {manualResult.stdout || manualResult.stderr ? (
+                      <pre>
+                        {manualResult.stdout ? `$ ${manualResult.stdout}\n` : ""}
+                        {manualResult.stderr
+                          ? `[stderr]\n${manualResult.stderr}`
+                          : ""}
+                      </pre>
+                    ) : null}
+                  </section>
+                ) : null}
+              </section>
+            </div>
+          ) : null}
+
           <button
             className="workspace-resizer"
             type="button"
diff --git a/v2/src/services/runner.ts b/v2/src/services/runner.ts
index 698b2e7..cee7c8f 100644
--- a/v2/src/services/runner.ts
+++ b/v2/src/services/runner.ts
@@ -1,4 +1,6 @@
 import type {
+  Language,
+  ManualRunResult,
   MissionTest,
   RunnerRequest,
   RunResult,
@@ -14,6 +16,7 @@ interface WorkerResponse {
   ok: boolean;
   logs: string[];
   tests: TestResult[];
+  manual?: ManualRunResult | { expression: string; value?: string } | null;
   error?: string;
   stack?: string;
 }
@@ -84,6 +87,117 @@ function runInWorker(
   });
 }
 
+function runManualInWorker(
+  worker: Worker,
+  request: ManualRunnerRequest,
+  timeoutMs: number,
+): Promise<ManualRunResult> {
+  const startedAt = performance.now();
+
+  return new Promise((resolve) => {
+    const timeout = window.setTimeout(() => {
+      worker.terminate();
+      resolve({
+        id: crypto.randomUUID(),
+        status: "timeout",
+        expression: request.expression,
+        stdout: "",
+        stderr: `La ejecución superó ${timeoutMs} ms.`,
+        diagnostics: [],
+        durationMs: timeoutMs,
+        createdAt: new Date().toISOString(),
+      });
+    }, timeoutMs);
+
+    worker.onmessage = ({ data }: MessageEvent<WorkerResponse>) => {
+      window.clearTimeout(timeout);
+      worker.terminate();
+      const manual = data.manual && "expression" in data.manual ? data.manual : null;
+      resolve({
+        id: crypto.randomUUID(),
+        status: data.ok ? "passed" : "runtime_error",
+        expression: request.expression,
+        value: manual?.value,
+        stdout: data.logs.join("\n").slice(0, 32_768),
+        stderr: data.error ?? "",
+        diagnostics: data.error
+          ? [{ severity: "error", message: data.error }]
+          : [],
+        durationMs: Math.round(performance.now() - startedAt),
+        createdAt: new Date().toISOString(),
+      });
+    };
+
+    worker.onerror = (event) => {
+      window.clearTimeout(timeout);
+      worker.terminate();
+      resolve({
+        id: crypto.randomUUID(),
+        status: "runtime_error",
+        expression: request.expression,
+        stdout: "",
+        stderr: event.message,
+        diagnostics: [{ severity: "error", message: event.message }],
+        durationMs: Math.round(performance.now() - startedAt),
+        createdAt: new Date().toISOString(),
+      });
+    };
+
+    worker.postMessage({
+      code: request.code,
+      tests: [],
+      manualExpression: request.expression,
+    });
+  });
+}
+
+export async function runManualCode(
+  request: ManualRunnerRequest,
+): Promise<ManualRunResult> {
+  if (request.code.length > 65_536) {
+    return {
+      id: crypto.randomUUID(),
+      status: "failed",
+      expression: request.expression,
+      stdout: "",
+      stderr: "El código supera el límite de 64 KB.",
+      diagnostics: [],
+      createdAt: new Date().toISOString(),
+    };
+  }
+
+  if (!request.expression.trim()) {
+    return {
+      id: crypto.randomUUID(),
+      status: "failed",
+      expression: request.expression,
+      stdout: "",
+      stderr: "Escribe una expresión para probar.",
+      diagnostics: [],
+      createdAt: new Date().toISOString(),
+    };
+  }
+
+  if (request.language === "javascript") {
+    return runManualInWorker(
+      new Worker(
+        new URL("../workers/javascript-runner.worker.ts", import.meta.url),
+        { type: "module" },
+      ),
+      request,
+      1_500,
+    );
+  }
+
+  return runManualInWorker(
+    new Worker(new URL("../workers/python-runner.worker.ts", import.meta.url), {
+      type: "module",
+    }),
+    request,
+    30_000,
+  );
+}
+
 export async function runMissionCode(request: RunnerRequest): Promise<RunResult> {
   const variant = request.mission.variants[request.language];
   const tests = variant.publicTests;
diff --git a/v2/src/styles.css b/v2/src/styles.css
index 30eda02..211fc00 100644
--- a/v2/src/styles.css
+++ b/v2/src/styles.css
@@ -3958,6 +3958,138 @@ fieldset legend {
   font-size: 11px;
 }
 
+.manual-test-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 70;
+  display: grid;
+  place-items: center;
+  padding: 20px;
+  background: rgb(0 0 0 / 0.58);
+}
+
+.manual-test-dialog {
+  width: min(620px, 100%);
+  max-height: min(720px, calc(100vh - 40px));
+  overflow: auto;
+  border: 1px solid rgb(127 255 180 / 0.22);
+  border-radius: 8px;
+  background: #07100c;
+  box-shadow: 0 24px 80px rgb(0 0 0 / 0.42);
+}
+
+.manual-test-dialog header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 20px 20px 12px;
+  border-bottom: 1px solid rgb(127 255 180 / 0.12);
+}
+
+.manual-test-dialog h2 {
+  margin: 4px 0 0;
+  font-size: 1.1rem;
+}
+
+.manual-test-field {
+  display: grid;
+  gap: 8px;
+  padding: 18px 20px 0;
+}
+
+.manual-test-field span {
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 700;
+  text-transform: uppercase;
+}
+
+.manual-test-field input {
+  width: 100%;
+  min-height: 44px;
+  border: 1px solid rgb(127 255 180 / 0.18);
+  border-radius: 6px;
+  padding: 0 12px;
+  background: #0b1811;
+  color: var(--text);
+  font: 0.95rem "JetBrains Mono", "SFMono-Regular", Consolas, monospace;
+}
+
+.manual-test-hint {
+  margin: 10px 20px 0;
+  color: var(--muted);
+  font-size: 0.84rem;
+  line-height: 1.55;
+}
+
+.manual-test-hint code {
+  color: var(--text);
+}
+
+.manual-test-desc {
+  margin: 5px 0px 0;
+  color: var(--muted);
+  font-size: 0.84rem;
+  line-height: 1.55;
+}
+
+.manual-test-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+  padding: 16px 20px 20px;
+}
+
+.manual-test-result {
+  margin: 0 20px 20px;
+  border: 1px solid rgb(127 255 180 / 0.14);
+  border-radius: 8px;
+  padding: 14px;
+  background: rgb(255 255 255 / 0.035);
+}
+
+.manual-test-result.result-runtime_error,
+.manual-test-result.result-timeout,
+.manual-test-result.result-failed {
+  border-color: rgb(248 113 113 / 0.28);
+  background: rgb(248 113 113 / 0.08);
+}
+
+.manual-test-result dl {
+  display: grid;
+  gap: 10px;
+  margin: 12px 0 0;
+}
+
+.manual-test-result dl > div {
+  display: grid;
+  gap: 4px;
+}
+
+.manual-test-result dt {
+  color: var(--muted);
+  font-size: 0.75rem;
+  font-weight: 800;
+  text-transform: uppercase;
+}
+
+.manual-test-result dd {
+  margin: 0;
+  overflow-wrap: anywhere;
+}
+
+.manual-test-result pre {
+  max-height: 220px;
+  overflow: auto;
+  margin: 12px 0 0;
+  border-radius: 6px;
+  padding: 12px;
+  background: #030805;
+  color: var(--text);
+  white-space: pre-wrap;
+}
+
 .results-pane {
   display: flex;
   flex-direction: column;
diff --git a/v2/src/types.ts b/v2/src/types.ts
index 3ce04e2..fd738a3 100644
--- a/v2/src/types.ts
+++ b/v2/src/types.ts
@@ -239,6 +239,18 @@ export interface RunResult {
   createdAt: string;
 }
 
+export interface ManualRunResult {
+  id: string;
+  status: Exclude<RunStatus, "queued" | "running">;
+  expression: string;
+  value?: string;
+  stdout: string;
+  stderr: string;
+  diagnostics: Diagnostic[];
+  durationMs?: number;
+  createdAt: string;
+}
+
 export type RepositorySyncStatus =
   | "synced"
   | "pending_setup"
diff --git a/v2/src/workers/javascript-runner.worker.ts b/v2/src/workers/javascript-runner.worker.ts
index c7c777f..47b0774 100644
--- a/v2/src/workers/javascript-runner.worker.ts
+++ b/v2/src/workers/javascript-runner.worker.ts
@@ -1,10 +1,11 @@
 /// <reference lib="webworker" />
 
-import type { MissionTest, TestResult } from "@/types";
+import type { ManualRunResult, MissionTest, TestResult } from "@/types";
 
 interface WorkerRequest {
   code: string;
   tests: MissionTest[];
+  manualExpression?: string;
 }
 
 function serialize(value: unknown): string {
@@ -25,6 +26,28 @@ self.onmessage = ({ data }: MessageEvent<WorkerRequest>) => {
   };
 
   try {
+    if (data.manualExpression !== undefined) {
+      const execute = new Function(
+        "console",
+        "serializeValue",
+        `"use strict";
+${data.code}
+return serializeValue((${data.manualExpression}));`,
+      );
+      const result: ManualRunResult = {
+        id: crypto.randomUUID(),
+        status: "passed",
+        expression: data.manualExpression,
+        value: execute(consoleProxy, serialize) as string,
+        stdout: logs.join("\n").slice(0, 32_768),
+        stderr: "",
+        diagnostics: [],
+        createdAt: new Date().toISOString(),
+      };
+      self.postMessage({ ok: true, logs, tests: [], manual: result });
+      return;
+    }
+
     const checks = data.tests
       .map((entry) => {
         const actual = entry.actualExpression
diff --git a/v2/src/workers/python-runner.worker.ts b/v2/src/workers/python-runner.worker.ts
index 1aa5e37..55e437e 100644
--- a/v2/src/workers/python-runner.worker.ts
+++ b/v2/src/workers/python-runner.worker.ts
@@ -5,6 +5,7 @@ import type { MissionTest } from "@/types";
 interface WorkerRequest {
   code: string;
   tests: MissionTest[];
+  manualExpression?: string;
 }
 
 interface PyodideRuntime {
@@ -32,6 +33,8 @@ self.onmessage = async ({ data }: MessageEvent<WorkerRequest>) => {
     const runtime = await loadRuntime();
     runtime.globals.set("__tomatin_code", data.code);
     runtime.globals.set("__tomatin_tests_json", JSON.stringify(data.tests));
+    runtime.globals.set("__tomatin_manual_expression", data.manualExpression ?? "");
+    runtime.globals.set("__tomatin_manual_enabled", data.manualExpression !== undefined);
     const payload = await runtime.runPythonAsync(`
 import contextlib
 import io
@@ -42,33 +45,37 @@ _namespace = {}
 _stdout = io.StringIO()
 _resultados = []
 _error = None
+_manual = None
 
 try:
     with contextlib.redirect_stdout(_stdout), contextlib.redirect_stderr(_stdout):
         exec(__tomatin_code, _namespace)
-        for _prueba in json.loads(__tomatin_tests_json):
-            try:
-                _paso = bool(eval(_prueba["expression"], _namespace))
-                _actual = None
-                if _prueba.get("actualExpression"):
-                    _actual = repr(eval(_prueba["actualExpression"], _namespace))
-                _resultados.append({
-                    "id": _prueba["id"],
-                    "label": _prueba["label"],
-                    "passed": _paso,
-                    "expected": _prueba["expected"],
-                    "actual": _actual,
-                    "feedback": _prueba["feedback"],
-                })
-            except Exception as _test_error:
-                _resultados.append({
-                    "id": _prueba["id"],
-                    "label": _prueba["label"],
-                    "passed": False,
-                    "expected": _prueba["expected"],
-                    "actual": str(_test_error),
-                    "feedback": _prueba["feedback"],
-                })
+        if __tomatin_manual_enabled:
+            _manual = repr(eval(__tomatin_manual_expression, _namespace))
+        else:
+            for _prueba in json.loads(__tomatin_tests_json):
+                try:
+                    _paso = bool(eval(_prueba["expression"], _namespace))
+                    _actual = None
+                    if _prueba.get("actualExpression"):
+                        _actual = repr(eval(_prueba["actualExpression"], _namespace))
+                    _resultados.append({
+                        "id": _prueba["id"],
+                        "label": _prueba["label"],
+                        "passed": _paso,
+                        "expected": _prueba["expected"],
+                        "actual": _actual,
+                        "feedback": _prueba["feedback"],
+                    })
+                except Exception as _test_error:
+                    _resultados.append({
+                        "id": _prueba["id"],
+                        "label": _prueba["label"],
+                        "passed": False,
+                        "expected": _prueba["expected"],
+                        "actual": str(_test_error),
+                        "feedback": _prueba["feedback"],
+                    })
 except Exception:
     _error = traceback.format_exc()
 
@@ -76,6 +83,10 @@ json.dumps({
     "ok": _error is None,
     "logs": _stdout.getvalue().splitlines(),
     "tests": _resultados,
+    "manual": {
+        "expression": __tomatin_manual_expression,
+        "value": _manual,
+    } if __tomatin_manual_enabled and _error is None else None,
     "error": _error,
 })
 `);