@@ -59,6 +59,15 @@ class Settings(BaseSettings):
     perplexity_browser_model: str = "claude-sonnet-4-6"
     perplexity_base_url: str = "http://127.0.0.1:8011"
 
+    # GraceKelly orchestrate path — the AgentFlow branch runs NL->SQL on
+    # Claude Sonnet 5 via GraceKelly (AgentFlow ADR 0008), not Mistral. The
+    # portfolio default_provider stays `mistral`; this slot is selected
+    # explicitly via build_provider("gracekelly"). `claude-sonnet-5` resolves
+    # through GraceKelly's live catalog to "Claude Sonnet 5.0".
+    gracekelly_model: str = "claude-sonnet-5"
+    gracekelly_base_url: str = "http://127.0.0.1:8011"
+    gracekelly_timeout_seconds: float = 180.0
+
     mistral_api_key: str = Field(default="", validation_alias="MISTRAL_API_KEY")
     github_token: str = Field(default="", validation_alias="GITHUB_TOKEN")
     groq_api_key: str = Field(default="", validation_alias="GROQ_API_KEY")
 
@@ -5,6 +5,7 @@
 from nl_sql.config import Settings, get_settings
 from nl_sql.llm.providers.base import LLMProvider, ProviderError
 from nl_sql.llm.providers.github_models import GitHubModelsProvider
+from nl_sql.llm.providers.gracekelly import GraceKellyProvider
 from nl_sql.llm.providers.groq import GroqProvider
 from nl_sql.llm.providers.mistral import MistralProvider
 from nl_sql.llm.providers.ollama import OllamaProvider
@@ -16,11 +17,17 @@ def build_provider(name: str, settings: Settings | None = None) -> LLMProvider:
     """Build an LLMProvider by short name.
 
     Recognized names: ``mistral``, ``github_models``, ``groq``, ``ollama``,
-    ``perplexity``, ``openrouter``. Raises ProviderError for unknown names
-    or missing credentials.
+    ``perplexity``, ``openrouter``, ``gracekelly``. Raises ProviderError for
+    unknown names or missing credentials.
     """
     s = settings or get_settings()
     match name:
