diff --git a/build.zig.zon b/build.zig.zon
index 725fbed4d..00c2eeac8 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -36,8 +36,8 @@
             .hash = "sqlite3-3.53.2-DMxLWuAOAAA_Px0arJOIOaP4AKEu5prbsQgPMA35W1zz",
         },
         .zenai = .{
-            .url = "git+https://github.com/lightpanda-io/zenai.git#00c793fdd2797ae5fc9700c189d8617f167ae0dc",
-            .hash = "zenai-0.0.0-iOY_VGOnBQDaWE_Gn8cwhh0XXE8RZ8ESE7QtcITF-P73",
+            .url = "git+https://github.com/lightpanda-io/zenai.git#fce390119e2a4bb5d33f55579c6f6a79dfb245f6",
+            .hash = "zenai-0.0.0-iOY_VHzrBQBkTrBexUzTVhDNWGLNA7Vh2eoPuMnlUVZS",
         },
         .isocline = .{
             .url = "git+https://github.com/arrufat/isocline?ref=lightpanda#832a9fe25f5f4458fcc47b5acc7c21db669c2f47",
diff --git a/src/agent/Agent.zig b/src/agent/Agent.zig
index c2481a919..d270e8a52 100644
--- a/src/agent/Agent.zig
+++ b/src/agent/Agent.zig
@@ -38,6 +38,8 @@ const Terminal = @import("Terminal.zig");
 const ansi = @import("ansi.zig");
 const SlashCommand = @import("SlashCommand.zig");
 const settings = @import("settings.zig");
+const auth = @import("auth/auth.zig");
+const models_dev = @import("auth/models_dev.zig");
 const picker = @import("picker.zig");
 const save = @import("save.zig");
 const welcome = @import("welcome.zig");
@@ -136,6 +138,12 @@ model_credentials: ?Credentials,
 /// Allocated credentials key (Vertex gcloud token) — other keys are unowned
 /// env pointers. The AI client references it: free only after client deinit.
 owned_key: ?[:0]const u8,
+/// Active subscription (bearer) auth. Owns `model_credentials.key`, so it must
+/// outlive the AI client; refreshed between turns by `refreshAuthIfNeeded`.
+auth_session: ?auth.Session,
+/// App data dir (owned by `App`, which outlives the agent), used to cache the
+/// models.dev catalog. Null when no data dir is available.
+app_dir: ?[]const u8,
 /// True when the no-LLM state is a persisted preference (remembered null
 /// provider or runtime `/provider null`), so `reportSaved` writes
 /// `provider = null`. A transient `--no-llm` run leaves it false so saving
@@ -262,9 +270,10 @@ pub fn init(allocator: std.mem.Allocator, app: *App, opts: Config.Agent) !*Agent
     const banner_before = will_repl and (!resolve or settings.hasDetectableKey(opts, remembered));
     if (banner_before) welcome.print(resolve);
 
-    const resolved: ?settings.ResolvedProvider = if (resolve) try settings.resolveCredentials(allocator, opts, remembered, will_repl) else null;
+    var resolved: ?settings.ResolvedProvider = if (resolve) try settings.resolveCredentials(allocator, opts, remembered, will_repl) else null;
     // Before the ai_client errdefer, so on unwind the client goes first.
     errdefer if (resolved) |r| if (r.key_owned) allocator.free(r.credentials.key);
+    errdefer if (resolved) |*r| if (r.session) |*s| s.deinit();
 
     if (will_repl and !banner_before and resolved != null) welcome.print(resolve);
     const llm: ?Credentials = if (resolved) |r| r.credentials else null;
@@ -321,6 +330,8 @@ pub fn init(allocator: std.mem.Allocator, app: *App, opts: Config.Agent) !*Agent
         .ai_client = null,
         .model_credentials = llm,
         .owned_key = if (resolved) |r| (if (r.key_owned) r.credentials.key else null) else null,
+        .auth_session = if (resolved) |r| r.session else null,
+        .app_dir = app.app_dir_path,
         .no_llm_persisted = remembered_no_llm,
         .model_base_url = opts.base_url,
         .model_completions = null,
@@ -353,7 +364,7 @@ pub fn init(allocator: std.mem.Allocator, app: *App, opts: Config.Agent) !*Agent
 
     try self.startSession();
 
-    self.ai_client = if (llm) |l| try zenai.provider.Client.init(allocator, lp.io, l, .{ .base_url = opts.base_url, .retry_policy = .long_running, .bill_to = hfBillTo(l.provider), .environ = lp.environ() }) else null;
+    self.ai_client = if (llm) |l| try zenai.provider.Client.init(lp.io, allocator, l, .{ .base_url = opts.base_url, .retry_policy = .long_running, .bill_to = hfBillTo(l.provider), .environ = lp.environ() }) else null;
     errdefer if (self.ai_client) |c| c.deinit(allocator);
     if (self.ai_client) |c| c.setInterrupt(&self.http_interrupt);
 
@@ -382,6 +393,7 @@ pub fn deinit(self: *Agent) void {
     self.browser.deinit();
     self.notification.deinit();
     if (self.ai_client) |ai_client| ai_client.deinit(self.allocator);
+    if (self.auth_session) |*s| s.deinit();
     if (self.owned_key) |k| self.allocator.free(k);
     self.allocator.free(self.model);
     for (self.available_providers) |p| self.allocator.free(p);
@@ -905,9 +917,11 @@ fn handleProvider(self: *Agent, _: std.mem.Allocator, rest: []const u8) void {
         self.terminal.printError("unknown provider: {s} (or 'null' to disable the LLM)", .{trimmed});
         return;
     };
-    // Re-selecting vertex falls through — that's the token-refresh path.
+    // Re-selecting vertex (token refresh) or a subscription provider (re-import
+    // after logging into its CLI) falls through instead of no-op'ing.
     const vertex_project = provider == .vertex and settings.vertexProjectMode();
-    if (self.model_credentials) |current| if (provider == current.provider and !vertex_project) {
+    const subscription = auth.descriptorFor(provider) != null;
+    if (self.model_credentials) |current| if (provider == current.provider and !vertex_project and !subscription) {
         self.terminal.printInfo("provider: {s}", .{@tagName(provider)});
         return;
     };
@@ -916,17 +930,33 @@ fn handleProvider(self: *Agent, _: std.mem.Allocator, rest: []const u8) void {
             self.terminal.printError("could not obtain a Vertex access token: {s} (details above)", .{@errorName(err)});
             return;
         };
-        self.setProvider(.{ .provider = .vertex, .key = token }, token) catch |err| {
+        self.setProvider(.{ .provider = .vertex, .key = token }, token, null) catch |err| {
             self.allocator.free(token);
             self.terminal.printError("failed to set provider: {s}", .{@errorName(err)});
         };
         return;
     }
+    // Subscription takes priority; on no importable credential, fall through to
+    // the API-key path.
+    if (subscription) {
+        if (auth.sessionFor(self.allocator, provider) catch null) |session| {
+            var owned = session;
+            self.setProvider(.{ .provider = provider, .key = owned.tokens.access_token, .auth = .bearer }, null, owned) catch |err| {
+                owned.deinit();
+                self.terminal.printError("failed to set provider: {s}", .{@errorName(err)});
+            };
+            return;
+        }
+    }
     const key = zenai.provider.envApiKey(lp.environ(), provider) orelse {
         if (provider == .vertex) {
             self.terminal.printError("vertex needs VERTEX_API_KEY (express mode) or GOOGLE_CLOUD_PROJECT (project mode, token via gcloud)", .{});
             return;
         }
+        if (subscription) {
+            self.terminal.printError("no API key or subscription for {s}; set {s} or log into Claude Code", .{ @tagName(provider), zenai.provider.envVarName(provider) });
+            return;
+        }
         self.terminal.printError("no API key for {s}; set {s}", .{ @tagName(provider), zenai.provider.envVarName(provider) });
         return;
     };
@@ -939,7 +969,7 @@ fn handleProvider(self: *Agent, _: std.mem.Allocator, rest: []const u8) void {
         self.terminal.printError("no llama.cpp server with a loaded model at {s}", .{self.model_base_url orelse zenai.provider.llama_cpp_default_base_url});
         return;
     }
-    self.setProvider(.{ .provider = provider, .key = key }, null) catch |err| {
+    self.setProvider(.{ .provider = provider, .key = key }, null, null) catch |err| {
         self.terminal.printError("failed to set provider: {s}", .{@errorName(err)});
     };
 }
@@ -966,9 +996,11 @@ fn hfBillTo(provider: Config.AiProvider) ?[]const u8 {
 }
 
 /// `owned_key` transfers ownership of an allocated `credentials.key` (Vertex
-/// gcloud token) on success; on error the caller still owns it.
-fn setProvider(self: *Agent, credentials: Credentials, owned_key: ?[:0]const u8) !void {
-    const new_client = try zenai.provider.Client.init(self.allocator, lp.io, credentials, .{ .base_url = self.model_base_url, .retry_policy = .long_running, .bill_to = hfBillTo(credentials.provider), .environ = lp.environ() });
+/// gcloud token) on success; on error the caller still owns it. `session`
+/// likewise transfers a subscription session that owns `credentials.key`; the
+/// previous session is freed only after the old client is gone.
+fn setProvider(self: *Agent, credentials: Credentials, owned_key: ?[:0]const u8, session: ?auth.Session) !void {
+    const new_client = try zenai.provider.Client.init(lp.io, self.allocator, credentials, .{ .base_url = self.model_base_url, .retry_policy = .long_running, .bill_to = hfBillTo(credentials.provider), .environ = lp.environ() });
     errdefer new_client.deinit(self.allocator);
 
     // A same-provider re-select (vertex token refresh) must not reset the model.
@@ -976,7 +1008,9 @@ fn setProvider(self: *Agent, credentials: Credentials, owned_key: ?[:0]const u8)
     const new_model = try self.allocator.dupe(u8, if (same_provider) self.model else zenai.provider.defaultModel(credentials.provider));
     if (self.ai_client) |client| client.deinit(self.allocator);
     if (self.owned_key) |k| self.allocator.free(k);
+    if (self.auth_session) |*s| s.deinit();
     self.owned_key = owned_key;
+    self.auth_session = session;
     new_client.setInterrupt(&self.http_interrupt);
     self.ai_client = new_client;
     self.model_credentials = credentials;
@@ -984,13 +1018,38 @@ fn setProvider(self: *Agent, credentials: Credentials, owned_key: ?[:0]const u8)
     self.model_completions = null;
     self.allocator.free(self.model);
     self.model = new_model;
-    self.terminal.printInfo("provider: {s}", .{@tagName(credentials.provider)});
+    if (credentials.auth == .bearer) {
+        const label = if (auth.descriptorFor(credentials.provider)) |d| d.label else "subscription";
+        self.terminal.printInfo("provider: {s} ({s})", .{ @tagName(credentials.provider), label });
+    } else {
+        self.terminal.printInfo("provider: {s}", .{@tagName(credentials.provider)});
+    }
     if (zenai.provider.defaultEffort(credentials.provider)) |e| if (e != self.effort) {
         self.effort = e;
         self.terminal.printInfo("effort: {s} ({s} default)", .{ @tagName(e), @tagName(credentials.provider) });
     };
     self.reportSaved("model", self.model);
-    _ = completionModels(self, self.allocator);
+    // Priming warms the completion cache; skip it for bearer, whose catalog is a
+    // multi-MB models.dev download best deferred to first `/model` use.
+    if (credentials.auth != .bearer) _ = completionModels(self, self.allocator);
+}
+
+/// Keep a subscription (bearer) token current before a model request: when the
+/// active session's token is near expiry, re-import from the source and repoint
+/// the client and credentials at the fresh token. A no-op for API-key auth.
+/// Runs between turns on the single agent thread, never during a request, so the
+/// old buffer (held one cycle by `auth.Session`) is never dereferenced freed.
+fn refreshAuthIfNeeded(self: *Agent) void {
+    if (self.auth_session) |*session| {
+        const new_token = session.ensureFresh() catch |err| {
+            self.terminal.printError("could not refresh the Claude subscription token: {s}", .{@errorName(err)});
+            return;
+        };
+        if (new_token) |tok| {
+            if (self.ai_client) |client| client.setApiKey(tok);
+            if (self.model_credentials) |*c| c.key = tok;
+        }
+    }
 }
 
 const PathAndMode = struct { path: []const u8, mode: save.Mode };
@@ -1157,6 +1216,7 @@ fn saveOneShot(self: *Agent) void {
 /// interactive `/save` and one-shot `--save`.
 fn synthesizeSaveTo(self: *Agent, arena: std.mem.Allocator, path: []const u8, mode: save.Mode, prompt: ?[]const u8) void {
     const provider_client = self.ai_client.?;
+    self.refreshAuthIfNeeded();
 
     // Only update feeds the saved script back to the model; append stays
     // blind — the script is synthesized from this session alone and written
@@ -1599,6 +1659,7 @@ fn processUserMessage(self: *Agent, input: TurnInput) !?[]const u8 {
     }
 
     const provider_client = self.ai_client orelse return error.NoAiClient;
+    self.refreshAuthIfNeeded();
 
     self.terminal.spinner.start();
     var result = provider_client.runTools(
@@ -1839,13 +1900,24 @@ pub fn listModels(allocator: std.mem.Allocator, opts: Config.Agent) !void {
         });
         return error.ConflictingFlags;
     }
-    const resolved = (try settings.resolveCredentials(allocator, opts, null, false)) orelse return error.MissingProvider;
+    var resolved = (try settings.resolveCredentials(allocator, opts, null, false)) orelse return error.MissingProvider;
     const llm = resolved.credentials;
     defer if (resolved.key_owned) allocator.free(llm.key);
+    defer if (resolved.session) |*s| s.deinit();
 
     var arena: std.heap.ArenaAllocator = .init(allocator);
     defer arena.deinit();
-    const ids = zenai.provider.listChatModelIds(allocator, lp.io, arena.allocator(), llm.provider, llm.key, opts.base_url, lp.environ()) catch |err| {
+    // A subscription (bearer) token can't list models via the provider; use the
+    // free models.dev catalog (uncached here — this is a one-shot CLI command).
+    if (llm.auth == .bearer) {
+        const sub_ids = models_dev.modelIds(arena.allocator(), @tagName(llm.provider), null);
+        var stdout_sub = std.Io.File.stdout().writerStreaming(lp.io, &.{});
+        const ws = &stdout_sub.interface;
+        for (sub_ids) |id| try ws.print("{s}\n", .{id});
+        try ws.flush();
+        return;
+    }
+    const ids = zenai.provider.listChatModelIds(lp.io, allocator, arena.allocator(), llm.provider, llm.key, .{ .base_url = opts.base_url, .environ = lp.environ() }) catch |err| {
         if (llm.provider == .vertex and !settings.vertexProjectMode()) {
             std.debug.print("Vertex express mode cannot list models (the endpoint requires OAuth); set GOOGLE_CLOUD_PROJECT for project mode.\n", .{});
         }
@@ -1901,15 +1973,21 @@ fn completionModels(context: *anyopaque, _: std.mem.Allocator) []const []const u
     if (self.model_completions) |c| if (c.provider == llm.provider) return c.ids;
 
     _ = self.model_completion_arena.reset(.retain_capacity);
-    const ids = zenai.provider.listChatModelIds(
-        self.allocator,
-        lp.io,
-        self.model_completion_arena.allocator(),
-        llm.provider,
-        llm.key,
-        self.model_base_url,
-        lp.environ(),
-    ) catch &.{};
+    const arena = self.model_completion_arena.allocator();
+    // A subscription (bearer) token can't hit the provider's `/models` endpoint
+    // (it 401s), so list from the free, unauthenticated models.dev catalog
+    // instead — no API key needed.
+    const ids = if (llm.auth == .bearer)
+        models_dev.modelIds(arena, @tagName(llm.provider), self.app_dir)
+    else
+        zenai.provider.listChatModelIds(
+            lp.io,
+            self.allocator,
+            arena,
+            llm.provider,
+            llm.key,
+            .{ .base_url = self.model_base_url, .environ = lp.environ() },
+        ) catch &.{};
     self.model_completions = .{ .provider = llm.provider, .ids = ids };
     return ids;
 }
diff --git a/src/agent/auth/anthropic.zig b/src/agent/auth/anthropic.zig
new file mode 100644
index 000000000..679437f7f
--- /dev/null
+++ b/src/agent/auth/anthropic.zig
@@ -0,0 +1,64 @@
+// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+//! Anthropic subscription-auth descriptor plus the Claude Code credential
+//! importer. v1 reuses the OAuth token Claude Code already maintains at
+//! `$HOME/.claude/.credentials.json`; the login/refresh-endpoint fields on the
+//! descriptor are the seam for the deferred own-OAuth flow and are unused today.
+
+const std = @import("std");
+const lp = @import("lightpanda");
+const auth = @import("auth.zig");
+
+pub const descriptor: auth.Descriptor = .{
+    .provider = .anthropic,
+    .id = "anthropic",
+    .label = "Claude subscription",
+    .authorize_url = "https://claude.ai/oauth/authorize",
+    .token_url = "https://console.anthropic.com/v1/oauth/token",
+    .client_id = "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+    .redirect_uri = "https://console.anthropic.com/oauth/code/callback",
+    .scope = "org:create_api_key user:profile user:inference",
+    .importFn = importClaudeCode,
+};
+
+/// Read Claude Code's OAuth credentials from `$HOME/.claude/.credentials.json`.
+/// Returns null when the file is absent, unreadable, or malformed (the caller
+/// falls back to API-key auth). Tokens are duped into `allocator`.
+pub fn importClaudeCode(allocator: std.mem.Allocator) !?auth.TokenSet {
+    const home = std.c.getenv("HOME") orelse return null;
+    const path = try std.fs.path.join(allocator, &.{ std.mem.span(home), ".claude", ".credentials.json" });
+    defer allocator.free(path);
+
+    const data = std.Io.Dir.cwd().readFileAlloc(lp.io, path, allocator, .limited(64 * 1024)) catch return null;
+    defer allocator.free(data);
+
+    const Shape = struct {
+        claudeAiOauth: ?struct {
+            accessToken: []const u8,
+            refreshToken: []const u8 = "",
+            expiresAt: i64 = 0,
+        } = null,
+    };
+    const parsed = std.json.parseFromSlice(Shape, allocator, data, .{ .ignore_unknown_fields = true }) catch return null;
+    defer parsed.deinit();
+
+    const oauth = parsed.value.claudeAiOauth orelse return null;
+    if (oauth.accessToken.len == 0) return null;
+    return try auth.TokenSet.dup(allocator, oauth.accessToken, oauth.refreshToken, oauth.expiresAt);
+}
diff --git a/src/agent/auth/auth.zig b/src/agent/auth/auth.zig
new file mode 100644
index 000000000..e66c45da7
--- /dev/null
+++ b/src/agent/auth/auth.zig
@@ -0,0 +1,176 @@
+// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+//! Provider-agnostic subscription (OAuth bearer) auth for the agent. v1 imports
+//! the token a subscription CLI already maintains on disk — Claude Code for
+//! `.anthropic` — and re-reads it on expiry, so the agent never calls the OAuth
+//! token endpoint and cannot disturb that CLI's own login. The `Descriptor`'s
+//! login-endpoint fields are the seam for a future own-OAuth login flow.
+
+const std = @import("std");
+const lp = @import("lightpanda");
+const Config = lp.Config;
+const anthropic = @import("anthropic.zig");
+
+/// Wall-clock ms since the Unix epoch.
+pub fn nowMs() i64 {
+    return std.Io.Clock.now(.real, lp.io).toMilliseconds();
+}
+
+/// An OAuth credential set. `refresh_token`/`expires_at_ms` back expiry handling
+/// (and the deferred refresh grant).
+pub const TokenSet = struct {
+    access_token: [:0]const u8,
+    refresh_token: []const u8,
+    expires_at_ms: i64,
+
+    pub fn dup(allocator: std.mem.Allocator, access: []const u8, refresh: []const u8, expires_at_ms: i64) !TokenSet {
+        const a = try allocator.dupeZ(u8, access);
+        errdefer allocator.free(a);
+        const r = try allocator.dupe(u8, refresh);
+        return .{ .access_token = a, .refresh_token = r, .expires_at_ms = expires_at_ms };
+    }
+
+    pub fn deinit(self: TokenSet, allocator: std.mem.Allocator) void {
+        allocator.free(self.access_token);
+        allocator.free(self.refresh_token);
+    }
+};
+
+/// Static per-provider OAuth configuration. Adding a provider is a data addition
+/// here plus an `importFn`. The login-endpoint fields are the seam for the
+/// deferred own-OAuth login flow and are unused in v1.
+pub const Descriptor = struct {
+    provider: Config.AiProvider,
+    id: []const u8,
+    /// Human label for the credential, e.g. "Claude subscription".
+    label: []const u8,
+    authorize_url: []const u8,
+    token_url: []const u8,
+    client_id: []const u8,
+    redirect_uri: []const u8,
+    scope: []const u8,
+    /// Import a subscription token another CLI already maintains on disk.
+    importFn: ?*const fn (std.mem.Allocator) anyerror!?TokenSet = null,
+};
+
+pub const registry = [_]*const Descriptor{&anthropic.descriptor};
+
+pub fn descriptorFor(provider: Config.AiProvider) ?*const Descriptor {
+    for (registry) |d| if (d.provider == provider) return d;
+    return null;
+}
+
+/// Proactive-refresh margin: re-check the source once the token is within this
+/// window of expiry, so a turn never starts on a token about to lapse.
+const refresh_skew_ms: i64 = 5 * std.time.ms_per_min;
+
+/// A live subscription credential for one provider. Owns its `TokenSet`; the AI
+/// client borrows `tokens.access_token`, so the session must outlive the client.
+pub const Session = struct {
+    allocator: std.mem.Allocator,
+    descriptor: *const Descriptor,
+    tokens: TokenSet,
+    /// The immediately-prior token, kept alive one refresh cycle so a client
+    /// still pointing at it (until `setApiKey`) never dereferences freed memory.
+    previous: ?TokenSet = null,
+
+    /// When the access token is within `refresh_skew_ms` of expiry, re-import
+    /// from the source and, if the source has a newer token, adopt it and return
+    /// the new access token (owned by the session). Returns null when nothing
+    /// changed. The caller must repoint its client with the returned token
+    /// before its next request; the old buffer stays valid until the following
+    /// `ensureFresh`/`deinit`. Errors `SubscriptionTokenExpired` when the token
+    /// has lapsed and the source has no fresher one.
+    pub fn ensureFresh(self: *Session) !?[:0]const u8 {
+        const now = nowMs();
+        if (self.tokens.expires_at_ms - now > refresh_skew_ms) return null;
+
+        const importFn = self.descriptor.importFn orelse return self.staleResult(now);
+        const fresh = (try importFn(self.allocator)) orelse return self.staleResult(now);
+        // The source (e.g. Claude Code) hasn't refreshed yet.
+        if (fresh.expires_at_ms <= self.tokens.expires_at_ms) {
+            fresh.deinit(self.allocator);
+            return self.staleResult(now);
+        }
+
+        if (self.previous) |p| p.deinit(self.allocator);
+        self.previous = self.tokens;
+        self.tokens = fresh;
+        return self.tokens.access_token;
+    }
+
+    fn staleResult(self: *Session, now: i64) error{SubscriptionTokenExpired}!?[:0]const u8 {
+        return if (self.tokens.expires_at_ms > now) null else error.SubscriptionTokenExpired;
+    }
+
+    pub fn deinit(self: *Session) void {
+        self.tokens.deinit(self.allocator);
+        if (self.previous) |p| p.deinit(self.allocator);
+        self.previous = null;
+    }
+};
+
+/// Build a bearer session for `provider` from an available subscription
+/// credential, or null when none is importable.
+pub fn sessionFor(allocator: std.mem.Allocator, provider: Config.AiProvider) !?Session {
+    const desc = descriptorFor(provider) orelse return null;
+    const importFn = desc.importFn orelse return null;
+    const tokens = (try importFn(allocator)) orelse return null;
+    return .{ .allocator = allocator, .descriptor = desc, .tokens = tokens };
+}
+
+/// Process-lifetime memo for `subscriptionAvailable`: the credential file is
+/// probed several times across a single startup resolution, and it doesn't
+/// change under us there (runtime `/provider` re-import goes through `sessionFor`,
+/// which always reads fresh).
+var availability_cache: std.enums.EnumArray(Config.AiProvider, ?bool) = .initFill(null);
+
+/// Is a usable (present, not hard-expired) subscription token importable for
+/// `provider`? Lets the picker offer a subscription without its API-key env var,
+/// and not offer it when no credential exists.
+pub fn subscriptionAvailable(provider: Config.AiProvider) bool {
+    if (availability_cache.get(provider)) |cached| return cached;
+    const result = probeSubscription(provider);
+    availability_cache.set(provider, result);
+    return result;
+}
+
+fn probeSubscription(provider: Config.AiProvider) bool {
+    const desc = descriptorFor(provider) orelse return false;
+    const importFn = desc.importFn orelse return false;
+    var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+    defer arena.deinit();
+    const tokens = (importFn(arena.allocator()) catch return false) orelse return false;
+    // expires_at_ms == 0 means "unknown"; let a live request be the judge.
+    return tokens.expires_at_ms == 0 or tokens.expires_at_ms > nowMs();
+}
+
+test "TokenSet dup/deinit round-trips and is leak-free" {
+    const a = std.testing.allocator;
+    const t = try TokenSet.dup(a, "acc", "ref", 123);
+    defer t.deinit(a);
+    try std.testing.expectEqualStrings("acc", t.access_token);
+    try std.testing.expectEqualStrings("ref", t.refresh_token);
+    try std.testing.expectEqual(@as(i64, 123), t.expires_at_ms);
+}
+
+test "descriptorFor resolves anthropic, null for a non-OAuth provider" {
+    try std.testing.expect(descriptorFor(.anthropic) != null);
+    try std.testing.expectEqual(@as(?*const Descriptor, null), descriptorFor(.openai));
+}
diff --git a/src/agent/auth/models_dev.zig b/src/agent/auth/models_dev.zig
new file mode 100644
index 000000000..2a44f4d2d
--- /dev/null
+++ b/src/agent/auth/models_dev.zig
@@ -0,0 +1,125 @@
+// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+//! Model catalog from models.dev — the free, unauthenticated registry opencode
+//! uses. It lets a subscription (bearer) user list a provider's models without
+//! an API key, and stays current upstream instead of drifting like a hardcoded
+//! list. The full `api.json` is a few MB, so only each provider's id list is
+//! cached on disk (`<app_dir>/models-dev-<provider>.json`) with a TTL; the big
+//! payload is parsed transiently on refresh.
+
+const std = @import("std");
+const lp = @import("lightpanda");
+const auth = @import("auth.zig");
+
+const api_url = "https://models.dev/api.json";
+const cache_ttl_ms: i64 = 24 * std.time.ms_per_hour;
+
+/// Chat-model ids for `provider_id` from models.dev, allocated in `arena`. Reads
+/// a fresh on-disk cache when present, else fetches and refreshes it. Returns an
+/// empty slice on any failure (offline, parse error, no cache) so callers
+/// degrade to accepting a typed-in model name.
+pub fn modelIds(arena: std.mem.Allocator, provider_id: []const u8, app_dir: ?[]const u8) []const []const u8 {
+    if (app_dir) |dir| {
+        if (readCache(arena, dir, provider_id)) |ids| return ids;
+    }
+    const catalog = fetch(arena) catch return &.{};
+    const ids = parseProviderModels(arena, catalog, provider_id) catch return &.{};
+    if (app_dir) |dir| writeCache(dir, provider_id, ids) catch {};
+    return ids;
+}
+
+const Cache = struct {
+    fetched_ms: i64,
+    ids: []const []const u8,
+};
+
+fn cachePath(arena: std.mem.Allocator, app_dir: []const u8, provider_id: []const u8) ![]const u8 {
+    const name = try std.fmt.allocPrint(arena, "models-dev-{s}.json", .{provider_id});
+    return std.fs.path.join(arena, &.{ app_dir, name });
+}
+
+fn readCache(arena: std.mem.Allocator, app_dir: []const u8, provider_id: []const u8) ?[]const []const u8 {
+    const path = cachePath(arena, app_dir, provider_id) catch return null;
+    const data = std.Io.Dir.cwd().readFileAlloc(lp.io, path, arena, .limited(1024 * 1024)) catch return null;
+    const parsed = std.json.parseFromSliceLeaky(Cache, arena, data, .{ .ignore_unknown_fields = true }) catch return null;
+    if (auth.nowMs() - parsed.fetched_ms > cache_ttl_ms) return null;
+    if (parsed.ids.len == 0) return null;
+    return parsed.ids;
+}
+
+fn writeCache(app_dir: []const u8, provider_id: []const u8, ids: []const []const u8) !void {
+    var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+    defer arena.deinit();
+    const a = arena.allocator();
+    const path = try cachePath(a, app_dir, provider_id);
+
+    var buf: std.Io.Writer.Allocating = .init(a);
+    try std.json.Stringify.value(Cache{ .fetched_ms = auth.nowMs(), .ids = ids }, .{}, &buf.writer);
+    try std.Io.Dir.cwd().writeFile(lp.io, .{ .sub_path = path, .data = buf.written() });
+}
+
+/// Model-id keys of `catalog[provider_id].models`. `ignore_unknown_fields` skips
+/// every provider and model's metadata, so only the id strings are built — no
+/// Value tree for the multi-MB payload. The parse runs in a scoped arena; the
+/// ids are duped into `arena`.
+fn parseProviderModels(arena: std.mem.Allocator, catalog: []const u8, provider_id: []const u8) ![]const []const u8 {
+    var parse_arena: std.heap.ArenaAllocator = .init(arena);
+    defer parse_arena.deinit();
+
+    const Empty = struct {};
+    const Provider = struct { models: std.json.ArrayHashMap(Empty) = .{} };
+    const parsed = try std.json.parseFromSliceLeaky(std.json.ArrayHashMap(Provider), parse_arena.allocator(), catalog, .{ .ignore_unknown_fields = true });
+
+    const provider = parsed.map.get(provider_id) orelse return error.ProviderMissing;
+    const keys = provider.models.map.keys();
+    const ids = try arena.alloc([]const u8, keys.len);
+    for (keys, ids) |k, *dst| dst.* = try arena.dupe(u8, k);
+    return ids;
+}
+
+fn fetch(arena: std.mem.Allocator) ![]u8 {
+    var client: std.http.Client = .{ .allocator = arena, .io = lp.io };
+    defer client.deinit();
+
+    const uri = try std.Uri.parse(api_url);
+    var req = try client.request(.GET, uri, .{ .redirect_behavior = @enumFromInt(3) });
+    defer req.deinit();
+    try req.sendBodiless();
+
+    var redirect_buffer: [8 * 1024]u8 = undefined;
+    var response = try req.receiveHead(&redirect_buffer);
+    if (response.head.status != .ok) return error.HttpStatus;
+
+    const decompress_buffer: []u8 = switch (response.head.content_encoding) {
+        .identity => &.{},
+        .zstd => try arena.alloc(u8, std.compress.zstd.default_window_len),
+        .deflate, .gzip => try arena.alloc(u8, std.compress.flate.max_window_len),
+        .compress => return error.UnsupportedCompression,
+    };
+    var transfer_buffer: [4096]u8 = undefined;
+    var decompress: std.http.Decompress = undefined;
+    const reader = response.readerDecompressing(&transfer_buffer, &decompress, decompress_buffer);
+
+    var out: std.Io.Writer.Allocating = .init(arena);
+    _ = reader.streamRemaining(&out.writer) catch |err| switch (err) {
+        error.ReadFailed => return response.bodyErr().?,
+        else => |e| return e,
+    };
+    return out.written();
+}
diff --git a/src/agent/settings.zig b/src/agent/settings.zig
index f819758dd..ff1bdf770 100644
--- a/src/agent/settings.zig
+++ b/src/agent/settings.zig
@@ -28,9 +28,10 @@ const lp = @import("lightpanda");
 const Config = lp.Config;
 const picker = @import("picker.zig");
 const string = @import("../string.zig");
+const auth = @import("auth/auth.zig");
 const Credentials = zenai.provider.Credentials;
 
-pub const api_keys_hint = "ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY, HF_TOKEN, AI_GATEWAY_API_KEY, or MISTRAL_API_KEY (Vertex AI: VERTEX_API_KEY, or GOOGLE_CLOUD_PROJECT via gcloud)";
+pub const api_keys_hint = "ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY, HF_TOKEN, AI_GATEWAY_API_KEY, or MISTRAL_API_KEY (Vertex AI: VERTEX_API_KEY, or GOOGLE_CLOUD_PROJECT via gcloud; Anthropic: a Claude subscription from Claude Code)";
 
 /// Determine which provider to use and read its env key. Returns null
 /// only when no `--provider` was given AND no env key exists (the caller
@@ -41,6 +42,10 @@ pub const ResolvedProvider = struct {
     /// Key allocated (Vertex gcloud token) rather than an env pointer; the
     /// caller frees it, only after the client that references it is gone.
     key_owned: bool = false,
+    /// Set for subscription (bearer) auth. Owns `credentials.key`, so it must
+    /// outlive the AI client; the caller takes ownership. When set, `key_owned`
+    /// stays false — the session frees the key, not the caller directly.
+    session: ?auth.Session = null,
 };
 
 /// Probe a keyless local provider (Ollama, llama.cpp): its env key is a
@@ -50,7 +55,7 @@ pub fn detectLocalProvider(allocator: std.mem.Allocator, tag: Config.AiProvider,
     const key = zenai.provider.envApiKey(lp.environ(), tag) orelse return null;
     var arena: std.heap.ArenaAllocator = .init(allocator);
     defer arena.deinit();
-    const ids = zenai.provider.listChatModelIds(allocator, lp.io, arena.allocator(), tag, key, base_url, lp.environ()) catch return null;
+    const ids = zenai.provider.listChatModelIds(lp.io, allocator, arena.allocator(), tag, key, .{ .base_url = base_url, .environ = lp.environ() }) catch return null;
     if (ids.len == 0) return null;
     return .{ .provider = tag, .key = key };
 }
@@ -97,10 +102,11 @@ pub fn gcloudAccessToken(allocator: std.mem.Allocator) ![:0]const u8 {
 /// env-detected). Skips the Ollama probe so it isn't run twice at startup; the
 /// interactive picker only fires on detected keys, which this still catches.
 pub fn hasDetectableKey(opts: Config.Agent, remembered: ?Remembered) bool {
-    if (opts.provider) |p| return zenai.provider.envApiKey(lp.environ(), p) != null or (p == .vertex and vertexProjectMode());
+    if (opts.provider) |p| return zenai.provider.envApiKey(lp.environ(), p) != null or (p == .vertex and vertexProjectMode()) or auth.subscriptionAvailable(p);
     if (remembered) |r| if (r.provider) |p| {
         if (zenai.provider.envApiKey(lp.environ(), p) != null) return true;
         if (p == .vertex and vertexProjectMode()) return true;
+        if (auth.subscriptionAvailable(p)) return true;
     };
     var buf: [zenai.provider.default_candidates.len]Credentials = undefined;
     return availableProviders(&buf).len > 0;
@@ -114,6 +120,9 @@ pub fn resolveCredentials(allocator: std.mem.Allocator, opts: Config.Agent, reme
             const token = try gcloudAccessToken(allocator);
             return .{ .credentials = .{ .provider = p, .key = token }, .source = .flag, .key_owned = true };
         }
+        // A subscription takes priority over an API key; null = not a
+        // subscription provider (or none available), so fall through.
+        if (try subscriptionResolved(allocator, p, .flag)) |resolved| return resolved;
         const key = zenai.provider.envApiKey(lp.environ(), p) orelse {
             if (p == .vertex) {
                 std.debug.print(
@@ -137,8 +146,13 @@ pub fn resolveCredentials(allocator: std.mem.Allocator, opts: Config.Agent, reme
             if (gcloudAccessToken(allocator)) |token| {
                 return .{ .credentials = .{ .provider = p, .key = token }, .source = .remembered, .key_owned = true };
             } else |_| {}
-        } else if (zenai.provider.envApiKey(lp.environ(), p)) |key| {
-            return .{ .credentials = .{ .provider = p, .key = key }, .source = .remembered };
+        } else {
+            // Subscription takes priority over an API key; both fall through to
+            // detection on miss.
+            if (try subscriptionResolved(allocator, p, .remembered)) |resolved| return resolved;
+            if (zenai.provider.envApiKey(lp.environ(), p)) |key| {
+                return .{ .credentials = .{ .provider = p, .key = key }, .source = .remembered };
+            }
         }
     };
 
@@ -173,16 +187,41 @@ pub fn resolveCredentials(allocator: std.mem.Allocator, opts: Config.Agent, reme
     return try finishResolved(allocator, found[idx], .picked);
 }
 
-/// Swaps the placeholder key of a detected project-mode Vertex for a real
-/// gcloud token.
+/// Swaps a placeholder credential for a live token: a gcloud token for
+/// project-mode Vertex, or an imported subscription session for the Anthropic
+/// bearer placeholder.
 fn finishResolved(allocator: std.mem.Allocator, credentials: Credentials, source: @FieldType(ResolvedProvider, "source")) !ResolvedProvider {
     if (credentials.provider == .vertex and vertexProjectMode()) {
         const token = try gcloudAccessToken(allocator);
         return .{ .credentials = .{ .provider = .vertex, .key = token }, .source = source, .key_owned = true };
     }
+    if (credentials.auth == .bearer and credentials.key.len == 0) {
+        if (try subscriptionResolved(allocator, credentials.provider, source)) |resolved| return resolved;
+        return error.MissingApiKey;
+    }
     return .{ .credentials = credentials, .source = source };
 }
 
+/// Import a subscription and wrap it as a resolved bearer credential. The
+/// returned `session` owns `credentials.key`; the caller must keep it alive as
+/// long as the AI client and free it with `session.deinit`. Null when no
+/// subscription is importable.
+fn subscriptionResolved(allocator: std.mem.Allocator, provider: Config.AiProvider, source: @FieldType(ResolvedProvider, "source")) !?ResolvedProvider {
+    const session = (try auth.sessionFor(allocator, provider)) orelse return null;
+    // Name the credential in effect — a set-but-ignored API key would otherwise
+    // be a silent surprise.
+    if (zenai.provider.envApiKey(lp.environ(), provider) != null) {
+        std.debug.print("{s}: using your {s}; {s} is set but the subscription takes priority.\n", .{ @tagName(provider), session.descriptor.label, zenai.provider.envVarName(provider) });
+    } else {
+        std.debug.print("{s}: using your {s}.\n", .{ @tagName(provider), session.descriptor.label });
+    }
+    return .{
+        .credentials = .{ .provider = provider, .key = session.tokens.access_token, .auth = .bearer },
+        .source = source,
+        .session = session,
+    };
+}
+
 pub const remembered_path = ".lp-agent.zon";
 
 /// Last user-selected provider/model/effort/verbosity, persisted per-directory
@@ -234,7 +273,20 @@ pub fn saveRemembered(remembered: Remembered) !void {
 /// Vertex project mode joins with a placeholder key — no subprocess during a
 /// scan; the gcloud token is fetched on selection (`finishResolved`).
 pub fn availableProviders(buf: []Credentials) []Credentials {
-    const found = zenai.provider.detectKeys(lp.environ(), buf, zenai.provider.default_candidates);
+    var found = zenai.provider.detectKeys(lp.environ(), buf, zenai.provider.default_candidates);
+    // A subscription takes priority over an API key: offer it as a bearer
+    // placeholder (replacing any API-key entry) that `finishResolved` swaps for a
+    // live token on selection, mirroring Vertex project mode below.
+    for (auth.registry) |desc| {
+        if (!auth.subscriptionAvailable(desc.provider)) continue;
+        const placeholder: Credentials = .{ .provider = desc.provider, .key = "", .auth = .bearer };
+        if (indexOfProvider(found, desc.provider)) |i| {
+            found[i] = placeholder;
+        } else if (found.len < buf.len) {
+            buf[found.len] = placeholder;
+            found = buf[0 .. found.len + 1];
+        }
+    }
     if (zenai.provider.useVertex(lp.environ()) and vertexProjectMode() and found.len < buf.len) {
         buf[found.len] = .{ .provider = .vertex, .key = "" };
         return buf[0 .. found.len + 1];
@@ -242,6 +294,11 @@ pub fn availableProviders(buf: []Credentials) []Credentials {
     return found;
 }
 
+fn indexOfProvider(creds: []const Credentials, provider: Config.AiProvider) ?usize {
+    for (creds, 0..) |c, i| if (c.provider == provider) return i;
+    return null;
+}
+
 pub fn resolveModelName(opts: Config.Agent, resolved: ?ResolvedProvider, remembered: ?Remembered) []const u8 {
     if (opts.model) |m| return m;
     if (resolved) |r| {
@@ -300,9 +357,13 @@ pub fn reconcileModel(
     base_url: ?[:0]const u8,
     explicit: bool,
 ) !ReconciledModel {
+    // A subscription (bearer) token can't list models; trust the desired model
+    // as-is rather than 401 against `/models`.
+    if (llm.auth == .bearer) return .{ .use = try allocator.dupe(u8, desired) };
+
     var arena: std.heap.ArenaAllocator = .init(allocator);
     defer arena.deinit();
-    const ids: []const []const u8 = zenai.provider.listChatModelIds(allocator, lp.io, arena.allocator(), llm.provider, llm.key, base_url, lp.environ()) catch &.{};
+    const ids: []const []const u8 = zenai.provider.listChatModelIds(lp.io, allocator, arena.allocator(), llm.provider, llm.key, .{ .base_url = base_url, .environ = lp.environ() }) catch &.{};
     if (ids.len == 0 or string.isOneOf(desired, ids)) return .{ .use = try allocator.dupe(u8, desired) };
 
     if (!explicit) {
diff --git a/src/browser/tools.zig b/src/browser/tools.zig
index 6e295d8a1..8ae9d077e 100644
--- a/src/browser/tools.zig
+++ b/src/browser/tools.zig
@@ -982,7 +982,7 @@ fn tavilySearch(
     api_key: []const u8,
     query: []const u8,
 ) ![]const u8 {
-    var client: tavily.Client = .init(arena, lp.io, api_key, .{});
+    var client: tavily.Client = .init(lp.io, arena, api_key, .{});
     defer client.deinit();
 
     var response = client.search(query, .{ .max_results = 10 }) catch |err| {