diff --git a/src-tauri/capabilities/main.json b/src-tauri/capabilities/main.json
index 2195cacf..73f0a8bc 100644
--- a/src-tauri/capabilities/main.json
+++ b/src-tauri/capabilities/main.json
@@ -53,6 +53,18 @@
       "allow": [
         {
           "url": "https://generativelanguage.googleapis.com/**"
+        },
+        {
+          "url": "https://api.github.com/**"
+        },
+        {
+          "url": "https://github.com/**"
+        },
+        {
+          "url": "https://api.githubcopilot.com/**"
+        },
+        {
+          "url": "https://copilot-proxy.githubusercontent.com/**"
         }
       ]
     },
diff --git a/src-tauri/src/commands/copilot_auth.rs b/src-tauri/src/commands/copilot_auth.rs
new file mode 100644
index 00000000..0454f538
--- /dev/null
+++ b/src-tauri/src/commands/copilot_auth.rs
@@ -0,0 +1,389 @@
+use serde::{Deserialize, Serialize};
+use tauri::command;
+
+const GITHUB_DEVICE_CODE_URL: &str = "https://github.com/login/device/code";
+const GITHUB_OAUTH_TOKEN_URL: &str = "https://github.com/login/oauth/access_token";
+const GITHUB_USER_URL: &str = "https://api.github.com/user";
+const COPILOT_TOKEN_URL: &str = "https://api.github.com/copilot_internal/v2/token";
+const COPILOT_MODELS_URL: &str = "https://api.githubcopilot.com/models";
+
+const GITHUB_CLIENT_ID: &str = "Ov23liyskE1hUrlbL9M4";
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DeviceFlowResponse {
+   pub device_code: String,
+   pub user_code: String,
+   pub verification_uri: String,
+   pub expires_in: u64,
+   pub interval: u64,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct OAuthTokenResponse {
+   pub access_token: Option<String>,
+   pub token_type: Option<String>,
+   pub scope: Option<String>,
+   pub error: Option<String>,
+   pub error_description: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CopilotTokenResponse {
+   pub token: String,
+   pub expires_at: i64,
+   pub refresh_in: Option<i64>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CopilotAuthStatus {
+   pub authenticated: bool,
+   pub github_username: Option<String>,
+   pub copilot_token_expires_at: Option<i64>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CopilotModel {
+   pub id: String,
+   pub name: String,
+   pub version: Option<String>,
+   pub is_default: Option<bool>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GitHubUser {
+   login: String,
+}
+
+#[command]
+pub async fn copilot_start_device_flow() -> Result<DeviceFlowResponse, String> {
+   let client = reqwest::Client::new();
+
+   let response = client
+      .post(GITHUB_DEVICE_CODE_URL)
+      .header("Accept", "application/json")
+      .form(&[("client_id", GITHUB_CLIENT_ID), ("scope", "read:user")])
+      .send()
+      .await
+      .map_err(|e| format!("Failed to start device flow: {e}"))?;
+
+   if !response.status().is_success() {
+      let error_text = response.text().await.unwrap_or_default();
+      return Err(format!("GitHub API error: {error_text}"));
+   }
+
+   response
+      .json::<DeviceFlowResponse>()
+      .await
+      .map_err(|e| format!("Failed to parse device flow response: {e}"))
+}
+
+#[command]
+pub async fn copilot_poll_device_auth(device_code: String) -> Result<OAuthTokenResponse, String> {
+   let client = reqwest::Client::new();
+
+   let response = client
+      .post(GITHUB_OAUTH_TOKEN_URL)
+      .header("Accept", "application/json")
+      .form(&[
+         ("client_id", GITHUB_CLIENT_ID),
+         ("device_code", &device_code),
+         ("grant_type", "urn:ietf:params:oauth:grant-type:device_code"),
+      ])
+      .send()
+      .await
+      .map_err(|e| format!("Failed to poll for token: {e}"))?;
+
+   response
+      .json::<OAuthTokenResponse>()
+      .await
+      .map_err(|e| format!("Failed to parse token response: {e}"))
+}
+
+async fn fetch_github_username(github_token: &str) -> Option<String> {
+   let client = reqwest::Client::new();
+
+   let response = client
+      .get(GITHUB_USER_URL)
+      .header("Authorization", format!("token {github_token}"))
+      .header("Accept", "application/json")
+      .header("User-Agent", "Athas/1.0.0")
+      .send()
+      .await
+      .ok()?;
+
+   if !response.status().is_success() {
+      return None;
+   }
+
+   let user: GitHubUser = response.json().await.ok()?;
+   Some(user.login)
+}
+
+#[command]
+pub async fn copilot_get_copilot_token(
+   app: tauri::AppHandle,
+   github_token: String,
+) -> Result<CopilotTokenResponse, String> {
+   let client = reqwest::Client::new();
+
+   let response = client
+      .get(COPILOT_TOKEN_URL)
+      .header("Authorization", format!("token {github_token}"))
+      .header("Accept", "application/json")
+      .header("Editor-Version", "vscode/1.96.0")
+      .header("Editor-Plugin-Version", "copilot-chat/0.24.0")
+      .header("User-Agent", "GitHubCopilotChat/0.24.0")
+      .send()
+      .await
+      .map_err(|e| format!("Failed to get Copilot token: {e}"))?;
+
+   if !response.status().is_success() {
+      let status = response.status();
+      let error_text = response.text().await.unwrap_or_default();
+
+      if status.as_u16() == 401 {
+         return Err("GitHub token is invalid or expired".to_string());
+      }
+      if status.as_u16() == 403 {
+         return Err(
+            "No active Copilot subscription found. Please subscribe at github.com/features/copilot"
+               .to_string(),
+         );
+      }
+
+      return Err(format!("Copilot API error ({status}): {error_text}"));
+   }
+
+   let token_response = response
+      .json::<CopilotTokenResponse>()
+      .await
+      .map_err(|e| format!("Failed to parse Copilot token: {e}"))?;
+
+   let username = fetch_github_username(&github_token).await;
+   store_copilot_tokens(&app, &github_token, &token_response, username.as_deref()).await?;
+
+   Ok(token_response)
+}
+
+async fn store_copilot_tokens(
+   app: &tauri::AppHandle,
+   github_token: &str,
+   copilot_token: &CopilotTokenResponse,
+   username: Option<&str>,
+) -> Result<(), String> {
+   use tauri_plugin_store::StoreExt;
+
+   let store = app
+      .store("secure.json")
+      .map_err(|e| format!("Failed to access store: {e}"))?;
+
+   store.set(
+      "copilot_github_token",
+      serde_json::Value::String(github_token.to_string()),
+   );
+   store.set(
+      "copilot_access_token",
+      serde_json::Value::String(copilot_token.token.clone()),
+   );
+   store.set(
+      "copilot_token_expires_at",
+      serde_json::Value::Number(copilot_token.expires_at.into()),
+   );
+
+   if let Some(name) = username {
+      store.set(
+         "copilot_github_username",
+         serde_json::Value::String(name.to_string()),
+      );
+   }
+
+   store
+      .save()
+      .map_err(|e| format!("Failed to save tokens: {e}"))?;
+
+   Ok(())
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct StoredCopilotTokens {
+   pub github_token: String,
+   pub access_token: String,
+   pub expires_at: i64,
+   pub username: Option<String>,
+}
+
+#[command]
+pub async fn copilot_get_stored_tokens(
+   app: tauri::AppHandle,
+) -> Result<Option<StoredCopilotTokens>, String> {
+   use tauri_plugin_store::StoreExt;
+
+   let store = app
+      .store("secure.json")
+      .map_err(|e| format!("Failed to access store: {e}"))?;
+
+   let github_token = store
+      .get("copilot_github_token")
+      .and_then(|v| v.as_str().map(String::from));
+   let access_token = store
+      .get("copilot_access_token")
+      .and_then(|v| v.as_str().map(String::from));
+   let expires_at = store
+      .get("copilot_token_expires_at")
+      .and_then(|v| v.as_i64());
+   let username = store
+      .get("copilot_github_username")
+      .and_then(|v| v.as_str().map(String::from));
+
+   match (github_token, access_token, expires_at) {
+      (Some(github_token), Some(access_token), Some(expires_at)) => Ok(Some(StoredCopilotTokens {
+         github_token,
+         access_token,
+         expires_at,
+         username,
+      })),
+      _ => Ok(None),
+   }
+}
+
+#[command]
+pub async fn copilot_refresh_token(app: tauri::AppHandle) -> Result<CopilotTokenResponse, String> {
+   let tokens = copilot_get_stored_tokens(app.clone())
+      .await?
+      .ok_or("No stored tokens found")?;
+
+   copilot_get_copilot_token(app, tokens.github_token).await
+}
+
+#[command]
+pub async fn copilot_check_auth_status(app: tauri::AppHandle) -> Result<CopilotAuthStatus, String> {
+   let tokens = copilot_get_stored_tokens(app).await?;
+
+   match tokens {
+      Some(stored) => {
+         let now = chrono::Utc::now().timestamp();
+         let authenticated = stored.expires_at > now;
+
+         Ok(CopilotAuthStatus {
+            authenticated,
+            github_username: stored.username,
+            copilot_token_expires_at: Some(stored.expires_at),
+         })
+      }
+      None => Ok(CopilotAuthStatus {
+         authenticated: false,
+         github_username: None,
+         copilot_token_expires_at: None,
+      }),
+   }
+}
+
+#[command]
+pub async fn copilot_sign_out(app: tauri::AppHandle) -> Result<(), String> {
+   use tauri_plugin_store::StoreExt;
+
+   let store = app
+      .store("secure.json")
+      .map_err(|e| format!("Failed to access store: {e}"))?;
+
+   let _ = store.delete("copilot_github_token");
+   let _ = store.delete("copilot_access_token");
+   let _ = store.delete("copilot_token_expires_at");
+   let _ = store.delete("copilot_github_username");
+   let _ = store.delete("copilot_enterprise_uri");
+
+   store
+      .save()
+      .map_err(|e| format!("Failed to save store: {e}"))?;
+
+   Ok(())
+}
+
+#[command]
+pub async fn copilot_list_models(app: tauri::AppHandle) -> Result<Vec<CopilotModel>, String> {
+   let tokens = copilot_get_stored_tokens(app.clone())
+      .await?
+      .ok_or("Not authenticated with Copilot")?;
+
+   let now = chrono::Utc::now().timestamp();
+
+   let token = if tokens.expires_at <= now {
+      let refreshed = copilot_refresh_token(app).await?;
+      refreshed.token
+   } else {
+      tokens.access_token
+   };
+
+   let client = reqwest::Client::new();
+
+   let response = client
+      .get(COPILOT_MODELS_URL)
+      .header("Authorization", format!("Bearer {token}"))
+      .header("Accept", "application/json")
+      .header("Editor-Version", "vscode/1.96.0")
+      .header("Editor-Plugin-Version", "copilot-chat/0.24.0")
+      .header("Copilot-Integration-Id", "vscode-chat")
+      .header("User-Agent", "GitHubCopilotChat/0.24.0")
+      .send()
+      .await
+      .map_err(|e| format!("Failed to list models: {e}"))?;
+
+   if !response.status().is_success() {
+      let error_text = response.text().await.unwrap_or_default();
+      return Err(format!("Failed to list models: {error_text}"));
+   }
+
+   #[derive(Deserialize)]
+   struct ModelsResponse {
+      data: Option<Vec<CopilotModel>>,
+      models: Option<Vec<CopilotModel>>,
+   }
+
+   let models_response: ModelsResponse = response
+      .json()
+      .await
+      .map_err(|e| format!("Failed to parse models: {e}"))?;
+
+   Ok(models_response
+      .data
+      .or(models_response.models)
+      .unwrap_or_default())
+}
+
+#[command]
+pub async fn copilot_set_enterprise_uri(
+   app: tauri::AppHandle,
+   uri: Option<String>,
+) -> Result<(), String> {
+   use tauri_plugin_store::StoreExt;
+
+   let store = app
+      .store("secure.json")
+      .map_err(|e| format!("Failed to access store: {e}"))?;
+
+   match uri {
+      Some(u) => store.set("copilot_enterprise_uri", serde_json::Value::String(u)),
+      None => {
+         let _ = store.delete("copilot_enterprise_uri");
+      }
+   }
+
+   store
+      .save()
+      .map_err(|e| format!("Failed to save store: {e}"))?;
+
+   Ok(())
+}
+
+#[command]
+pub async fn copilot_get_enterprise_uri(app: tauri::AppHandle) -> Result<Option<String>, String> {
+   use tauri_plugin_store::StoreExt;
+
+   let store = app
+      .store("secure.json")
+      .map_err(|e| format!("Failed to access store: {e}"))?;
+
+   Ok(store
+      .get("copilot_enterprise_uri")
+      .and_then(|v| v.as_str().map(String::from)))
+}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 3a1fffbb..eeb18f77 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -2,6 +2,7 @@ pub mod ai_tokens;
 pub mod chat_history;
 pub mod claude;
 pub mod cli;
+pub mod copilot_auth;
 pub mod extensions;
 pub mod font;
 pub mod format;
@@ -21,6 +22,7 @@ pub use ai_tokens::*;
 pub use chat_history::*;
 pub use claude::*;
 pub use cli::*;
+pub use copilot_auth::*;
 pub use extensions::*;
 pub use font::*;
 pub use format::*;
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index f4aae9f6..a66a3b81 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -305,6 +305,17 @@ fn main() {
          store_ai_provider_token,
          get_ai_provider_token,
          remove_ai_provider_token,
+         // Copilot auth commands
+         copilot_start_device_flow,
+         copilot_poll_device_auth,
+         copilot_get_copilot_token,
+         copilot_get_stored_tokens,
+         copilot_refresh_token,
+         copilot_check_auth_status,
+         copilot_sign_out,
+         copilot_list_models,
+         copilot_set_enterprise_uri,
+         copilot_get_enterprise_uri,
          // Chat history commands
          init_chat_database,
          save_chat,
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 20e4b7c1..35dde706 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -33,15 +33,11 @@
       }
     ],
     "security": {
-      "csp": "default-src 'self' ipc: http://ipc.localhost; connect-src 'self' https://athas.dev https://*.athas.dev https://api.anthropic.com https://api.openai.com https://generativelanguage.googleapis.com https://*.githubusercontent.com; img-src 'self' asset: http://asset.localhost data: blob:; font-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' 'unsafe-eval'",
-      "capabilities": [
-        "main-capability"
-      ],
+      "csp": "default-src 'self' ipc: http://ipc.localhost; connect-src 'self' https://athas.dev https://*.athas.dev https://api.anthropic.com https://api.openai.com https://generativelanguage.googleapis.com https://*.githubusercontent.com https://api.github.com https://api.githubcopilot.com https://copilot-proxy.githubusercontent.com; img-src 'self' asset: http://asset.localhost data: blob:; font-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' 'unsafe-eval'",
+      "capabilities": ["main-capability"],
       "assetProtocol": {
         "enable": true,
-        "scope": [
-          "**"
-        ]
+        "scope": ["**"]
       }
     },
     "macOSPrivateApi": true
@@ -57,9 +53,7 @@
       "icons/icon.icns",
       "icons/icon.ico"
     ],
-    "resources": [
-      "../src/extensions/bundled"
-    ],
+    "resources": ["../src/extensions/bundled"],
     "macOS": {
       "frameworks": [],
       "minimumSystemVersion": "10.15",
@@ -72,9 +66,7 @@
   "plugins": {
     "deep-link": {
       "desktop": {
-        "schemes": [
-          "athas"
-        ]
+        "schemes": ["athas"]
       }
     },
     "fs": {
diff --git a/src/features/ai/components/chat/ai-chat.tsx b/src/features/ai/components/chat/ai-chat.tsx
index ac0d2c84..2d22db75 100644
--- a/src/features/ai/components/chat/ai-chat.tsx
+++ b/src/features/ai/components/chat/ai-chat.tsx
@@ -2,6 +2,7 @@ import { invoke } from "@tauri-apps/api/core";
 import { memo, useCallback, useEffect, useRef } from "react";
 import ApiKeyModal from "@/features/ai/components/api-key-modal";
 import { parseMentionsAndLoadFiles } from "@/features/ai/lib/file-mentions";
+import { useCopilotAuthStore } from "@/features/ai/store/copilot-auth-store";
 import type { AIChatProps, Message } from "@/features/ai/types/ai-chat";
 import type { ClaudeStatus } from "@/features/ai/types/claude";
 import { getAvailableProviders, setClaudeCodeAvailability } from "@/features/ai/types/providers";
@@ -30,9 +31,18 @@ const AIChat = memo(function AIChat({
   const chatState = useChatState();
   const chatActions = useChatActions();
 
+  // Subscribe to Copilot auth state to re-check API keys when it changes
+  const copilotIsAuthenticated = useCopilotAuthStore((state) => state.isAuthenticated);
+  const checkCopilotAuthStatus = useCopilotAuthStore((state) => state.checkAuthStatus);
+
   const messagesEndRef = useRef<HTMLDivElement>(null);
   const abortControllerRef = useRef<AbortController | null>(null);
 
+  // Check Copilot auth status on mount to load models if already authenticated
+  useEffect(() => {
+    checkCopilotAuthStatus();
+  }, [checkCopilotAuthStatus]);
+
   useEffect(() => {
     if (activeBuffer) {
       chatActions.autoSelectBuffer(activeBuffer.id);
@@ -42,7 +52,12 @@ const AIChat = memo(function AIChat({
   useEffect(() => {
     chatActions.checkApiKey(settings.aiProviderId);
     chatActions.checkAllProviderApiKeys();
-  }, [settings.aiProviderId, chatActions.checkApiKey, chatActions.checkAllProviderApiKeys]);
+  }, [
+    settings.aiProviderId,
+    copilotIsAuthenticated,
+    chatActions.checkApiKey,
+    chatActions.checkAllProviderApiKeys,
+  ]);
 
   useEffect(() => {
     const checkClaudeCodeStatus = async () => {
@@ -404,7 +419,9 @@ details: ${errorDetails || mainError}
 
   return (
     <div
-      className={`ui-font flex h-full flex-col bg-secondary-bg text-text text-xs ${className || ""}`}
+      className={`ui-font flex h-full flex-col bg-secondary-bg text-text text-xs ${
+        className || ""
+      }`}
     >
       <ChatHeader />
 
diff --git a/src/features/ai/components/github-copilot-settings.tsx b/src/features/ai/components/github-copilot-settings.tsx
index 6d0e8a3d..f0ab26f1 100644
--- a/src/features/ai/components/github-copilot-settings.tsx
+++ b/src/features/ai/components/github-copilot-settings.tsx
@@ -1,73 +1,292 @@
-import { AlertCircle, Zap } from "lucide-react";
+import { open } from "@tauri-apps/plugin-shell";
+import {
+  AlertCircle,
+  Check,
+  Copy,
+  ExternalLink,
+  Loader2,
+  LogOut,
+  RefreshCw,
+  Zap,
+} from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useCopilotAuthStore } from "@/features/ai/store/copilot-auth-store";
 import { useUIState } from "@/stores/ui-state-store";
 import Button from "@/ui/button";
 
 const GitHubCopilotSettings = () => {
-  // Get data from stores
   const { isGitHubCopilotSettingsVisible, setIsGitHubCopilotSettingsVisible } = useUIState();
 
+  const {
+    stage,
+    userCode,
+    verificationUri,
+    expiresAt,
+    pollInterval,
+    isAuthenticated,
+    availableModels,
+    error,
+    startSignIn,
+    pollForAuth,
+    cancelSignIn,
+    signOut,
+    checkAuthStatus,
+  } = useCopilotAuthStore();
+
+  const [copied, setCopied] = useState(false);
+  const [timeRemaining, setTimeRemaining] = useState<number | null>(null);
+  const pollIntervalRef = useRef<NodeJS.Timeout | null>(null);
+
   const isVisible = isGitHubCopilotSettingsVisible;
   const onClose = () => setIsGitHubCopilotSettingsVisible(false);
 
+  useEffect(() => {
+    if (isVisible) {
+      checkAuthStatus();
+    }
+  }, [isVisible, checkAuthStatus]);
+
+  useEffect(() => {
+    if (stage === "polling" && expiresAt) {
+      pollIntervalRef.current = setInterval(async () => {
+        const success = await pollForAuth();
+        if (success) {
+          if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+          }
+        }
+      }, pollInterval * 1000);
+
+      return () => {
+        if (pollIntervalRef.current) {
+          clearInterval(pollIntervalRef.current);
+        }
+      };
+    }
+  }, [stage, pollInterval, pollForAuth, expiresAt]);
+
+  useEffect(() => {
+    if (expiresAt && (stage === "awaiting_code" || stage === "polling")) {
+      const timer = setInterval(() => {
+        const remaining = Math.max(0, Math.floor((expiresAt - Date.now()) / 1000));
+        setTimeRemaining(remaining);
+
+        if (remaining === 0) {
+          clearInterval(timer);
+          cancelSignIn();
+        }
+      }, 1000);
+
+      return () => clearInterval(timer);
+    }
+    setTimeRemaining(null);
+  }, [expiresAt, stage, cancelSignIn]);
+
+  const handleCopyCode = useCallback(async () => {
+    if (userCode) {
+      await navigator.clipboard.writeText(userCode);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2000);
+    }
+  }, [userCode]);
+
+  const handleOpenGitHub = useCallback(() => {
+    if (verificationUri) {
+      open(verificationUri);
+    }
+  }, [verificationUri]);
+
+  const handleSignIn = useCallback(async () => {
+    await startSignIn();
+  }, [startSignIn]);
+
+  const handleSignOut = useCallback(async () => {
+    await signOut();
+  }, [signOut]);
+
+  const handleCancel = useCallback(() => {
+    cancelSignIn();
+    if (pollIntervalRef.current) {
+      clearInterval(pollIntervalRef.current);
+    }
+  }, [cancelSignIn]);
+
   if (!isVisible) {
     return null;
   }
 
-  return (
-    <div className="pointer-events-none fixed inset-0 z-50 flex items-center justify-center">
-      <div
-        className="pointer-events-auto mx-4 w-full max-w-md rounded-lg border border-border bg-primary-bg shadow-2xl"
-        style={{ boxShadow: "0 25px 50px -12px rgba(0, 0, 0, 0.5)" }}
-      >
-        {/* Header */}
-        <div className="flex items-center gap-3 border-border border-b px-4 py-3">
-          <Zap size={16} className="text-text" />
-          <h2 className="ui-font font-medium text-sm text-text">GitHub Copilot Integration</h2>
-          <div className="flex-1" />
-          <button onClick={onClose} className="text-text-lighter transition-colors hover:text-text">
-            ×
-          </button>
+  const formatTime = (seconds: number) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  };
+
+  const renderContent = () => {
+    if (isAuthenticated && stage === "authenticated") {
+      return (
+        <div className="space-y-4">
+          <div className="flex items-center gap-2 rounded border border-green-500/30 bg-green-500/10 p-3">
+            <Check size={16} className="text-green-500" />
+            <span className="font-medium text-green-500 text-sm">Connected to GitHub Copilot</span>
+          </div>
+
+          {availableModels.length > 0 && (
+            <div className="space-y-2 rounded border border-border bg-secondary-bg p-3">
+              <div className="font-medium text-text text-xs">Available Models</div>
+              <div className="flex flex-wrap gap-1">
+                {availableModels.slice(0, 8).map((model) => (
+                  <span
+                    key={model.id}
+                    className="rounded bg-hover px-2 py-0.5 text-text-lighter text-xs"
+                  >
+                    {model.name || model.id}
+                  </span>
+                ))}
+                {availableModels.length > 8 && (
+                  <span className="rounded bg-hover px-2 py-0.5 text-text-lighter text-xs">
+                    +{availableModels.length - 8} more
+                  </span>
+                )}
+              </div>
+            </div>
+          )}
+
+          <div className="flex gap-2 pt-2">
+            <Button onClick={handleSignOut} variant="outline" className="flex-1 gap-2">
+              <LogOut size={14} />
+              Sign Out
+            </Button>
+            <Button onClick={onClose} variant="default" className="flex-1">
+              Done
+            </Button>
+          </div>
         </div>
+      );
+    }
 
-        {/* Content */}
-        <div className="space-y-4 p-4">
+    if (stage === "awaiting_code" || stage === "polling" || stage === "exchanging_token") {
+      return (
+        <div className="space-y-4">
           <div className="text-text-lighter text-xs leading-relaxed">
-            GitHub Copilot integration uses official GitHub authentication through the code Editor.
+            Enter this code on GitHub to authorize Athas:
           </div>
 
-          {/* Coming Soon Notice */}
-          <div className="space-y-3 rounded border border-border bg-secondary-bg p-4">
-            <div className="flex items-center gap-2 font-medium text-sm text-text">
-              <AlertCircle size={14} className="text-blue-400" />
-              <span>Coming Soon</span>
-            </div>
-            <div className="text-text-lighter text-xs leading-relaxed">
-              GitHub Copilot integration is currently in development. GitHub Copilot does not
-              support API key authentication. It requires OAuth-based authentication through
-              official GitHub channels.
+          <div className="flex flex-col items-center gap-3 rounded border border-border bg-secondary-bg p-4">
+            <div className="font-bold font-mono text-2xl text-text tracking-widest">
+              {userCode || "--------"}
             </div>
+
+            <Button
+              onClick={handleCopyCode}
+              variant="outline"
+              size="sm"
+              className="gap-2"
+              disabled={!userCode}
+            >
+              {copied ? <Check size={14} /> : <Copy size={14} />}
+              {copied ? "Copied!" : "Copy Code"}
+            </Button>
           </div>
 
-          {/* Information */}
-          <div className="space-y-2 rounded border border-border bg-secondary-bg p-3">
-            <div className="mb-2 font-medium text-text text-xs">
-              How GitHub Copilot authentication works:
+          <Button onClick={handleOpenGitHub} variant="default" className="w-full gap-2">
+            <ExternalLink size={14} />
+            Open GitHub
+          </Button>
+
+          <div className="flex items-center justify-center gap-2 text-text-lighter text-xs">
+            {stage === "exchanging_token" ? (
+              <>
+                <Loader2 size={12} className="animate-spin" />
+                <span>Completing authorization...</span>
+              </>
+            ) : (
+              <>
+                <Loader2 size={12} className="animate-spin" />
+                <span>Waiting for authorization...</span>
+                {timeRemaining !== null && (
+                  <span className="text-text-lighter">({formatTime(timeRemaining)})</span>
+                )}
+              </>
+            )}
+          </div>
+
+          <Button onClick={handleCancel} variant="ghost" className="w-full" size="sm">
+            Cancel
+          </Button>
+        </div>
+      );
+    }
+
+    if (stage === "error") {
+      return (
+        <div className="space-y-4">
+          <div className="flex items-start gap-2 rounded border border-red-500/30 bg-red-500/10 p-3">
+            <AlertCircle size={16} className="mt-0.5 shrink-0 text-red-500" />
+            <div className="space-y-1">
+              <div className="font-medium text-red-500 text-sm">Authentication Failed</div>
+              <div className="text-red-400 text-xs">{error}</div>
             </div>
-            <ul className="list-inside list-disc space-y-1 text-text-lighter text-xs">
-              <li>Requires a GitHub Copilot subscription</li>
-              <li>Uses OAuth authentication with GitHub</li>
-              <li>Integrates through official IDE extensions</li>
-              <li>Does not support standalone API keys</li>
-            </ul>
           </div>
 
-          {/* Actions */}
           <div className="flex gap-2 pt-2">
-            <Button onClick={onClose} variant="default" className="flex-1">
-              Got it
+            <Button onClick={handleSignIn} variant="default" className="flex-1 gap-2">
+              <RefreshCw size={14} />
+              Try Again
+            </Button>
+            <Button onClick={onClose} variant="outline" className="flex-1">
+              Close
             </Button>
           </div>
         </div>
+      );
+    }
+
+    return (
+      <div className="space-y-4">
+        <div className="text-text-lighter text-xs leading-relaxed">
+          Sign in with your GitHub account to use Copilot models. Requires an active GitHub Copilot
+          subscription.
+        </div>
+
+        <div className="space-y-2 rounded border border-border bg-secondary-bg p-3">
+          <div className="mb-2 font-medium text-text text-xs">What you get:</div>
+          <ul className="list-inside list-disc space-y-1 text-text-lighter text-xs">
+            <li>Access to GPT-5, Claude, Gemini and more</li>
+            <li>Usage based on your Copilot plan</li>
+            <li>Secure OAuth authentication</li>
+          </ul>
+        </div>
+
+        <div className="flex gap-2 pt-2">
+          <Button onClick={handleSignIn} variant="default" className="flex-1 gap-2">
+            <Zap size={14} />
+            Sign in with GitHub
+          </Button>
+        </div>
+      </div>
+    );
+  };
+
+  return (
+    <div className="pointer-events-none fixed inset-0 z-[10000] flex items-center justify-center">
+      <div
+        className="pointer-events-auto mx-4 w-full max-w-md rounded-lg border border-border bg-primary-bg shadow-2xl"
+        style={{ boxShadow: "0 25px 50px -12px rgba(0, 0, 0, 0.5)" }}
+      >
+        <div className="flex items-center gap-3 border-border border-b px-4 py-3">
+          <Zap size={16} className="text-text" />
+          <h2 className="ui-font font-medium text-sm text-text">GitHub Copilot</h2>
+          <div className="flex-1" />
+          <button
+            onClick={onClose}
+            className="text-text-lighter transition-colors hover:text-text"
+            aria-label="Close"
+          >
+            ×
+          </button>
+        </div>
+
+        <div className="p-4">{renderContent()}</div>
       </div>
     </div>
   );
diff --git a/src/features/ai/components/selectors/model-selector-dropdown.tsx b/src/features/ai/components/selectors/model-selector-dropdown.tsx
index 85b4acf7..4acc0a30 100644
--- a/src/features/ai/components/selectors/model-selector-dropdown.tsx
+++ b/src/features/ai/components/selectors/model-selector-dropdown.tsx
@@ -1,6 +1,8 @@
-import { Check, ChevronDown, Key, Search } from "lucide-react";
+import { Check, ChevronDown, Key, LogIn, Search } from "lucide-react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCopilotAuthStore } from "@/features/ai/store/copilot-auth-store";
 import { getAvailableProviders } from "@/features/ai/types/providers";
+import { useUIState } from "@/stores/ui-state-store";
 import { cn } from "@/utils/cn";
 
 interface ModelSelectorDropdownProps {
@@ -28,6 +30,18 @@ export function ModelSelectorDropdown({
   const inputRef = useRef<HTMLInputElement>(null);
 
   const providers = getAvailableProviders();
+  const copilotAuth = useCopilotAuthStore();
+  const { setIsGitHubCopilotSettingsVisible } = useUIState();
+
+  const isProviderReady = useCallback(
+    (providerId: string, requiresApiKey: boolean, requiresAuth?: boolean) => {
+      if (requiresAuth && providerId === "copilot") {
+        return copilotAuth.isAuthenticated;
+      }
+      return !requiresApiKey || hasApiKey(providerId);
+    },
+    [hasApiKey, copilotAuth.isAuthenticated],
+  );
 
   const filteredItems = useMemo(() => {
     const items: Array<{
@@ -37,14 +51,19 @@ export function ModelSelectorDropdown({
       modelId?: string;
       modelName?: string;
       requiresApiKey?: boolean;
-      hasKey?: boolean;
+      requiresAuth?: boolean;
+      isReady?: boolean;
     }> = [];
 
     const searchLower = search.toLowerCase();
 
     for (const provider of providers) {
       const providerMatches = provider.name.toLowerCase().includes(searchLower);
-      const providerHasKey = !provider.requiresApiKey || hasApiKey(provider.id);
+      const providerIsReady = isProviderReady(
+        provider.id,
+        provider.requiresApiKey,
+        provider.requiresAuth,
+      );
       const matchingModels = provider.models.filter(
         (model) =>
           providerMatches ||
@@ -58,11 +77,11 @@ export function ModelSelectorDropdown({
           providerId: provider.id,
           providerName: provider.name,
           requiresApiKey: provider.requiresApiKey,
-          hasKey: providerHasKey,
+          requiresAuth: provider.requiresAuth,
+          isReady: providerIsReady,
         });
 
-        // Only show models if provider has API key or doesn't require one
-        if (providerHasKey) {
+        if (providerIsReady) {
           const modelsToShow = search ? matchingModels : provider.models;
           for (const model of modelsToShow) {
             items.push({
@@ -78,7 +97,7 @@ export function ModelSelectorDropdown({
     }
 
     return items;
-  }, [providers, search, hasApiKey]);
+  }, [providers, search, isProviderReady]);
 
   const selectableItems = useMemo(
     () => filteredItems.filter((item) => item.type === "model"),
@@ -132,12 +151,6 @@ export function ModelSelectorDropdown({
     [isOpen, selectableItems, selectedIndex, onSelect],
   );
 
-  const handleApiKeyClick = (e: React.MouseEvent) => {
-    e.stopPropagation();
-    onOpenSettings();
-    setIsOpen(false);
-  };
-
   let selectableIndex = -1;
 
   return (
@@ -161,8 +174,8 @@ export function ModelSelectorDropdown({
             ref={dropdownRef}
             onKeyDown={handleKeyDown}
             className={cn(
-              "absolute right-0 bottom-full z-[9999] mb-1",
-              "max-h-[400px] w-[280px] overflow-hidden",
+              "absolute bottom-full left-0 z-[9999] mb-1",
+              "max-h-[400px] min-w-[280px] overflow-hidden",
               "rounded-lg border border-border bg-primary-bg shadow-xl",
             )}
           >
@@ -187,6 +200,16 @@ export function ModelSelectorDropdown({
               ) : (
                 filteredItems.map((item) => {
                   if (item.type === "provider") {
+                    const handleProviderAction = (e: React.MouseEvent) => {
+                      e.stopPropagation();
+                      if (item.requiresAuth && item.providerId === "copilot") {
+                        setIsGitHubCopilotSettingsVisible(true);
+                      } else {
+                        onOpenSettings();
+                      }
+                      setIsOpen(false);
+                    };
+
                     return (
                       <div
                         key={`provider-${item.providerId}`}
@@ -195,9 +218,18 @@ export function ModelSelectorDropdown({
                         <span className="font-medium text-text-lighter text-xs">
                           {item.providerName}
                         </span>
-                        {item.requiresApiKey && !item.hasKey && (
+                        {!item.isReady && item.requiresAuth && (
+                          <button
+                            onClick={handleProviderAction}
+                            className="flex items-center gap-1 rounded bg-blue-500/20 px-1.5 py-0.5 text-[10px] text-blue-400 transition-colors hover:bg-blue-500/30"
+                          >
+                            <LogIn size={8} />
+                            Sign In
+                          </button>
+                        )}
+                        {!item.isReady && item.requiresApiKey && !item.requiresAuth && (
                           <button
-                            onClick={handleApiKeyClick}
+                            onClick={handleProviderAction}
                             className="flex items-center gap-1 rounded bg-red-500/20 px-1.5 py-0.5 text-[10px] text-red-400 transition-colors hover:bg-red-500/30"
                           >
                             <Key size={8} />
diff --git a/src/features/ai/store/copilot-auth-store.ts b/src/features/ai/store/copilot-auth-store.ts
new file mode 100644
index 00000000..bcb13509
--- /dev/null
+++ b/src/features/ai/store/copilot-auth-store.ts
@@ -0,0 +1,289 @@
+import { invoke } from "@tauri-apps/api/core";
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import type {
+  CopilotAuthActions,
+  CopilotAuthState,
+  CopilotAuthStatus,
+  CopilotModel,
+  CopilotTokenResponse,
+  DeviceFlowResponse,
+  OAuthTokenResponse,
+  StoredCopilotTokens,
+} from "@/features/ai/types/copilot";
+import { clearCopilotModels, setCopilotModels } from "@/features/ai/types/providers";
+
+const initialState: CopilotAuthState = {
+  stage: "idle",
+  deviceCode: null,
+  userCode: null,
+  verificationUri: null,
+  expiresAt: null,
+  pollInterval: 5,
+  isAuthenticated: false,
+  githubUsername: null,
+  copilotTokenExpiresAt: null,
+  availableModels: [],
+  enterpriseUri: null,
+  error: null,
+};
+
+export const useCopilotAuthStore = create<CopilotAuthState & CopilotAuthActions>()(
+  immer(
+    persist(
+      (set, get) => ({
+        ...initialState,
+
+        startSignIn: async () => {
+          set((state) => {
+            state.stage = "awaiting_code";
+            state.error = null;
+          });
+
+          try {
+            const response = await invoke<DeviceFlowResponse>("copilot_start_device_flow");
+
+            set((state) => {
+              state.deviceCode = response.device_code;
+              state.userCode = response.user_code;
+              state.verificationUri = response.verification_uri;
+              state.expiresAt = Date.now() + response.expires_in * 1000;
+              state.pollInterval = response.interval;
+              state.stage = "polling";
+            });
+          } catch (error) {
+            set((state) => {
+              state.stage = "error";
+              state.error = error instanceof Error ? error.message : String(error);
+            });
+          }
+        },
+
+        pollForAuth: async () => {
+          const { deviceCode, stage } = get();
+
+          if (stage !== "polling" || !deviceCode) {
+            return false;
+          }
+
+          try {
+            const response = await invoke<OAuthTokenResponse>("copilot_poll_device_auth", {
+              deviceCode,
+            });
+
+            if (response.error) {
+              if (response.error === "authorization_pending") {
+                return false;
+              }
+              if (response.error === "slow_down") {
+                set((state) => {
+                  state.pollInterval = state.pollInterval + 5;
+                });
+                return false;
+              }
+              if (response.error === "expired_token") {
+                set((state) => {
+                  state.stage = "error";
+                  state.error = "Authorization expired. Please try again.";
+                });
+                return false;
+              }
+              if (response.error === "access_denied") {
+                set((state) => {
+                  state.stage = "error";
+                  state.error = "Authorization denied by user.";
+                });
+                return false;
+              }
+
+              set((state) => {
+                state.stage = "error";
+                state.error = response.error_description || response.error || "Unknown error";
+              });
+              return false;
+            }
+
+            if (response.access_token) {
+              set((state) => {
+                state.stage = "exchanging_token";
+              });
+
+              const copilotToken = await invoke<CopilotTokenResponse>("copilot_get_copilot_token", {
+                githubToken: response.access_token,
+              });
+
+              set((state) => {
+                state.stage = "authenticated";
+                state.isAuthenticated = true;
+                state.copilotTokenExpiresAt = copilotToken.expires_at * 1000;
+                state.deviceCode = null;
+                state.userCode = null;
+                state.verificationUri = null;
+                state.expiresAt = null;
+              });
+
+              get().fetchAvailableModels();
+              return true;
+            }
+
+            return false;
+          } catch (error) {
+            set((state) => {
+              state.stage = "error";
+              state.error = error instanceof Error ? error.message : String(error);
+            });
+            return false;
+          }
+        },
+
+        cancelSignIn: () => {
+          set((state) => {
+            state.stage = "idle";
+            state.deviceCode = null;
+            state.userCode = null;
+            state.verificationUri = null;
+            state.expiresAt = null;
+            state.error = null;
+          });
+        },
+
+        signOut: async () => {
+          try {
+            await invoke("copilot_sign_out");
+          } catch (error) {
+            console.error("Failed to sign out:", error);
+          }
+
+          // Clear dynamic models when signing out
+          clearCopilotModels();
+
+          set((state) => {
+            Object.assign(state, initialState);
+          });
+        },
+
+        refreshTokenIfNeeded: async () => {
+          const { isAuthenticated, copilotTokenExpiresAt } = get();
+
+          if (!isAuthenticated) {
+            return false;
+          }
+
+          const now = Date.now();
+          const bufferMs = 5 * 60 * 1000;
+
+          if (copilotTokenExpiresAt && copilotTokenExpiresAt - now > bufferMs) {
+            return true;
+          }
+
+          try {
+            const response = await invoke<CopilotTokenResponse>("copilot_refresh_token");
+
+            set((state) => {
+              state.copilotTokenExpiresAt = response.expires_at * 1000;
+            });
+
+            return true;
+          } catch (error) {
+            console.error("Failed to refresh token:", error);
+            set((state) => {
+              state.isAuthenticated = false;
+              state.stage = "idle";
+              state.error = "Session expired. Please sign in again.";
+            });
+            return false;
+          }
+        },
+
+        fetchAvailableModels: async () => {
+          try {
+            const models = await invoke<CopilotModel[]>("copilot_list_models");
+
+            // Update provider models list with what user has access to
+            setCopilotModels(models);
+
+            set((state) => {
+              state.availableModels = models;
+            });
+          } catch (error) {
+            console.error("Failed to fetch models:", error);
+          }
+        },
+
+        checkAuthStatus: async () => {
+          try {
+            const status = await invoke<CopilotAuthStatus>("copilot_check_auth_status");
+
+            set((state) => {
+              state.isAuthenticated = status.authenticated;
+              state.githubUsername = status.github_username ?? null;
+              state.copilotTokenExpiresAt = status.copilot_token_expires_at
+                ? status.copilot_token_expires_at * 1000
+                : null;
+
+              if (status.authenticated) {
+                state.stage = "authenticated";
+              } else if (state.stage === "authenticated") {
+                state.stage = "idle";
+              }
+            });
+
+            if (status.authenticated) {
+              get().fetchAvailableModels();
+            }
+          } catch (error) {
+            console.error("Failed to check auth status:", error);
+          }
+        },
+
+        setEnterpriseUri: async (uri) => {
+          try {
+            await invoke("copilot_set_enterprise_uri", { uri });
+
+            set((state) => {
+              state.enterpriseUri = uri;
+            });
+          } catch (error) {
+            console.error("Failed to set enterprise URI:", error);
+          }
+        },
+
+        getAccessToken: async () => {
+          const refreshed = await get().refreshTokenIfNeeded();
+
+          if (!refreshed) {
+            return null;
+          }
+
+          try {
+            const tokens = await invoke<StoredCopilotTokens | null>("copilot_get_stored_tokens");
+
+            if (tokens) {
+              return tokens.access_token;
+            }
+
+            return null;
+          } catch {
+            return null;
+          }
+        },
+
+        reset: () => {
+          set((state) => {
+            Object.assign(state, initialState);
+          });
+        },
+      }),
+      {
+        name: "copilot-auth-storage",
+        partialize: (state) => ({
+          isAuthenticated: state.isAuthenticated,
+          githubUsername: state.githubUsername,
+          copilotTokenExpiresAt: state.copilotTokenExpiresAt,
+          enterpriseUri: state.enterpriseUri,
+        }),
+      },
+    ),
+  ),
+);
diff --git a/src/features/ai/store/store.ts b/src/features/ai/store/store.ts
index b8911df0..3c8810aa 100644
--- a/src/features/ai/store/store.ts
+++ b/src/features/ai/store/store.ts
@@ -18,6 +18,7 @@ import {
   loadChatFromDb,
   saveChatToDb,
 } from "@/utils/chat-history-db";
+import { useCopilotAuthStore } from "./copilot-auth-store";
 import type { AIChatActions, AIChatState } from "./types";
 
 export const useAIChatStore = create<AIChatState & AIChatActions>()(
@@ -321,6 +322,15 @@ export const useAIChatStore = create<AIChatState & AIChatActions>()(
               return;
             }
 
+            // Copilot uses OAuth, not API keys
+            if (providerId === "copilot") {
+              const copilotAuth = useCopilotAuthStore.getState();
+              set((state) => {
+                state.hasApiKey = copilotAuth.isAuthenticated;
+              });
+              return;
+            }
+
             const token = await getProviderApiToken(providerId);
             set((state) => {
               state.hasApiKey = !!token;
@@ -335,6 +345,7 @@ export const useAIChatStore = create<AIChatState & AIChatActions>()(
 
         checkAllProviderApiKeys: async () => {
           const newApiKeyMap = new Map<string, boolean>();
+          const copilotAuth = useCopilotAuthStore.getState();
 
           for (const provider of AI_PROVIDERS) {
             try {
@@ -344,6 +355,12 @@ export const useAIChatStore = create<AIChatState & AIChatActions>()(
                 continue;
               }
 
+              // Copilot uses OAuth, not API keys
+              if (provider.id === "copilot") {
+                newApiKeyMap.set(provider.id, copilotAuth.isAuthenticated);
+                continue;
+              }
+
               const token = await getProviderApiToken(provider.id);
               newApiKeyMap.set(provider.id, !!token);
             } catch {
@@ -440,6 +457,10 @@ export const useAIChatStore = create<AIChatState & AIChatActions>()(
         },
 
         hasProviderApiKey: (providerId) => {
+          // Copilot uses OAuth, check auth store directly
+          if (providerId === "copilot") {
+            return useCopilotAuthStore.getState().isAuthenticated;
+          }
           return get().providerApiKeys.get(providerId) || false;
         },
 
diff --git a/src/features/ai/types/copilot.ts b/src/features/ai/types/copilot.ts
new file mode 100644
index 00000000..ab85424e
--- /dev/null
+++ b/src/features/ai/types/copilot.ts
@@ -0,0 +1,77 @@
+export interface DeviceFlowResponse {
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  expires_in: number;
+  interval: number;
+}
+
+export interface OAuthTokenResponse {
+  access_token?: string;
+  token_type?: string;
+  scope?: string;
+  error?: string;
+  error_description?: string;
+}
+
+export interface CopilotTokenResponse {
+  token: string;
+  expires_at: number;
+  refresh_in?: number;
+}
+
+export interface CopilotAuthStatus {
+  authenticated: boolean;
+  github_username?: string;
+  copilot_token_expires_at?: number;
+}
+
+export interface StoredCopilotTokens {
+  github_token: string;
+  access_token: string;
+  expires_at: number;
+  username?: string;
+}
+
+export interface CopilotModel {
+  id: string;
+  name: string;
+  version?: string;
+  is_default?: boolean;
+}
+
+export type CopilotAuthStage =
+  | "idle"
+  | "awaiting_code"
+  | "polling"
+  | "exchanging_token"
+  | "authenticated"
+  | "error";
+
+export interface CopilotAuthState {
+  stage: CopilotAuthStage;
+  deviceCode: string | null;
+  userCode: string | null;
+  verificationUri: string | null;
+  expiresAt: number | null;
+  pollInterval: number;
+  isAuthenticated: boolean;
+  githubUsername: string | null;
+  copilotTokenExpiresAt: number | null;
+  availableModels: CopilotModel[];
+  enterpriseUri: string | null;
+  error: string | null;
+}
+
+export interface CopilotAuthActions {
+  startSignIn: () => Promise<void>;
+  pollForAuth: () => Promise<boolean>;
+  cancelSignIn: () => void;
+  signOut: () => Promise<void>;
+  refreshTokenIfNeeded: () => Promise<boolean>;
+  fetchAvailableModels: () => Promise<void>;
+  checkAuthStatus: () => Promise<void>;
+  setEnterpriseUri: (uri: string | null) => Promise<void>;
+  getAccessToken: () => Promise<string | null>;
+  reset: () => void;
+}
diff --git a/src/features/ai/types/providers.ts b/src/features/ai/types/providers.ts
index 39bdcfc3..c1863150 100644
--- a/src/features/ai/types/providers.ts
+++ b/src/features/ai/types/providers.ts
@@ -13,6 +13,47 @@ interface Model {
   maxTokens: number;
 }
 
+// Metadata for Copilot models (maxTokens lookup)
+const COPILOT_MODEL_METADATA: Record<string, { maxTokens: number }> = {
+  "gpt-4.1": { maxTokens: 128000 },
+  "gpt-5": { maxTokens: 128000 },
+  "gpt-5-mini": { maxTokens: 128000 },
+  "gpt-5-codex": { maxTokens: 128000 },
+  "gpt-5.1": { maxTokens: 128000 },
+  "gpt-5.1-codex": { maxTokens: 128000 },
+  "gpt-5.1-codex-mini": { maxTokens: 128000 },
+  "gpt-5.1-codex-max": { maxTokens: 128000 },
+  "gpt-5.2": { maxTokens: 128000 },
+  "claude-haiku-4.5": { maxTokens: 128000 },
+  "claude-opus-4.1": { maxTokens: 128000 },
+  "claude-opus-4.5": { maxTokens: 128000 },
+  "claude-sonnet-4": { maxTokens: 128000 },
+  "claude-sonnet-4.5": { maxTokens: 128000 },
+  "gemini-2.5-pro": { maxTokens: 108801 },
+  "gemini-3-pro": { maxTokens: 108801 },
+  "grok-code-fast-1": { maxTokens: 128000 },
+  "raptor-mini": { maxTokens: 128000 },
+};
+
+// Dynamic Copilot models (populated from API based on user's plan)
+let dynamicCopilotModels: Model[] | null = null;
+
+export const setCopilotModels = (models: Array<{ id: string; name: string }>) => {
+  // Filter to only include models Copilot supports right now
+  // This removes old/irrelevant models
+  dynamicCopilotModels = models
+    .filter((m) => m.id in COPILOT_MODEL_METADATA)
+    .map((m) => ({
+      id: m.id,
+      name: m.name,
+      maxTokens: COPILOT_MODEL_METADATA[m.id]?.maxTokens ?? 128000,
+    }));
+};
+
+export const clearCopilotModels = () => {
+  dynamicCopilotModels = null;
+};
+
 export const AI_PROVIDERS: ModelProvider[] = [
   {
     id: "claude-code",
@@ -345,68 +386,7 @@ export const AI_PROVIDERS: ModelProvider[] = [
     apiUrl: "https://api.githubcopilot.com/chat/completions",
     requiresApiKey: false,
     requiresAuth: true,
-    models: [
-      {
-        id: "gpt-4.1",
-        name: "GPT-4.1 (Copilot)",
-        maxTokens: 1048576,
-      },
-      {
-        id: "claude-opus-4",
-        name: "Claude Opus 4 (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "claude-sonnet-4",
-        name: "Claude Sonnet 4 (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "o3",
-        name: "o3 (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "o4-mini",
-        name: "o4 Mini (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "o3-mini",
-        name: "o3 Mini (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "gpt-4o",
-        name: "GPT-4o (Copilot)",
-        maxTokens: 128000,
-      },
-      {
-        id: "claude-3.7-sonnet",
-        name: "Claude 3.7 Sonnet (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "claude-3.7-sonnet-thinking",
-        name: "Claude 3.7 Sonnet Thinking (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "claude-3.5-sonnet",
-        name: "Claude 3.5 Sonnet (Copilot)",
-        maxTokens: 200000,
-      },
-      {
-        id: "gemini-2.5-pro",
-        name: "Gemini 2.5 Pro (Copilot)",
-        maxTokens: 1048576,
-      },
-      {
-        id: "gemini-2.0-flash",
-        name: "Gemini 2.0 Flash (Copilot)",
-        maxTokens: 1000000,
-      },
-    ],
+    models: [], // Populated dynamically from API based on user's plan
   },
 ];
 
@@ -418,15 +398,22 @@ export const setClaudeCodeAvailability = (available: boolean) => {
 };
 
 export const getAvailableProviders = (): ModelProvider[] => {
-  if (claudeCodeAvailable) {
-    return AI_PROVIDERS;
+  let providers = claudeCodeAvailable
+    ? AI_PROVIDERS
+    : AI_PROVIDERS.filter((provider) => provider.id !== "claude-code");
+
+  // Inject dynamic Copilot models if available
+  if (dynamicCopilotModels && dynamicCopilotModels.length > 0) {
+    providers = providers.map((provider) =>
+      provider.id === "copilot" ? { ...provider, models: dynamicCopilotModels! } : provider,
+    );
   }
-  // Filter out Claude Code if not available
-  return AI_PROVIDERS.filter((provider) => provider.id !== "claude-code");
+
+  return providers;
 };
 
 export const getProviderById = (id: string): ModelProvider | undefined => {
-  return AI_PROVIDERS.find((provider) => provider.id === id);
+  return getAvailableProviders().find((provider) => provider.id === id);
 };
 
 export const getModelById = (providerId: string, modelId: string): Model | undefined => {
diff --git a/src/features/settings/components/tabs/ai-settings.tsx b/src/features/settings/components/tabs/ai-settings.tsx
index a43ed981..a8065da3 100644
--- a/src/features/settings/components/tabs/ai-settings.tsx
+++ b/src/features/settings/components/tabs/ai-settings.tsx
@@ -1,10 +1,23 @@
 import { invoke } from "@tauri-apps/api/core";
-import { AlertCircle, Check, CheckCircle, Eye, EyeOff, Key, Trash2, X } from "lucide-react";
+import {
+  AlertCircle,
+  Check,
+  CheckCircle,
+  Eye,
+  EyeOff,
+  Key,
+  LogIn,
+  LogOut,
+  Trash2,
+  X,
+} from "lucide-react";
 import { useEffect, useState } from "react";
+import { useCopilotAuthStore } from "@/features/ai/store/copilot-auth-store";
 import { useAIChatStore } from "@/features/ai/store/store";
 import type { ClaudeStatus } from "@/features/ai/types/claude";
 import { getAvailableProviders, setClaudeCodeAvailability } from "@/features/ai/types/providers";
 import { useSettingsStore } from "@/features/settings/store";
+import { useUIState } from "@/stores/ui-state-store";
 import Button from "@/ui/button";
 import Dropdown from "@/ui/dropdown";
 import Section, { SettingRow } from "@/ui/section";
@@ -294,18 +307,76 @@ export const AISettings = () => {
       {providersNeedingAuth.length > 0 && (
         <Section title="Authentication">
           {providersNeedingAuth.map((provider) => (
-            <SettingRow
+            <AuthProviderRow
               key={provider.id}
-              label={provider.name}
-              description="Requires OAuth authentication"
-            >
-              <div className="flex items-center gap-2 rounded border border-border bg-secondary-bg px-3 py-1.5">
-                <span className="text-text-lighter text-xs">Coming Soon</span>
-              </div>
-            </SettingRow>
+              providerId={provider.id}
+              providerName={provider.name}
+            />
           ))}
         </Section>
       )}
     </div>
   );
 };
+
+const AuthProviderRow = ({
+  providerId,
+  providerName,
+}: {
+  providerId: string;
+  providerName: string;
+}) => {
+  const { setIsGitHubCopilotSettingsVisible } = useUIState();
+  const copilotAuth = useCopilotAuthStore();
+
+  if (providerId === "copilot") {
+    const handleClick = () => {
+      setIsGitHubCopilotSettingsVisible(true);
+    };
+
+    if (copilotAuth.isAuthenticated) {
+      const description = copilotAuth.githubUsername
+        ? `Signed in as @${copilotAuth.githubUsername}`
+        : "Connected to GitHub";
+
+      return (
+        <SettingRow label={providerName} description={description}>
+          <div className="flex items-center gap-2">
+            <div className="flex items-center gap-1.5 text-green-500 text-xs">
+              <Check size={12} />
+              <span>Connected</span>
+            </div>
+            <Button variant="ghost" size="xs" onClick={handleClick}>
+              Manage
+            </Button>
+            <Button
+              variant="ghost"
+              size="xs"
+              onClick={() => copilotAuth.signOut()}
+              className="text-red-500 hover:bg-red-500/10"
+            >
+              <LogOut size={12} />
+            </Button>
+          </div>
+        </SettingRow>
+      );
+    }
+
+    return (
+      <SettingRow label={providerName} description="Requires OAuth authentication">
+        <Button variant="outline" size="xs" onClick={handleClick} className="gap-1.5">
+          <LogIn size={12} />
+          Sign in with GitHub
+        </Button>
+      </SettingRow>
+    );
+  }
+
+  return (
+    <SettingRow label={providerName} description="Requires OAuth authentication">
+      <div className="flex items-center gap-2 rounded border border-border bg-secondary-bg px-3 py-1.5">
+        <span className="text-text-lighter text-xs">Coming Soon</span>
+      </div>
+    </SettingRow>
+  );
+};
diff --git a/src/features/settings/components/tabs/extensions-settings.tsx b/src/features/settings/components/tabs/extensions-settings.tsx
index f622f191..d9238c72 100644
--- a/src/features/settings/components/tabs/extensions-settings.tsx
+++ b/src/features/settings/components/tabs/extensions-settings.tsx
@@ -50,7 +50,7 @@ const ExtensionRow = ({
     <div className="flex items-center justify-between gap-4 border-border/50 border-b px-1 py-3 last:border-b-0">
       <div className="min-w-0 flex-1">
         <div className="mb-1 flex items-center gap-2">
-          <span className="font-medium text-text text-sm">{extension.name}</span>
+          <span className="font-medium text-sm text-text">{extension.name}</span>
           <span className="rounded bg-secondary-bg px-1.5 py-0.5 text-[10px] text-text-lighter">
             {getCategoryLabel(extension.category)}
           </span>
@@ -58,7 +58,7 @@ const ExtensionRow = ({
             <span className="text-[10px] text-text-lighter">v{extension.version}</span>
           )}
         </div>
-        <div className="flex items-center gap-2 text-xs text-text-lighter">
+        <div className="flex items-center gap-2 text-text-lighter text-xs">
           {extension.publisher && <span>by {extension.publisher}</span>}
           {extension.publisher && extension.extensions && extension.extensions.length > 0 && (
             <span>·</span>
@@ -75,7 +75,7 @@ const ExtensionRow = ({
         </div>
       </div>
       {extension.isBundled ? (
-        <span className="flex-shrink-0 text-xs text-accent">Built-in</span>
+        <span className="flex-shrink-0 text-accent text-xs">Built-in</span>
       ) : isInstalling ? (
         <div className="flex flex-shrink-0 items-center gap-1.5 text-accent">
           <RefreshCw size={12} className="animate-spin" />
@@ -84,7 +84,7 @@ const ExtensionRow = ({
       ) : extension.isInstalled ? (
         <button
           onClick={onToggle}
-          className="flex-shrink-0 text-xs text-text-lighter transition-colors hover:text-red-500"
+          className="flex-shrink-0 text-text-lighter text-xs transition-colors hover:text-red-500"
           title="Uninstall"
         >
           Uninstall
@@ -92,7 +92,7 @@ const ExtensionRow = ({
       ) : (
         <button
           onClick={onToggle}
-          className="flex-shrink-0 text-xs text-text-lighter transition-colors hover:text-accent"
+          className="flex-shrink-0 text-text-lighter text-xs transition-colors hover:text-accent"
           title="Install"
         >
           Install
diff --git a/src/utils/ai-chat.ts b/src/utils/ai-chat.ts
index 4bfaabf8..21a4a842 100644
--- a/src/utils/ai-chat.ts
+++ b/src/utils/ai-chat.ts
@@ -1,10 +1,12 @@
 import { fetch as tauriFetch } from "@tauri-apps/plugin-http";
+import { useCopilotAuthStore } from "@/features/ai/store/copilot-auth-store";
 import type { ChatMode, OutputStyle } from "@/features/ai/store/types";
 import type { AIMessage } from "@/features/ai/types/messages";
 import { getModelById, getProviderById } from "@/features/ai/types/providers";
 import { ClaudeCodeStreamHandler } from "./claude-code-handler";
 import { buildContextPrompt, buildSystemPrompt } from "./context-builder";
 import { getProvider } from "./providers";
+import type { CopilotProvider } from "./providers/copilot-provider";
 import { processStreamingResponse } from "./stream-utils";
 import { getProviderApiToken } from "./token-manager";
 import type { ContextInfo } from "./types";
@@ -55,6 +57,80 @@ export const getChatCompletionStream = async (
       return;
     }
 
+    // Handle GitHub Copilot provider
+    if (providerId === "copilot") {
+      const copilotAuth = useCopilotAuthStore.getState();
+
+      if (!copilotAuth.isAuthenticated) {
+        throw new Error("Please sign in to GitHub Copilot first");
+      }
+
+      const accessToken = await copilotAuth.getAccessToken();
+      if (!accessToken) {
+        throw new Error("Failed to get Copilot access token. Please sign in again.");
+      }
+
+      const contextPrompt = buildContextPrompt(context);
+      const systemPrompt = buildSystemPrompt(contextPrompt, mode, outputStyle);
+
+      const messages: AIMessage[] = [{ role: "system" as const, content: systemPrompt }];
+
+      if (conversationHistory && conversationHistory.length > 0) {
+        messages.push(...conversationHistory);
+      }
+
+      messages.push({ role: "user" as const, content: userMessage });
+
+      const providerImpl = getProvider(providerId) as CopilotProvider;
+      if (!providerImpl) {
+        throw new Error("Copilot provider not initialized");
+      }
+
+      if (copilotAuth.enterpriseUri) {
+        providerImpl.setEnterpriseUri(copilotAuth.enterpriseUri);
+      }
+
+      const streamRequest = {
+        modelId,
+        messages,
+        maxTokens: Math.min(4096, Math.floor(model.maxTokens * 0.25)),
+        temperature: 0.7,
+      };
+
+      const headers = providerImpl.buildHeaders(accessToken);
+      const payload = providerImpl.buildPayload(streamRequest);
+      const url = providerImpl.buildUrl();
+
+      console.log(`Making Copilot streaming chat request with model ${model.name}...`);
+
+      const response = await tauriFetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+
+        if (response.status === 401) {
+          useCopilotAuthStore.getState().reset();
+          onError("Copilot session expired. Please sign in again.");
+          return;
+        }
+
+        if (response.status === 403) {
+          onError("Access denied. Please check your Copilot subscription.");
+          return;
+        }
+
+        onError(`Copilot API error: ${response.status}|||${errorText}`);
+        return;
+      }
+
+      await processStreamingResponse(response, onChunk, onComplete, onError);
+      return;
+    }
+
     const apiKey = await getProviderApiToken(providerId);
     if (!apiKey && provider.requiresApiKey) {
       throw new Error(`${provider.name} API key not found`);
diff --git a/src/utils/providers/copilot-provider.ts b/src/utils/providers/copilot-provider.ts
new file mode 100644
index 00000000..b8a9fcd4
--- /dev/null
+++ b/src/utils/providers/copilot-provider.ts
@@ -0,0 +1,53 @@
+import { AIProvider, type ProviderHeaders, type StreamRequest } from "./provider-interface";
+
+const DEFAULT_BASE_URL = "https://api.githubcopilot.com";
+
+export class CopilotProvider extends AIProvider {
+  private enterpriseUri: string | null = null;
+
+  setEnterpriseUri(uri: string | null) {
+    this.enterpriseUri = uri;
+  }
+
+  getBaseUrl(): string {
+    return this.enterpriseUri || DEFAULT_BASE_URL;
+  }
+
+  buildHeaders(token?: string): ProviderHeaders {
+    const headers: ProviderHeaders = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "Editor-Version": "Athas/1.0.0",
+      "Editor-Plugin-Version": "copilot-athas/1.0.0",
+      "User-Agent": "Athas/1.0.0",
+      "Copilot-Integration-Id": "vscode-chat",
+    };
+
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+
+    return headers;
+  }
+
+  buildPayload(request: StreamRequest): Record<string, unknown> {
+    return {
+      model: request.modelId,
+      messages: request.messages.map((msg) => ({
+        role: msg.role,
+        content: msg.content,
+      })),
+      max_tokens: request.maxTokens,
+      temperature: request.temperature,
+      stream: true,
+    };
+  }
+
+  buildUrl(): string {
+    return `${this.getBaseUrl()}/chat/completions`;
+  }
+
+  async validateApiKey(): Promise<boolean> {
+    return true;
+  }
+}
diff --git a/src/utils/providers/index.ts b/src/utils/providers/index.ts
index 28cc9a8e..a185ae90 100644
--- a/src/utils/providers/index.ts
+++ b/src/utils/providers/index.ts
@@ -1,3 +1,4 @@
+import { CopilotProvider } from "./copilot-provider";
 import { GeminiProvider } from "./gemini-provider";
 import { GrokProvider } from "./grok-provider";
 import { OpenAIProvider } from "./openai-provider";
@@ -43,6 +44,15 @@ function initializeProviders(): void {
     maxTokens: 131072,
   };
   providers.set("grok", new GrokProvider(grokConfig));
+
+  const copilotConfig: ProviderConfig = {
+    id: "copilot",
+    name: "GitHub Copilot",
+    apiUrl: "https://api.githubcopilot.com/chat/completions",
+    requiresApiKey: false,
+    maxTokens: 128000,
+  };
+  providers.set("copilot", new CopilotProvider(copilotConfig));
 }
 
 export function getProvider(providerId: string): AIProvider | undefined {