+        case "gracekelly":
+            return GraceKellyProvider(
+                model=s.gracekelly_model,
+                base_url=s.gracekelly_base_url,
+                timeout_seconds=s.gracekelly_timeout_seconds,
+            )
         case "mistral":
             return MistralProvider(
                 api_key=s.mistral_api_key,
 
@@ -0,0 +1,110 @@
+"""GraceKelly orchestrate provider — routes generation through a local
+GraceKelly instance that drives a frontier model via its browser adapter.
+
+This is the AgentFlow-branch model slot (see AgentFlow ADR 0008): AgentFlow
+adopts this engine but runs NL->SQL on **Claude Sonnet 5 via GraceKelly**, not
+Mistral. The portfolio NL_SQL default provider stays `mistral`; this provider is
+selected explicitly (`build_provider("gracekelly")`).
+
+Difference from `PerplexityProvider`: that one predates the V2 API and posts to
+`/api/v1/pipeline` reading `answer`. This provider posts to `/api/v1/orchestrate`
+reading `output_text`, which is the contract AgentFlow's serving layer already
+standardised on (`serving/semantic_layer/nl_engine._llm_translate`). GraceKelly
+owns model selection/execution — this provider never talks to a model API
+directly. The default model `claude-sonnet-5` resolves through GraceKelly's live
+catalog to "Claude Sonnet 5.0".
+
+Latency is ~20-40s per call (browser path), so this provider is for evaluation
+runs and one-off probes, not an interactive chat surface.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from urllib import error as urlerror
+from urllib import request as urlrequest
+
+from nl_sql.llm.providers.base import (
+    GenerateRequest,
+    GenerateResponse,
+    ProviderError,
+)
+
+# Reuse the hardened Perplexity/GraceKelly output parsing: strip terminal ANSI
+# codes the Markdown pipeline can leave behind, and unwrap the
+# `{"sql": "...", "rationale": "..."}` envelope Sonnet sometimes emits instead
+# of a bare statement. Same browser backend => same output quirks.
+from nl_sql.llm.providers.perplexity import _ANSI_RE, _unwrap_sql_json
+
+
+class GraceKellyProvider:
+    """LLMProvider that proxies generate() to a local GraceKelly orchestrate API."""
+
+    name: str = "gracekelly"
+
+    def __init__(
+        self,
+        *,
+        model: str = "claude-sonnet-5",
+        base_url: str = "http://127.0.0.1:8011",
+        timeout_seconds: float = 180.0,
+    ) -> None:
+        if not model.strip():
+            raise ProviderError("GraceKellyProvider requires non-empty model")
+        self.model = model
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout_seconds
+
+    def generate(self, req: GenerateRequest) -> GenerateResponse:
+        prompt = req.prompt
+        if req.system:
+            prompt = f"{req.system}\n\n{prompt}"
+        payload = json.dumps({"prompt": prompt, "model": self.model}).encode("utf-8")
+
+        http_request = urlrequest.Request(
+            f"{self._base_url}/api/v1/orchestrate",
+            data=payload,
+            headers={"Content-Type": "application/json", "Accept": "application/json"},
+            method="POST",
+        )
+        t0 = time.perf_counter()
+        try:
+            with urlrequest.urlopen(http_request, timeout=self._timeout) as response:
+                body = response.read().decode("utf-8")
+        except urlerror.HTTPError as exc:
+            raise ProviderError(
+                f"GraceKelly /api/v1/orchestrate returned {exc.code}: "
+                f"{exc.read().decode('utf-8', errors='replace')[:400]}"
+            ) from exc
+        except (urlerror.URLError, TimeoutError) as exc:
+            raise ProviderError(
+                f"GraceKelly unreachable at {self._base_url}: {exc!r}. "
+                "Start it with `python -m uvicorn gracekelly.main:create_app "
+                "--factory --host 127.0.0.1 --port 8011` "
+                "and set GRACEKELLY_EXECUTION_PROFILE=hybrid."
+            ) from exc
+
+        elapsed_ms = (time.perf_counter() - t0) * 1000.0
+        parsed = json.loads(body)
+
+        failure = parsed.get("failure_message") or parsed.get("failure_code")
+        if failure and not parsed.get("output_text"):
+            raise ProviderError(f"GraceKelly orchestrate failed: {failure}")
+
+        answer = _ANSI_RE.sub("", str(parsed.get("output_text") or ""))
+        answer = _unwrap_sql_json(answer)
+
+        model_field = parsed.get("model")
+        model_id = model_field.get("id") if isinstance(model_field, dict) else model_field
+        # Browser path does not surface token counts; use a word-count proxy so
+        # eval reports show something plausible without faking billing units.
+        approx_in = max(1, len(prompt.split()))
+        approx_out = max(1, len(answer.split()))
+        return GenerateResponse(
+            text=answer,
+            model=str(model_id or self.model),
+            input_tokens=approx_in,
+            output_tokens=approx_out,
+            latency_ms=elapsed_ms,
+        )
@@ -0,0 +1,123 @@
+"""Unit tests for the GraceKelly orchestrate provider (AgentFlow ADR 0008 slot).
+
+Mock the HTTP layer so these run without a live GraceKelly server; a live smoke
+is done separately against a running instance.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+from typing import Any
+from unittest import mock
+from urllib import error as urlerror
+
+import pytest
+
+from nl_sql.llm.providers import GenerateRequest, ProviderError, build_provider
+from nl_sql.llm.providers.gracekelly import GraceKellyProvider
+
+
+class _FakeResponse(io.BytesIO):
+    def __enter__(self) -> _FakeResponse:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+
+def _orchestrate_body(**overrides: Any) -> bytes:
+    payload = {
+        "status": "completed",
+        "output_text": "SELECT COUNT(*) FROM orders_v2 WHERE status = 'cancelled';",
+        "model": {"id": "claude-sonnet-5-0", "display_name": "Claude Sonnet 5.0"},
+        "failure_message": None,
+    }
+    payload.update(overrides)
+    return json.dumps(payload).encode("utf-8")
+
+
+def test_factory_builds_gracekelly_with_sonnet_5() -> None:
+    provider = build_provider("gracekelly")
+    assert isinstance(provider, GraceKellyProvider)
+    assert provider.name == "gracekelly"
+    assert provider.model == "claude-sonnet-5"
+
+
+def test_generate_posts_orchestrate_and_parses_output_text() -> None:
+    captured: dict[str, Any] = {}
+
+    def fake_urlopen(req: Any, timeout: float | None = None) -> _FakeResponse:
+        captured["url"] = req.full_url
+        captured["body"] = json.loads(req.data.decode("utf-8"))
+        return _FakeResponse(_orchestrate_body())
+
+    provider = GraceKellyProvider(model="claude-sonnet-5", base_url="http://127.0.0.1:8011")
+    with mock.patch("nl_sql.llm.providers.gracekelly.urlrequest.urlopen", fake_urlopen):
+        resp = provider.generate(GenerateRequest(prompt="how many orders were cancelled?"))
+
+    assert captured["url"] == "http://127.0.0.1:8011/api/v1/orchestrate"
+    assert captured["body"] == {
+        "prompt": "how many orders were cancelled?",
+        "model": "claude-sonnet-5",
+    }
+    assert resp.text == "SELECT COUNT(*) FROM orders_v2 WHERE status = 'cancelled';"
+    assert resp.model == "claude-sonnet-5-0"
+
+
+def test_generate_prepends_system_prompt() -> None:
+    captured: dict[str, Any] = {}
+
+    def fake_urlopen(req: Any, timeout: float | None = None) -> _FakeResponse:
+        captured["body"] = json.loads(req.data.decode("utf-8"))
+        return _FakeResponse(_orchestrate_body())
+
+    provider = GraceKellyProvider()
+    with mock.patch("nl_sql.llm.providers.gracekelly.urlrequest.urlopen", fake_urlopen):
+        provider.generate(
+            GenerateRequest(system="You are a DuckDB SQL generator.", prompt="revenue?")
+        )
+
+    assert captured["body"]["prompt"] == "You are a DuckDB SQL generator.\n\nrevenue?"
+
+
+def test_generate_unwraps_sql_json_envelope() -> None:
+    envelope = json.dumps({"sql": "SELECT 1", "rationale": "trivial"})
+
+    def fake_urlopen(req: Any, timeout: float | None = None) -> _FakeResponse:
+        return _FakeResponse(_orchestrate_body(output_text=envelope))
+
+    provider = GraceKellyProvider()
+    with mock.patch("nl_sql.llm.providers.gracekelly.urlrequest.urlopen", fake_urlopen):
+        resp = provider.generate(GenerateRequest(prompt="q"))
+
+    assert resp.text == "SELECT 1"
+
+
+def test_generate_raises_on_orchestrate_failure() -> None:
+    def fake_urlopen(req: Any, timeout: float | None = None) -> _FakeResponse:
+        return _FakeResponse(_orchestrate_body(output_text="", failure_message="browser timeout"))
+
+    provider = GraceKellyProvider()
+    with (
+        mock.patch("nl_sql.llm.providers.gracekelly.urlrequest.urlopen", fake_urlopen),
+        pytest.raises(ProviderError, match="browser timeout"),
+    ):
+        provider.generate(GenerateRequest(prompt="q"))
+
+
+def test_generate_wraps_http_error() -> None:
+    def fake_urlopen(req: Any, timeout: float | None = None) -> _FakeResponse:
+        raise urlerror.HTTPError(req.full_url, 422, "Unsupported model", {}, io.BytesIO(b"nope"))  # type: ignore[arg-type]
+
+    provider = GraceKellyProvider()
+    with (
+        mock.patch("nl_sql.llm.providers.gracekelly.urlrequest.urlopen", fake_urlopen),
+        pytest.raises(ProviderError, match="422"),
+    ):
+        provider.generate(GenerateRequest(prompt="q"))
+
+
+def test_empty_model_rejected() -> None:
+    with pytest.raises(ProviderError):
+        GraceKellyProvider(model="  ")