diff --git a/apps/desktop/src/components/connection/ConnectionDialog.vue b/apps/desktop/src/components/connection/ConnectionDialog.vue
index e95a85ed94..fd3cd54840 100644
--- a/apps/desktop/src/components/connection/ConnectionDialog.vue
+++ b/apps/desktop/src/components/connection/ConnectionDialog.vue
@@ -359,8 +359,6 @@ const driverProfiles: Record<
   },
   sqlserver: { type: "sqlserver", port: 1433, user: "sa", label: "SQL Server", icon: "sqlserver" },
   oracle: { type: "oracle", port: 1521, user: "system", label: "Oracle", icon: "oracle" },
-  "oracle-legacy": { type: "oracle", port: 1521, user: "system", label: "Oracle Legacy", icon: "oracle" },
-  "oracle-10g": { type: "oracle", port: 1521, user: "system", label: "Oracle 10g", icon: "oracle" },
   elasticsearch: {
     type: "elasticsearch",
     port: 9200,
@@ -474,6 +472,7 @@ const driverProfiles: Record<
 };
 
 function profileForConfig(config: ConnectionConfig) {
+  if (config.db_type === "oracle") return "oracle";
   if (config.driver_profile && driverProfiles[config.driver_profile]) {
     if (config.driver_profile === "oceanbase-oracle") return "oceanbase";
     return config.driver_profile;
@@ -707,8 +706,6 @@ const iconTypeMap: Record<string, string> = {
   clickhouse: "clickhouse",
   sqlserver: "sqlserver",
   oracle: "oracle",
-  "oracle-legacy": "oracle",
-  "oracle-10g": "oracle",
   elasticsearch: "elasticsearch",
   mariadb: "mariadb",
   tidb: "tidb",
@@ -2600,20 +2597,6 @@ function openExternalUrl(url: string) {
                     </p>
                   </div>
 
-                  <div v-if="form.db_type === 'oracle'" class="grid grid-cols-4 items-center gap-4">
-                    <Label class="text-right text-xs">{{ t("connection.version") }}</Label>
-                    <Select :model-value="selectedType === 'oracle-legacy' || selectedType === 'oracle-10g' ? selectedType : 'oracle'" @update:model-value="(val) => applyProfile(String(val), true)">
-                      <SelectTrigger class="col-span-3 h-8 text-sm">
-                        <SelectValue />
-                      </SelectTrigger>
-                      <SelectContent>
-                        <SelectItem value="oracle">Oracle 19c+</SelectItem>
-                        <SelectItem value="oracle-legacy">Oracle 11g-19c</SelectItem>
-                        <SelectItem value="oracle-10g">Oracle 10g</SelectItem>
-                      </SelectContent>
-                    </Select>
-                  </div>
-
                   <div v-if="form.db_type === 'oracle'" class="grid grid-cols-4 items-center gap-4">
                     <Label class="text-right text-xs">SYSDBA</Label>
                     <label class="col-span-3 flex items-center gap-2 cursor-pointer">
diff --git a/apps/desktop/src/lib/agentDriverInstallHint.ts b/apps/desktop/src/lib/agentDriverInstallHint.ts
index ffd1874559..50df1b2479 100644
--- a/apps/desktop/src/lib/agentDriverInstallHint.ts
+++ b/apps/desktop/src/lib/agentDriverInstallHint.ts
@@ -6,8 +6,13 @@ export interface AgentDriverInstallState {
   installed: boolean;
 }
 
+function agentDriverInstallKey(dbType: DatabaseType | undefined, driverProfile?: string): string | undefined {
+  if (dbType === "oracle") return "oracle";
+  return driverProfile && driverProfile !== dbType ? driverProfile : dbType;
+}
+
 export function showAgentDriverInstallHint(dbType: DatabaseType | undefined, drivers: readonly AgentDriverInstallState[], driverProfile?: string): boolean {
   if (!supportsDriverManagement(dbType)) return false;
-  const driverKey = driverProfile && driverProfile !== dbType ? driverProfile : dbType;
+  const driverKey = agentDriverInstallKey(dbType, driverProfile);
   return drivers.find((driver) => driver.db_type === driverKey)?.installed !== true;
 }
diff --git a/crates/dbx-core/assets/database-drivers.manifest.json b/crates/dbx-core/assets/database-drivers.manifest.json
index 784c89eac4..a1cd9b1c27 100644
--- a/crates/dbx-core/assets/database-drivers.manifest.json
+++ b/crates/dbx-core/assets/database-drivers.manifest.json
@@ -271,18 +271,6 @@
       "metadataConnectionScoped": false,
       "skipTcpProbe": true,
       "defaultPort": 1521,
-      "driverProfiles": [
-        {
-          "profile": "oracle-legacy",
-          "label": "Oracle Legacy",
-          "agentKey": "oracle-legacy"
-        },
-        {
-          "profile": "oracle-10g",
-          "label": "Oracle 10g",
-          "agentKey": "oracle-10g"
-        }
-      ],
       "supportLevel": "operate",
       "capabilities": {
         "queryExecution": true,
diff --git a/crates/dbx-core/src/agent_catalog.rs b/crates/dbx-core/src/agent_catalog.rs
index 228abc5998..f0ea1352d9 100644
--- a/crates/dbx-core/src/agent_catalog.rs
+++ b/crates/dbx-core/src/agent_catalog.rs
@@ -18,8 +18,8 @@ pub struct AgentDriverProfile {
 }
 
 const ORACLE_PROFILES: &[AgentDriverProfile] = &[
-    AgentDriverProfile { profile: "oracle-legacy", key: "oracle-legacy", label: "Oracle Legacy", store_visible: true },
-    AgentDriverProfile { profile: "oracle-10g", key: "oracle-10g", label: "Oracle 10g", store_visible: true },
+    AgentDriverProfile { profile: "oracle-legacy", key: "oracle", label: "Oracle", store_visible: false },
+    AgentDriverProfile { profile: "oracle-10g", key: "oracle", label: "Oracle", store_visible: false },
 ];
 
 const GBASE_PROFILES: &[AgentDriverProfile] =
diff --git a/crates/dbx-core/src/agent_connection.rs b/crates/dbx-core/src/agent_connection.rs
index 4664d73c64..d77664a4c0 100644
--- a/crates/dbx-core/src/agent_connection.rs
+++ b/crates/dbx-core/src/agent_connection.rs
@@ -193,18 +193,13 @@ pub fn oracle_error_with_driver_hint(config: &ConnectionConfig, err: &str) -> St
     if config.db_type != DatabaseType::Oracle {
         return err.to_string();
     }
-    if matches!(config.driver_profile.as_deref(), Some("oracle-legacy" | "oracle-10g")) {
-        return err.to_string();
-    }
 
     let normalized = err.to_lowercase();
     if !normalized.contains("ora-12541") && !err.contains("没有监听程序") {
         return err.to_string();
     }
 
-    format!(
-        "{err}\n\nOracle listener was not reachable with the current driver. If the host and port are correct, try switching Version to Oracle 11g-19c or Oracle 10g."
-    )
+    format!("{err}\n\nOracle listener was not reachable. If the host and port are correct, try switching between Service Name and SID.")
 }
 
 pub fn oracle_alternate_connect_configs(config: &ConnectionConfig, err: &str) -> Vec<ConnectionConfig> {
@@ -356,11 +351,7 @@ pub fn oracle_auth_fallback_profiles(config: &ConnectionConfig, err: &str) -> Ve
     if !normalized.contains("ora-28040") && !normalized.contains("no matching authentication protocol") {
         return Vec::new();
     }
-    match config.driver_profile.as_deref() {
-        Some("oracle-10g") => Vec::new(),
-        Some("oracle-legacy") => vec!["oracle-10g"],
-        _ => vec!["oracle-legacy", "oracle-10g"],
-    }
+    Vec::new()
 }
 
 pub fn oracle_alternate_connect_config(config: &ConnectionConfig, err: &str) -> Option<ConnectionConfig> {
@@ -632,17 +623,17 @@ mod tests {
         let hinted = oracle_error_with_driver_hint(&cfg, err);
 
         assert!(hinted.starts_with(err));
-        assert!(hinted.contains("Oracle 11g-19c"));
-        assert!(hinted.contains("Oracle 10g"));
+        assert!(hinted.contains("Service Name"));
+        assert!(hinted.contains("SID"));
     }
 
     #[test]
-    fn oracle_listener_error_hint_skips_legacy_profiles_and_other_databases() {
+    fn oracle_listener_error_hint_skips_other_databases() {
         let err = "Agent RPC error (-1): ORA-12541: TNS:no listener";
         let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
         cfg.driver_profile = Some("oracle-legacy".to_string());
 
-        assert_eq!(oracle_error_with_driver_hint(&cfg, err), err);
+        assert!(oracle_error_with_driver_hint(&cfg, err).contains("Service Name"));
 
         cfg.db_type = DatabaseType::OceanbaseOracle;
         cfg.driver_profile = None;
@@ -762,20 +753,14 @@ mod tests {
     }
 
     #[test]
-    fn oracle_auth_errors_use_legacy_then_10g_fallbacks() {
+    fn oracle_auth_errors_do_not_switch_driver_profiles() {
         let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
         cfg.driver_profile = Some("oracle".to_string());
 
-        assert_eq!(
-            oracle_auth_fallback_profiles(&cfg, "ORA-28040: No matching authentication protocol"),
-            vec!["oracle-legacy", "oracle-10g"]
-        );
+        assert!(oracle_auth_fallback_profiles(&cfg, "ORA-28040: No matching authentication protocol").is_empty());
 
         cfg.driver_profile = Some("oracle-legacy".to_string());
-        assert_eq!(
-            oracle_auth_fallback_profiles(&cfg, "ORA-28040: No matching authentication protocol"),
-            vec!["oracle-10g"]
-        );
+        assert!(oracle_auth_fallback_profiles(&cfg, "ORA-28040: No matching authentication protocol").is_empty());
 
         cfg.driver_profile = Some("oracle-10g".to_string());
         assert!(oracle_auth_fallback_profiles(&cfg, "ORA-28040: No matching authentication protocol").is_empty());
diff --git a/crates/dbx-core/src/agent_manager.rs b/crates/dbx-core/src/agent_manager.rs
index ae906f3fd7..ed7edc3fc2 100644
--- a/crates/dbx-core/src/agent_manager.rs
+++ b/crates/dbx-core/src/agent_manager.rs
@@ -153,11 +153,8 @@ mod tests {
     async fn runtime_gateway_resolves_profile_specific_keys() {
         let manager = test_manager("profile-key");
 
-        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle-10g"));
-        assert_eq!(
-            AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, Some("oracle-legacy")),
-            Some("oracle-legacy")
-        );
+        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle"));
+        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, Some("oracle-legacy")), Some("oracle"));
         assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, None), Some("oracle"));
         assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Gbase, Some("gbase8s")), Some("gbase8s"));
         assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Gbase, None), Some("gbase"));
@@ -220,7 +217,10 @@ pub struct DriverInfo {
     pub version: String,
     pub label: String,
     pub min_app_version: String,
-    pub jar: ArtifactInfo,
+    #[serde(default)]
+    pub jar: Option<ArtifactInfo>,
+    #[serde(default)]
+    pub native: std::collections::HashMap<String, ArtifactInfo>,
     #[serde(default = "default_jre_key")]
     pub jre: String,
 }
diff --git a/crates/dbx-core/src/agent_runtime.rs b/crates/dbx-core/src/agent_runtime.rs
index 4298a6f0c7..26fa011e9d 100644
--- a/crates/dbx-core/src/agent_runtime.rs
+++ b/crates/dbx-core/src/agent_runtime.rs
@@ -33,9 +33,9 @@ pub async fn spawn_connection_client(
     db_type: &DatabaseType,
     driver_profile: Option<&str>,
 ) -> Result<AgentDriverClient, String> {
-    let key = db_type_to_agent_key(db_type, driver_profile)
+    let keys = runtime_agent_key_candidates(db_type, driver_profile)
         .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?;
-    spawn_client_for_key(manager, key).await
+    spawn_first_available_client(manager, &keys).await
 }
 
 pub async fn call_daemon<T: DeserializeOwned + Send + 'static>(
@@ -45,9 +45,9 @@ pub async fn call_daemon<T: DeserializeOwned + Send + 'static>(
     method: &str,
     params: serde_json::Value,
 ) -> Result<T, String> {
-    let key = db_type_to_agent_key(db_type, driver_profile)
-        .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?
-        .to_string();
+    let keys = runtime_agent_key_candidates(db_type, driver_profile)
+        .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?;
+    let key = first_installed_agent_key(manager, &keys).unwrap_or(keys[0]).to_string();
 
     let mut daemons = manager.daemons.lock().await;
 
@@ -80,6 +80,36 @@ pub async fn call_daemon_method<T: DeserializeOwned + Send + 'static>(
     call_daemon(manager, db_type, driver_profile, method.as_str(), params).await
 }
 
+fn runtime_agent_key_candidates(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<Vec<&'static str>> {
+    let primary = db_type_to_agent_key(db_type, driver_profile)?;
+    if *db_type == DatabaseType::Oracle {
+        return match driver_profile {
+            Some("oracle-legacy") => Some(vec![primary, "oracle-legacy"]),
+            Some("oracle-10g") => Some(vec![primary, "oracle-10g"]),
+            _ => Some(vec![primary]),
+        };
+    }
+    Some(vec![primary])
+}
+
+fn first_installed_agent_key<'a>(manager: &AgentManager, keys: &'a [&'static str]) -> Option<&'a str> {
+    keys.iter().copied().find(|key| manager.is_driver_installed(key))
+}
+
+async fn spawn_first_available_client(
+    manager: &AgentManager,
+    keys: &[&'static str],
+) -> Result<AgentDriverClient, String> {
+    let mut last_error = None;
+    for key in keys {
+        match spawn_client_for_key(manager, key).await {
+            Ok(client) => return Ok(client),
+            Err(err) => last_error = Some(err),
+        }
+    }
+    Err(last_error.unwrap_or_else(|| "No agent driver candidates available".to_string()))
+}
+
 async fn spawn_client_for_key(manager: &AgentManager, key: &str) -> Result<AgentDriverClient, String> {
     let state = manager.load_state();
     let jre_key = state.installed_drivers.get(key).map(|driver| driver.jre.as_str()).unwrap_or(DEFAULT_JRE_KEY);
diff --git a/crates/dbx-core/src/agent_service.rs b/crates/dbx-core/src/agent_service.rs
index 9e8ff5f373..dd873b4b99 100644
--- a/crates/dbx-core/src/agent_service.rs
+++ b/crates/dbx-core/src/agent_service.rs
@@ -81,7 +81,7 @@ pub fn build_agent_list(am: &AgentManager, registry: Option<&AgentRegistry>) ->
                 db_type: key.to_string(),
                 label: label.to_string(),
                 version: remote.map(|r| r.version.clone()).unwrap_or_default(),
-                size: remote.map(|r| r.jar.size).unwrap_or(0),
+                size: remote.and_then(driver_download_artifact).map(|artifact| artifact.size).unwrap_or(0),
                 installed,
                 installed_version: local.map(|l| l.version.clone()),
                 update_available: match (local, remote) {
@@ -95,6 +95,10 @@ pub fn build_agent_list(am: &AgentManager, registry: Option<&AgentRegistry>) ->
         .collect()
 }
 
+fn driver_download_artifact(driver: &crate::agent_manager::DriverInfo) -> Option<&crate::agent_manager::ArtifactInfo> {
+    driver.native.get(AgentManager::current_platform()).or(driver.jar.as_ref())
+}
+
 fn installed_jre_version<'a>(state: &'a crate::agent_manager::AgentState, jre_key: &str) -> Option<&'a String> {
     state
         .jre_versions
@@ -102,6 +106,21 @@ fn installed_jre_version<'a>(state: &'a crate::agent_manager::AgentState, jre_ke
         .or_else(|| (jre_key == DEFAULT_JRE_KEY).then_some(state.jre_version.as_ref()).flatten())
 }
 
+fn mark_executable(path: &Path) -> Result<(), String> {
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut permissions = std::fs::metadata(path).map_err(|err| err.to_string())?.permissions();
+        permissions.set_mode(0o755);
+        std::fs::set_permissions(path, permissions).map_err(|err| err.to_string())?;
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = path;
+    }
+    Ok(())
+}
+
 pub fn jre_needs_install(am: &AgentManager, registry: &AgentRegistry, jre_key: &str) -> bool {
     let state = am.load_state();
     if state.java_runtime.mode != JavaRuntimeMode::Managed {
@@ -352,7 +371,10 @@ async fn install_agent_driver_from_registry(
         return Err(format!("Unknown driver type: {db_type}"));
     };
     let jre_key = &driver.jre;
-    let needs_jre = jre_needs_install(am, registry, jre_key);
+    let native_artifact = driver.native.get(AgentManager::current_platform());
+    let jar_artifact = driver.jar.as_ref();
+    let requires_java_runtime = native_artifact.is_none();
+    let needs_jre = requires_java_runtime && jre_needs_install(am, registry, jre_key);
 
     if needs_jre {
         let jre_info =
@@ -391,8 +413,17 @@ async fn install_agent_driver_from_registry(
         std::fs::remove_file(&jre_archive).ok();
     }
 
-    let jar_path = am.driver_jar_path(db_type);
-    progress(AgentProgressEvent::transfer("driver", 0, driver.jar.size).with_batch(
+    let (artifact, target_path) = if let Some(native) = native_artifact {
+        (native, am.driver_native_path(db_type))
+    } else if let Some(jar) = jar_artifact {
+        (jar, am.driver_jar_path(db_type))
+    } else {
+        return Err(format!("No driver artifact available for {db_type}"));
+    };
+    if let Some(parent) = target_path.parent() {
+        std::fs::create_dir_all(parent).map_err(|err| format!("Failed to create driver directory: {err}"))?;
+    }
+    progress(AgentProgressEvent::transfer("driver", 0, artifact.size).with_batch(
         Some(db_type),
         current,
         total_drivers,
@@ -401,20 +432,28 @@ async fn install_agent_driver_from_registry(
         am,
         progress,
         "driver",
-        &driver.jar.url,
-        &github_url_to_r2_path(&driver.jar.url, "driver"),
-        &jar_path,
-        driver.jar.size,
+        &artifact.url,
+        &github_url_to_r2_path(&artifact.url, "driver"),
+        &target_path,
+        artifact.size,
         Some(CacheIdentity::Driver { db_type, version: &driver.version }),
         Some(db_type),
         current,
         total_drivers,
     )
     .await?;
+    if native_artifact.is_some() {
+        mark_executable(&target_path)?;
+        std::fs::remove_file(am.driver_jar_path(db_type)).ok();
+    } else {
+        std::fs::remove_file(am.driver_native_path(db_type)).ok();
+    }
 
     let mut local_state = am.load_state();
-    if let Some(jre_info) = registry.resolve_jre(jre_key) {
-        local_state.jre_versions.insert(jre_key.clone(), jre_info.version.clone());
+    if requires_java_runtime {
+        if let Some(jre_info) = registry.resolve_jre(jre_key) {
+            local_state.jre_versions.insert(jre_key.clone(), jre_info.version.clone());
+        }
     }
     local_state.installed_drivers.insert(
         db_type.to_string(),
@@ -715,13 +754,16 @@ pub fn import_offline_zip(
         })
         .collect();
 
-    let driver_entries: Vec<(String, String)> = (0..archive.len())
+    let driver_entries: Vec<(String, String, bool)> = (0..archive.len())
         .filter_map(|i| {
             let entry = archive.by_index(i).ok()?;
             let name = entry.name().to_string();
             if name.starts_with("drivers/") && name.ends_with(".jar") {
                 let db_type = extract_db_type_from_filename(&name)?;
-                Some((db_type, name))
+                Some((db_type, name, false))
+            } else if name.starts_with("drivers/") {
+                let db_type = db_type_for_native_offline_entry(&registry, platform, &name)?;
+                Some((db_type, name, true))
             } else {
                 None
             }
@@ -762,7 +804,7 @@ pub fn import_offline_zip(
         result.jre_installed.push(jre_key.clone());
     }
 
-    for (db_type, entry_name) in &driver_entries {
+    for (db_type, entry_name, is_native) in &driver_entries {
         current += 1;
 
         if let Some(remote_driver) = registry.drivers.get(db_type) {
@@ -784,13 +826,19 @@ pub fn import_offline_zip(
             label: agent_catalog::label_for_key(db_type).unwrap_or(db_type).to_string(),
         });
 
-        let jar_path = am.driver_jar_path(db_type);
-        if let Some(parent) = jar_path.parent() {
+        let driver_path = if *is_native { am.driver_native_path(db_type) } else { am.driver_jar_path(db_type) };
+        if let Some(parent) = driver_path.parent() {
             std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
         }
         let mut entry = archive.by_name(entry_name).map_err(|e| format!("Failed to read {entry_name}: {e}"))?;
-        let mut out = std::fs::File::create(&jar_path).map_err(|e| format!("Failed to write driver JAR: {e}"))?;
-        std::io::copy(&mut entry, &mut out).map_err(|e| format!("Failed to copy driver JAR: {e}"))?;
+        let mut out = std::fs::File::create(&driver_path).map_err(|e| format!("Failed to write driver: {e}"))?;
+        std::io::copy(&mut entry, &mut out).map_err(|e| format!("Failed to copy driver: {e}"))?;
+        if *is_native {
+            mark_executable(&driver_path)?;
+            std::fs::remove_file(am.driver_jar_path(db_type)).ok();
+        } else {
+            std::fs::remove_file(am.driver_native_path(db_type)).ok();
+        }
 
         let version = registry.drivers.get(db_type).map(|d| d.version.clone()).unwrap_or_else(|| "local".to_string());
         let jre_key =
@@ -836,6 +884,15 @@ fn extract_db_type_from_filename(name: &str) -> Option<String> {
     Some(db_type.to_string())
 }
 
+fn db_type_for_native_offline_entry(registry: &AgentRegistry, platform: &str, name: &str) -> Option<String> {
+    let filename = name.rsplit('/').next()?;
+    registry.drivers.iter().find_map(|(db_type, driver)| {
+        let artifact = driver.native.get(platform)?;
+        let artifact_filename = artifact.url.rsplit('/').next()?;
+        (artifact_filename == filename).then(|| db_type.clone())
+    })
+}
+
 fn extract_tar_gz(archive: &Path, dest: &Path) -> Result<(), String> {
     std::fs::create_dir_all(dest).map_err(|e| e.to_string())?;
     let status = std::process::Command::new("tar")
diff --git a/crates/dbx-core/tests/agent_service.rs b/crates/dbx-core/tests/agent_service.rs
index 4af5f5fc1e..5aff015287 100644
--- a/crates/dbx-core/tests/agent_service.rs
+++ b/crates/dbx-core/tests/agent_service.rs
@@ -21,7 +21,8 @@ fn registry_with_driver(db_type: &str, version: &str, jre: &str) -> AgentRegistr
             label: db_type.to_string(),
             min_app_version: "0.1.0".to_string(),
             jre: jre.to_string(),
-            jar: ArtifactInfo { url: format!("https://example.com/dbx-agent-{db_type}.jar"), size: 42 },
+            jar: Some(ArtifactInfo { url: format!("https://example.com/dbx-agent-{db_type}.jar"), size: 42 }),
+            native: std::collections::HashMap::new(),
         },
     );
     AgentRegistry { jre: None, jres: std::collections::HashMap::new(), drivers }
diff --git a/crates/dbx-core/tests/database_capabilities.rs b/crates/dbx-core/tests/database_capabilities.rs
index 25ffe65b36..b5c107815d 100644
--- a/crates/dbx-core/tests/database_capabilities.rs
+++ b/crates/dbx-core/tests/database_capabilities.rs
@@ -112,8 +112,8 @@ fn maps_agent_database_types_to_driver_keys() {
     assert_eq!(agent_key(&DatabaseType::Oracle, None), Some("oracle"));
     assert_eq!(agent_key(&DatabaseType::Databend, None), Some("databend"));
     assert_eq!(agent_key(&DatabaseType::InfluxDb, None), Some("influxdb"));
-    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-legacy")), Some("oracle-legacy"));
-    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle-10g"));
+    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-legacy")), Some("oracle"));
+    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle"));
     assert_eq!(agent_key(&DatabaseType::Postgres, None), None);
 }
 
diff --git a/packages/app-tests/agentDriverInstallHint.test.ts b/packages/app-tests/agentDriverInstallHint.test.ts
index 1deb8bfbdb..5d5b8cc17a 100644
--- a/packages/app-tests/agentDriverInstallHint.test.ts
+++ b/packages/app-tests/agentDriverInstallHint.test.ts
@@ -22,7 +22,7 @@ test("does not show agent driver install hints for built-in database types", ()
   assert.equal(showAgentDriverInstallHint("mysql", [{ db_type: "informix", installed: false }]), false);
 });
 
-test("uses the selected Oracle driver profile for install hints", () => {
+test("uses the unified Oracle driver for legacy Oracle profiles", () => {
   assert.equal(
     showAgentDriverInstallHint(
       "oracle",
@@ -33,7 +33,7 @@ test("uses the selected Oracle driver profile for install hints", () => {
       ],
       "oracle-10g",
     ),
-    false,
+    true,
   );
   assert.equal(
     showAgentDriverInstallHint(