diff --git a/.changeset/public-radios-pull.md b/.changeset/public-radios-pull.md
new file mode 100644
index 00000000000..bf2cf98d216
--- /dev/null
+++ b/.changeset/public-radios-pull.md
@@ -0,0 +1,5 @@
+---
+"@kilocode/cli": patch
+---
+
+Improve "/model list" command with pagination, filters and sorting
diff --git a/cli/src/commands/__tests__/helpers/mockContext.ts b/cli/src/commands/__tests__/helpers/mockContext.ts
index 4ca3c836052..254e6f5240c 100644
--- a/cli/src/commands/__tests__/helpers/mockContext.ts
+++ b/cli/src/commands/__tests__/helpers/mockContext.ts
@@ -71,6 +71,14 @@ export function createMockContext(overrides: Partial<CommandContext> = {}): Comm
 		previousTaskHistoryPage: vi.fn().mockResolvedValue(null),
 		sendWebviewMessage: vi.fn().mockResolvedValue(undefined),
 		chatMessages: [],
+		modelListPageIndex: 0,
+		modelListFilters: {
+			sort: "preferred",
+			capabilities: [],
+		},
+		updateModelListFilters: vi.fn(),
+		changeModelListPage: vi.fn(),
+		resetModelListState: vi.fn(),
 	}
 
 	return {
diff --git a/cli/src/commands/__tests__/model.test.ts b/cli/src/commands/__tests__/model.test.ts
index 6aa637e3317..190c00a0c79 100644
--- a/cli/src/commands/__tests__/model.test.ts
+++ b/cli/src/commands/__tests__/model.test.ts
@@ -4,9 +4,11 @@
 
 import { describe, it, expect, vi, beforeEach } from "vitest"
 import { modelCommand } from "../model.js"
+import { createMockContext } from "./helpers/mockContext.js"
 import type { CommandContext } from "../core/types.js"
 import type { RouterModels } from "../../types/messages.js"
 import type { ProviderConfig } from "../../config/types.js"
+import type { ModelRecord } from "../../constants/providers/models.js"
 
 describe("/model command", () => {
 	let mockContext: CommandContext
@@ -51,26 +53,35 @@ describe("/model command", () => {
 		apiKey: "test-key",
 	}
 
+	// Create many models for pagination testing
+	const createManyModels = (count: number): ModelRecord => {
+		const models: ModelRecord = {}
+		for (let i = 1; i <= count; i++) {
+			models[`model-${i}`] = {
+				contextWindow: 100000 + i * 1000,
+				supportsPromptCache: i % 2 === 0,
+				supportsImages: i % 3 === 0,
+				inputPrice: i * 0.5,
+				outputPrice: i * 1.0,
+				displayName: `Model ${i}`,
+			}
+		}
+		return models
+	}
+
 	beforeEach(() => {
 		addMessageMock = vi.fn()
 		updateProviderModelMock = vi.fn().mockResolvedValue(undefined)
 
-		mockContext = {
+		mockContext = createMockContext({
 			input: "/model",
 			args: [],
-			options: {},
-			sendMessage: vi.fn().mockResolvedValue(undefined),
-			addMessage: addMessageMock,
-			clearMessages: vi.fn(),
-			clearTask: vi.fn().mockResolvedValue(undefined),
-			setMode: vi.fn(),
-			exit: vi.fn(),
 			routerModels: mockRouterModels,
 			currentProvider: mockProvider,
 			kilocodeDefaultModel: "",
 			updateProviderModel: updateProviderModelMock,
-			refreshRouterModels: vi.fn().mockResolvedValue(undefined),
-		}
+			addMessage: addMessageMock,
+		})
 	})
 
 	describe("Command metadata", () => {
@@ -107,7 +118,7 @@ describe("/model command", () => {
 
 		it("should have arguments defined", () => {
 			expect(modelCommand.arguments).toBeDefined()
-			expect(modelCommand.arguments).toHaveLength(2)
+			expect(modelCommand.arguments).toHaveLength(3)
 		})
 
 		it("should have subcommand argument with values", () => {
@@ -313,32 +324,47 @@ describe("/model command", () => {
 		})
 
 		it("should filter models when filter is provided", async () => {
+			// Mock updateModelListFilters to actually update the filters
+			const updateFiltersMock = vi.fn((filters) => {
+				mockContext.modelListFilters = { ...mockContext.modelListFilters, ...filters }
+			})
+			mockContext.updateModelListFilters = updateFiltersMock
 			mockContext.args = ["list", "gpt-4"]
 
 			await modelCommand.handler(mockContext)
 
+			// Verify the filter was persisted
+			expect(updateFiltersMock).toHaveBeenCalledWith({ search: "gpt-4" })
+
 			const message = addMessageMock.mock.calls[0][0]
-			expect(message.content).toContain("Filtered by")
+			expect(message.content).toContain('Search: "gpt-4"')
 			expect(message.content).toContain("gpt-4")
 			expect(message.content).not.toContain("gpt-3.5-turbo")
 		})
 
 		it("should show message when no models match filter", async () => {
+			// Mock updateModelListFilters to actually update the filters
+			const updateFiltersMock = vi.fn((filters) => {
+				mockContext.modelListFilters = { ...mockContext.modelListFilters, ...filters }
+			})
+			mockContext.updateModelListFilters = updateFiltersMock
 			mockContext.args = ["list", "nonexistent"]
 
 			await modelCommand.handler(mockContext)
 
+			// Verify the filter was persisted
+			expect(updateFiltersMock).toHaveBeenCalledWith({ search: "nonexistent" })
+
 			const message = addMessageMock.mock.calls[0][0]
 			expect(message.type).toBe("system")
 			expect(message.content).toContain("No models found")
 		})
 
-		it("should display model count", async () => {
+		it("should display model count with pagination", async () => {
 			await modelCommand.handler(mockContext)
 
 			const message = addMessageMock.mock.calls[0][0]
-			expect(message.content).toContain("Total:")
-			expect(message.content).toContain("2 models")
+			expect(message.content).toContain("Showing 1-2 of 2")
 		})
 
 		it("should show error when no provider configured", async () => {
@@ -429,4 +455,204 @@ describe("/model command", () => {
 			}
 		})
 	})
+
+	describe("Model list pagination", () => {
+		beforeEach(() => {
+			mockContext.routerModels = {
+				...mockRouterModels,
+				openrouter: createManyModels(25),
+			}
+			mockContext.args = ["list"]
+		})
+
+		it("should paginate results with 10 items per page", async () => {
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.content).toContain("Showing 1-10 of 25")
+			expect(message.content).toContain("Page 1/3")
+		})
+
+		it("should navigate to specific page", async () => {
+			mockContext.args = ["list", "page", "2"]
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.changeModelListPage).toHaveBeenCalledWith(1)
+		})
+
+		it("should go to next page", async () => {
+			mockContext.args = ["list", "next"]
+			mockContext.modelListPageIndex = 0
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.changeModelListPage).toHaveBeenCalledWith(1)
+		})
+
+		it("should go to previous page", async () => {
+			mockContext.args = ["list", "prev"]
+			mockContext.modelListPageIndex = 1
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.changeModelListPage).toHaveBeenCalledWith(0)
+		})
+
+		it("should show error when already on first page", async () => {
+			mockContext.args = ["list", "prev"]
+			mockContext.modelListPageIndex = 0
+
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.type).toBe("system")
+			expect(message.content).toContain("Already on the first page")
+		})
+
+		it("should show error when already on last page", async () => {
+			mockContext.args = ["list", "next"]
+			mockContext.modelListPageIndex = 2
+
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.type).toBe("system")
+			expect(message.content).toContain("Already on the last page")
+		})
+
+		it("should validate page number", async () => {
+			mockContext.args = ["list", "page", "invalid"]
+
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.type).toBe("error")
+			expect(message.content).toContain("Invalid page number")
+		})
+
+		it("should validate page number is within range", async () => {
+			mockContext.args = ["list", "page", "10"]
+
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.type).toBe("error")
+			expect(message.content).toContain("Must be between 1 and")
+		})
+	})
+
+	describe("Model list sorting", () => {
+		beforeEach(() => {
+			mockContext.args = ["list"]
+		})
+
+		it("should sort by name", async () => {
+			mockContext.args = ["list", "sort", "name"]
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.updateModelListFilters).toHaveBeenCalledWith({ sort: "name" })
+		})
+
+		it("should sort by context window", async () => {
+			mockContext.args = ["list", "sort", "context"]
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.updateModelListFilters).toHaveBeenCalledWith({ sort: "context" })
+		})
+
+		it("should sort by price", async () => {
+			mockContext.args = ["list", "sort", "price"]
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.updateModelListFilters).toHaveBeenCalledWith({ sort: "price" })
+		})
+
+		it("should show error for invalid sort option", async () => {
+			mockContext.args = ["list", "sort", "invalid"]
+
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.type).toBe("error")
+			expect(message.content).toContain("Invalid sort option")
+		})
+
+		it("should show error when sort option is missing", async () => {
+			mockContext.args = ["list", "sort"]
+
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.type).toBe("error")
+			expect(message.content).toContain("Usage: /model list sort")
+		})
+	})
+
+	describe("Model list filtering", () => {
+		beforeEach(() => {
+			mockContext.args = ["list"]
+		})
+
+		it("should filter by images capability", async () => {
+			mockContext.args = ["list", "filter", "images"]
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.updateModelListFilters).toHaveBeenCalledWith({
+				capabilities: ["images"],
+			})
+		})
+
+		it("should filter by cache capability", async () => {
+			mockContext.args = ["list", "filter", "cache"]
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.updateModelListFilters).toHaveBeenCalledWith({
+				capabilities: ["cache"],
+			})
+		})
+
+		it("should toggle filter off when already active", async () => {
+			mockContext.args = ["list", "filter", "images"]
+			mockContext.modelListFilters = {
+				sort: "preferred",
+				capabilities: ["images"],
+			}
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.updateModelListFilters).toHaveBeenCalledWith({
+				capabilities: [],
+			})
+		})
+
+		it("should clear all filters", async () => {
+			mockContext.args = ["list", "filter", "all"]
+			mockContext.modelListFilters = {
+				sort: "preferred",
+				capabilities: ["images", "cache"],
+			}
+
+			await modelCommand.handler(mockContext)
+
+			expect(mockContext.updateModelListFilters).toHaveBeenCalledWith({
+				capabilities: [],
+			})
+		})
+
+		it("should show error for invalid filter option", async () => {
+			mockContext.args = ["list", "filter", "invalid"]
+
+			await modelCommand.handler(mockContext)
+
+			const message = addMessageMock.mock.calls[0][0]
+			expect(message.type).toBe("error")
+			expect(message.content).toContain("Invalid filter option")
+		})
+	})
 })
diff --git a/cli/src/commands/core/types.ts b/cli/src/commands/core/types.ts
index 67d217cce5b..7c4ebf5f3cc 100644
--- a/cli/src/commands/core/types.ts
+++ b/cli/src/commands/core/types.ts
@@ -7,6 +7,7 @@ import type { CliMessage } from "../../types/cli.js"
 import type { CLIConfig, ProviderConfig } from "../../config/types.js"
 import type { ProfileData, BalanceData } from "../../state/atoms/profile.js"
 import type { TaskHistoryData, TaskHistoryFilters } from "../../state/atoms/taskHistory.js"
+import type { ModelListFilters } from "../../state/atoms/modelList.js"
 
 export interface Command {
 	name: string
@@ -76,6 +77,12 @@ export interface CommandContext {
 	sendWebviewMessage: (message: WebviewMessage) => Promise<void>
 	refreshTerminal: () => Promise<void>
 	chatMessages: ExtensionMessage[]
+	// Model list context
+	modelListPageIndex: number
+	modelListFilters: ModelListFilters
+	updateModelListFilters: (filters: Partial<ModelListFilters>) => void
+	changeModelListPage: (pageIndex: number) => void
+	resetModelListState: () => void
 }
 
 export type CommandHandler = (context: CommandContext) => Promise<void> | void
diff --git a/cli/src/commands/model.ts b/cli/src/commands/model.ts
index 42cf2a38309..13478f631ac 100644
--- a/cli/src/commands/model.ts
+++ b/cli/src/commands/model.ts
@@ -3,7 +3,9 @@
  */
 
 import type { Command, ArgumentProviderContext, CommandContext } from "./core/types.js"
-import type { ModelInfo } from "../constants/providers/models.js"
+import type { ModelRecord } from "../constants/providers/models.js"
+import type { ProviderConfig } from "../config/types.js"
+import type { RouterModels } from "../types/messages.js"
 import {
 	getModelsByProvider,
 	getCurrentModelId,
@@ -13,6 +15,22 @@ import {
 	formatPrice,
 	prettyModelName,
 } from "../constants/providers/models.js"
+import { MODEL_LIST_PAGE_SIZE, type ModelListFilters } from "../state/atoms/modelList.js"
+
+/**
+ * Sort options for model list
+ */
+const MODEL_SORT_OPTIONS: Record<string, string> = {
+	name: "name",
+	context: "context",
+	price: "price",
+	preferred: "preferred",
+}
+
+/**
+ * Filter options for model list
+ */
+const MODEL_FILTER_OPTIONS = ["images", "cache", "reasoning", "free", "all"]
 
 /**
  * Ensure router models are loaded for the current provider
@@ -73,6 +91,137 @@ async function ensureRouterModels(context: CommandContext): Promise<boolean> {
 	return true
 }
 
+/**
+ * Sort models by different criteria
+ */
+function sortModels(models: ModelRecord, sortBy: string): string[] {
+	const modelIds = Object.keys(models)
+
+	switch (sortBy) {
+		case "name":
+			return modelIds.sort((a, b) => a.localeCompare(b))
+		case "context":
+			return modelIds.sort((a, b) => (models[b]?.contextWindow || 0) - (models[a]?.contextWindow || 0))
+		case "price":
+			return modelIds.sort((a, b) => {
+				const priceA = models[a]?.inputPrice ?? Infinity
+				const priceB = models[b]?.inputPrice ?? Infinity
+				return priceA - priceB
+			})
+		case "preferred":
+		default:
+			return sortModelsByPreference(models)
+	}
+}
+
+/**
+ * Filter models by capabilities
+ */
+function filterModelsByCapabilities(models: ModelRecord, capabilities: string[]): string[] {
+	if (capabilities.length === 0) {
+		return Object.keys(models)
+	}
+
+	return Object.keys(models).filter((id) => {
+		const model = models[id]
+		if (!model) return false
+
+		return capabilities.every((cap) => {
+			switch (cap) {
+				case "images":
+					return model.supportsImages === true
+				case "cache":
+					return model.supportsPromptCache === true
+				case "reasoning":
+					return (
+						model.supportsReasoningEffort === true ||
+						model.supportsReasoningBudget === true ||
+						(Array.isArray(model.supportsReasoningEffort) && model.supportsReasoningEffort.length > 0)
+					)
+				case "free":
+					// Consider a model free if it has isFree flag OR if both input and output prices are 0
+					return (
+						model.isFree === true ||
+						(model.inputPrice !== undefined &&
+							model.outputPrice !== undefined &&
+							model.inputPrice === 0 &&
+							model.outputPrice === 0)
+					)
+				default:
+					return true
+			}
+		})
+	})
+}
+
+/**
+ * Paginate model list
+ */
+function paginateModels(
+	modelIds: string[],
+	pageIndex: number,
+	pageSize: number = MODEL_LIST_PAGE_SIZE,
+): {
+	pageIds: string[]
+	pageCount: number
+	totalCount: number
+} {
+	const totalCount = modelIds.length
+	if (totalCount === 0) {
+		return { pageIds: [], pageCount: 0, totalCount: 0 }
+	}
+	const pageCount = Math.ceil(totalCount / pageSize)
+	const start = pageIndex * pageSize
+	const pageIds = modelIds.slice(start, start + pageSize)
+
+	return { pageIds, pageCount, totalCount }
+}
+/**
+ * Get filtered model IDs and page count based on current filters
+ * This helper avoids duplication in pagination functions
+ */
+function getFilteredModelsWithPageCount(params: {
+	currentProvider: ProviderConfig
+	routerModels: RouterModels | null
+	kilocodeDefaultModel: string
+	filters: {
+		search?: string | undefined
+		capabilities: ("images" | "cache" | "reasoning" | "free")[]
+	}
+}): {
+	models: ModelRecord
+	modelIds: string[]
+	pageCount: number
+	totalCount: number
+} {
+	const { currentProvider, routerModels, kilocodeDefaultModel, filters } = params
+
+	const { models } = getModelsByProvider({
+		provider: currentProvider.provider,
+		routerModels,
+		kilocodeDefaultModel,
+	})
+
+	// Apply search filter
+	let modelIds = filters.search ? fuzzyFilterModels(models, filters.search) : Object.keys(models)
+
+	// Apply capability filters
+	modelIds = filterModelsByCapabilities(
+		modelIds.reduce((acc, id) => {
+			const model = models[id]
+			if (model) {
+				acc[id] = model
+			}
+			return acc
+		}, {} as ModelRecord),
+		filters.capabilities,
+	)
+
+	const { pageCount, totalCount } = paginateModels(modelIds, 0)
+
+	return { models, modelIds, pageCount, totalCount }
+}
+
 /**
  * Show current model information
  */
@@ -316,10 +465,19 @@ async function selectModel(context: CommandContext, modelId: string): Promise<vo
 }
 
 /**
- * List all available models
+ * List all available models with pagination
  */
-async function listModels(context: CommandContext, filter?: string): Promise<void> {
-	const { currentProvider, routerModels, kilocodeDefaultModel, addMessage } = context
+async function listModels(
+	context: CommandContext,
+	pageIndexOverride?: number,
+	filtersOverride?: { sort?: string; capabilities?: string[]; search?: string | undefined },
+): Promise<void> {
+	const { currentProvider, routerModels, kilocodeDefaultModel, addMessage, modelListPageIndex, modelListFilters } =
+		context
+
+	// Use overrides if provided, otherwise use context values
+	const effectivePageIndex = pageIndexOverride !== undefined ? pageIndexOverride : modelListPageIndex
+	const effectiveFilters = filtersOverride ? { ...modelListFilters, ...filtersOverride } : modelListFilters
 
 	if (!currentProvider) {
 		addMessage({
@@ -349,42 +507,73 @@ async function listModels(context: CommandContext, filter?: string): Promise<voi
 		kilocodeDefaultModel,
 	})
 
-	let modelIds = filter ? fuzzyFilterModels(models, filter) : Object.keys(models)
-	modelIds = sortModelsByPreference(
-		modelIds.reduce(
-			(acc, id) => {
-				const model = models[id]
-				if (model) {
-					acc[id] = model
-				}
-				return acc
-			},
-			{} as Record<string, ModelInfo>,
-		),
+	// Apply search filter from stored filters
+	const effectiveSearch = effectiveFilters.search
+	let modelIds = effectiveSearch ? fuzzyFilterModels(models, effectiveSearch) : Object.keys(models)
+
+	// Apply capability filters
+	modelIds = filterModelsByCapabilities(
+		modelIds.reduce((acc, id) => {
+			const model = models[id]
+			if (model) {
+				acc[id] = model
+			}
+			return acc
+		}, {} as ModelRecord),
+		effectiveFilters.capabilities,
+	)
+
+	// Apply sorting
+	modelIds = sortModels(
+		modelIds.reduce((acc, id) => {
+			const model = models[id]
+			if (model) {
+				acc[id] = model
+			}
+			return acc
+		}, {} as ModelRecord),
+		effectiveFilters.sort,
 	)
 
 	if (modelIds.length === 0) {
 		addMessage({
 			id: Date.now().toString(),
 			type: "system",
-			content: filter ? `No models found matching "${filter}".` : "No models available for this provider.",
+			content: effectiveSearch
+				? `No models found matching "${effectiveSearch}".`
+				: "No models available for this provider.",
 			ts: Date.now(),
 		})
 		return
 	}
 
+	// Paginate results
+	const { pageIds, pageCount, totalCount } = paginateModels(modelIds, effectivePageIndex)
+
 	const providerName = currentProvider.provider
 		.split("-")
 		.map((word: string) => word.charAt(0).toUpperCase() + word.slice(1))
 		.join(" ")
 
-	let content = `**Available Models (${providerName})**`
-	if (filter) {
-		content += ` - Filtered by "${filter}"`
+	let content = `**Available Models (${providerName})** - Page ${effectivePageIndex + 1}/${pageCount}\n`
+
+	// Show active filters
+	const filterParts: string[] = []
+	if (effectiveFilters.sort !== "preferred") {
+		filterParts.push(`Sort: ${effectiveFilters.sort}`)
+	}
+	if (effectiveFilters.capabilities.length > 0) {
+		filterParts.push(`Filter: ${effectiveFilters.capabilities.join(", ")}`)
 	}
-	content += `:\n\n`
+	if (effectiveSearch) {
+		filterParts.push(`Search: "${effectiveSearch}"`)
+	}
+	if (filterParts.length > 0) {
+		content += filterParts.join(" | ") + "\n"
+	}
+	content += `\n`
 
-	for (const modelId of modelIds) {
+	for (const modelId of pageIds) {
 		const model = models[modelId]
 		if (!model) continue
 
@@ -407,9 +596,22 @@ async function listModels(context: CommandContext, filter?: string): Promise<voi
 		content += `\n`
 	}
 
-	content += `**Total:** ${modelIds.length} model${modelIds.length !== 1 ? "s" : ""}\n`
-	content += `\nUse \`/model select <model>\` to switch models\n`
-	content += `Use \`/model info <model>\` for detailed information\n`
+	const start = effectivePageIndex * MODEL_LIST_PAGE_SIZE + 1
+	const end = Math.min((effectivePageIndex + 1) * MODEL_LIST_PAGE_SIZE, totalCount)
+	content += `**Showing ${start}-${end} of ${totalCount} model${totalCount !== 1 ? "s" : ""}**\n\n`
+
+	// Show navigation hints
+	if (pageCount > 1) {
+		if (effectivePageIndex < pageCount - 1) {
+			content += `Use \`/model list next\` for next page\n`
+		}
+		if (effectivePageIndex > 0) {
+			content += `Use \`/model list prev\` for previous page\n`
+		}
+		content += `Use \`/model list page <n>\` to go to a specific page\n`
+	}
+	content += `Use \`/model list sort <option>\` to change sort order\n`
+	content += `Use \`/model list filter <option>\` to filter by capability\n`
 
 	addMessage({
 		id: Date.now().toString(),
@@ -419,6 +621,236 @@ async function listModels(context: CommandContext, filter?: string): Promise<voi
 	})
 }
 
+/**
+ * Change to a specific page
+ */
+async function listModelsPage(context: CommandContext, pageNum: string): Promise<void> {
+	const { currentProvider, routerModels, kilocodeDefaultModel, addMessage, changeModelListPage, modelListFilters } =
+		context
+
+	if (!currentProvider) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "error",
+			content: "No provider configured.",
+			ts: Date.now(),
+		})
+		return
+	}
+
+	const pageIndex = parseInt(pageNum, 10) - 1 // Convert to 0-based index
+
+	if (isNaN(pageIndex) || pageIndex < 0) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "error",
+			content: "Invalid page number. Must be a positive number.",
+			ts: Date.now(),
+		})
+		return
+	}
+
+	// Get total page count
+	const { pageCount } = getFilteredModelsWithPageCount({
+		currentProvider,
+		routerModels,
+		kilocodeDefaultModel,
+		filters: modelListFilters,
+	})
+
+	if (pageIndex >= pageCount) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "error",
+			content: `Invalid page number. Must be between 1 and ${pageCount}.`,
+			ts: Date.now(),
+		})
+		return
+	}
+
+	changeModelListPage(pageIndex)
+	await listModels(context, pageIndex)
+}
+
+/**
+ * Go to next page
+ */
+async function listModelsNext(context: CommandContext): Promise<void> {
+	const {
+		currentProvider,
+		routerModels,
+		kilocodeDefaultModel,
+		addMessage,
+		changeModelListPage,
+		modelListPageIndex,
+		modelListFilters,
+	} = context
+
+	if (!currentProvider) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "error",
+			content: "No provider configured.",
+			ts: Date.now(),
+		})
+		return
+	}
+
+	// Get total page count
+	const { pageCount } = getFilteredModelsWithPageCount({
+		currentProvider,
+		routerModels,
+		kilocodeDefaultModel,
+		filters: modelListFilters,
+	})
+
+	if (modelListPageIndex >= pageCount - 1) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "system",
+			content: "Already on the last page.",
+			ts: Date.now(),
+		})
+		return
+	}
+
+	const newPageIndex = modelListPageIndex + 1
+	changeModelListPage(newPageIndex)
+	await listModels(context, newPageIndex)
+}
+
+/**
+ * Go to previous page
+ */
+async function listModelsPrev(context: CommandContext): Promise<void> {
+	const { addMessage, changeModelListPage, modelListPageIndex } = context
+
+	if (modelListPageIndex <= 0) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "system",
+			content: "Already on the first page.",
+			ts: Date.now(),
+		})
+		return
+	}
+
+	const newPageIndex = modelListPageIndex - 1
+	changeModelListPage(newPageIndex)
+	await listModels(context, newPageIndex)
+}
+
+/**
+ * Change sort order
+ */
+async function listModelsSort(context: CommandContext, sortOption: string): Promise<void> {
+	const { addMessage, updateModelListFilters } = context
+
+	const validSorts = Object.keys(MODEL_SORT_OPTIONS)
+	const mappedSort = MODEL_SORT_OPTIONS[sortOption]
+
+	if (!mappedSort) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "error",
+			content: `Invalid sort option. Valid options: ${validSorts.join(", ")}`,
+			ts: Date.now(),
+		})
+		return
+	}
+
+	const newSort = mappedSort as "name" | "context" | "price" | "preferred"
+	updateModelListFilters({ sort: newSort })
+	await listModels(context, undefined, { sort: newSort })
+}
+
+/**
+ * Change filter
+ */
+async function listModelsFilter(context: CommandContext, filterOption: string): Promise<void> {
+	const { addMessage, updateModelListFilters, modelListFilters } = context
+
+	if (!MODEL_FILTER_OPTIONS.includes(filterOption)) {
+		addMessage({
+			id: Date.now().toString(),
+			type: "error",
+			content: `Invalid filter option. Valid options: ${MODEL_FILTER_OPTIONS.join(", ")}`,
+			ts: Date.now(),
+		})
+		return
+	}
+
+	let newCapabilities: ("images" | "cache" | "reasoning" | "free")[]
+
+	if (filterOption === "all") {
+		// Clear all filters
+		newCapabilities = []
+		updateModelListFilters({ capabilities: [] })
+	} else {
+		// Toggle the filter
+		const currentCapabilities = modelListFilters.capabilities
+		const capability = filterOption as "images" | "cache" | "reasoning" | "free"
+
+		if (currentCapabilities.includes(capability)) {
+			// Remove filter
+			newCapabilities = currentCapabilities.filter((c) => c !== capability)
+			updateModelListFilters({ capabilities: newCapabilities })
+		} else {
+			// Add filter
+			newCapabilities = [...currentCapabilities, capability]
+			updateModelListFilters({ capabilities: newCapabilities })
+		}
+	}
+
+	await listModels(context, undefined, { capabilities: newCapabilities })
+}
+
+/**
+ * Autocomplete provider for list subcommands
+ */
+async function listSubcommandAutocompleteProvider(_context: ArgumentProviderContext) {
+	return [
+		{ value: "page", description: "Go to a specific page", matchScore: 1.0, highlightedValue: "page" },
+		{ value: "next", description: "Go to next page", matchScore: 1.0, highlightedValue: "next" },
+		{ value: "prev", description: "Go to previous page", matchScore: 1.0, highlightedValue: "prev" },
+		{ value: "sort", description: "Change sort order", matchScore: 1.0, highlightedValue: "sort" },
+		{ value: "filter", description: "Filter by capability", matchScore: 1.0, highlightedValue: "filter" },
+	]
+}
+
+/**
+ * Autocomplete provider for sort options
+ */
+async function sortOptionAutocompleteProvider(_context: ArgumentProviderContext) {
+	return Object.keys(MODEL_SORT_OPTIONS).map((option) => ({
+		value: option,
+		description: `Sort by ${option}`,
+		matchScore: 1.0,
+		highlightedValue: option,
+	}))
+}
+
+/**
+ * Autocomplete provider for filter options
+ */
+async function filterOptionAutocompleteProvider(_context: ArgumentProviderContext) {
+	return MODEL_FILTER_OPTIONS.map((option) => {
+		const descriptions: Record<string, string> = {
+			images: "Models supporting images",
+			cache: "Models with prompt cache",
+			reasoning: "Models with reasoning capabilities",
+			free: "Free models only",
+			all: "Clear all filters",
+		}
+		return {
+			value: option,
+			description: descriptions[option] || option,
+			matchScore: 1.0,
+			highlightedValue: option,
+		}
+	})
+}
+
 /**
  * Autocomplete provider for model names
  */
@@ -466,7 +898,18 @@ export const modelCommand: Command = {
 	aliases: ["mdl"],
 	description: "View and manage AI models",
 	usage: "/model [subcommand] [args]",
-	examples: ["/model", "/model info claude-sonnet-4.5", "/model select gpt-4", "/model list", "/model list claude"],
+	examples: [
+		"/model",
+		"/model info claude-sonnet-4.5",
+		"/model select gpt-4",
+		"/model list",
+		"/model list claude",
+		"/model list page 2",
+		"/model list next",
+		"/model list prev",
+		"/model list sort price",
+		"/model list filter images",
+	],
 	category: "settings",
 	priority: 8,
 	arguments: [
@@ -481,8 +924,8 @@ export const modelCommand: Command = {
 			],
 		},
 		{
-			name: "model-or-filter",
-			description: "Model name (for info/select) or filter (for list)",
+			name: "model-or-list-subcommand",
+			description: "Model name (for info/select) or list subcommand (page, next, prev, sort, filter)",
 			required: false,
 			conditionalProviders: [
 				{
@@ -492,6 +935,25 @@ export const modelCommand: Command = {
 					},
 					provider: modelAutocompleteProvider,
 				},
+				{
+					condition: (context) => context.getArgument("subcommand") === "list",
+					provider: listSubcommandAutocompleteProvider,
+				},
+			],
+		},
+		{
+			name: "argument",
+			description: "Argument for the list subcommand",
+			required: false,
+			conditionalProviders: [
+				{
+					condition: (context) => context.getArgument("model-or-list-subcommand") === "sort",
+					provider: sortOptionAutocompleteProvider,
+				},
+				{
+					condition: (context) => context.getArgument("model-or-list-subcommand") === "filter",
+					provider: filterOptionAutocompleteProvider,
+				},
 			],
 		},
 	],
@@ -539,8 +1001,69 @@ export const modelCommand: Command = {
 				break
 
 			case "list": {
-				const filter = args.length > 1 ? args[1] : undefined
-				await listModels(context, filter)
+				// Check for list subcommands
+				const listSubcommand = args[1]?.toLowerCase()
+
+				if (!listSubcommand) {
+					context.updateModelListFilters({ search: undefined } as Partial<ModelListFilters>)
+					await listModels(context, undefined, { search: undefined } as Partial<ModelListFilters>)
+					break
+				}
+
+				switch (listSubcommand) {
+					case "page":
+						if (args.length < 3 || !args[2]) {
+							context.addMessage({
+								id: Date.now().toString(),
+								type: "error",
+								content: "Usage: /model list page <number>",
+								ts: Date.now(),
+							})
+							return
+						}
+						await listModelsPage(context, args[2])
+						break
+
+					case "next":
+						await listModelsNext(context)
+						break
+
+					case "prev":
+					case "previous":
+						await listModelsPrev(context)
+						break
+
+					case "sort":
+						if (args.length < 3 || !args[2]) {
+							context.addMessage({
+								id: Date.now().toString(),
+								type: "error",
+								content: `Usage: /model list sort <option>\nValid options: ${Object.keys(MODEL_SORT_OPTIONS).join(", ")}`,
+								ts: Date.now(),
+							})
+							return
+						}
+						await listModelsSort(context, args[2])
+						break
+
+					case "filter":
+						if (args.length < 3 || !args[2]) {
+							context.addMessage({
+								id: Date.now().toString(),
+								type: "error",
+								content: `Usage: /model list filter <option>\nValid options: ${MODEL_FILTER_OPTIONS.join(", ")}`,
+								ts: Date.now(),
+							})
+							return
+						}
+						await listModelsFilter(context, args[2])
+						break
+
+					default:
+						context.updateModelListFilters({ search: listSubcommand })
+						await listModels(context, undefined, { search: listSubcommand })
+						break
+				}
 				break
 			}
 
diff --git a/cli/src/state/atoms/history.ts b/cli/src/state/atoms/history.ts
index 19b360c4692..c9e9c917e30 100644
--- a/cli/src/state/atoms/history.ts
+++ b/cli/src/state/atoms/history.ts
@@ -134,10 +134,8 @@ export const addToHistoryAtom = atom(null, async (get, set, prompt: string) => {
 	try {
 		const currentData = get(historyDataAtom)
 		const newData = addEntry(currentData, prompt)
-
-		// Only save if data actually changed
+		set(historyDataAtom, newData)
 		if (newData.entries.length !== currentData.entries.length) {
-			set(historyDataAtom, newData)
 			await saveHistory(newData)
 		}
 	} catch (error) {
diff --git a/cli/src/state/atoms/index.ts b/cli/src/state/atoms/index.ts
index ac099d17026..2b2dc0379aa 100644
--- a/cli/src/state/atoms/index.ts
+++ b/cli/src/state/atoms/index.ts
@@ -162,6 +162,26 @@ export {
 	notificationsErrorAtom,
 } from "./notifications.js"
 
+// ============================================================================
+// Model List Atoms - Model list pagination, sorting, and filtering
+// ============================================================================
+export {
+	// Core model list atoms
+	modelListPageIndexAtom,
+	modelListFiltersAtom,
+
+	// Model list action atoms
+	updateModelListFiltersAtom,
+	changeModelListPageAtom,
+	resetModelListStateAtom,
+
+	// Constants and types
+	MODEL_LIST_PAGE_SIZE,
+	defaultModelListFilters,
+	type ModelListFilters,
+	type ModelListState,
+} from "./modelList.js"
+
 // ============================================================================
 // UI Atoms - Command-based UI state
 // ============================================================================
diff --git a/cli/src/state/atoms/modelList.ts b/cli/src/state/atoms/modelList.ts
new file mode 100644
index 00000000000..4886654fa59
--- /dev/null
+++ b/cli/src/state/atoms/modelList.ts
@@ -0,0 +1,64 @@
+/**
+ * Model list state management atoms
+ * Handles pagination, sorting, and filtering for the /model list command
+ */
+import { atom } from "jotai"
+
+export const MODEL_LIST_PAGE_SIZE = 10
+
+export interface ModelListFilters {
+	search?: string | undefined
+	sort: "name" | "context" | "price" | "preferred"
+	capabilities: ("images" | "cache" | "reasoning" | "free")[]
+}
+
+export interface ModelListState {
+	pageIndex: number
+	filters: ModelListFilters
+}
+
+// Default filters
+export const defaultModelListFilters: ModelListFilters = {
+	sort: "preferred",
+	capabilities: [],
+}
+
+/**
+ * Current page index (0-based)
+ */
+export const modelListPageIndexAtom = atom<number>(0)
+
+/**
+ * Current filters for model list
+ */
+export const modelListFiltersAtom = atom<ModelListFilters>(defaultModelListFilters)
+
+/**
+ * Action atom to update filters
+ */
+export const updateModelListFiltersAtom = atom(null, (get, set, filters: Partial<ModelListFilters>) => {
+	const current = get(modelListFiltersAtom)
+	const updated = { ...current, ...filters }
+	// Remove search if it's explicitly set to undefined
+	if ("search" in filters && filters.search === undefined) {
+		delete updated.search
+	}
+	set(modelListFiltersAtom, updated)
+	// Reset to first page when filters change
+	set(modelListPageIndexAtom, 0)
+})
+
+/**
+ * Action atom to change page
+ */
+export const changeModelListPageAtom = atom(null, (get, set, pageIndex: number) => {
+	set(modelListPageIndexAtom, pageIndex)
+})
+
+/**
+ * Action atom to reset model list state
+ */
+export const resetModelListStateAtom = atom(null, (get, set) => {
+	set(modelListFiltersAtom, defaultModelListFilters)
+	set(modelListPageIndexAtom, 0)
+})
diff --git a/cli/src/state/hooks/useCommandContext.ts b/cli/src/state/hooks/useCommandContext.ts
index 07591cf8e14..87847e11d5d 100644
--- a/cli/src/state/hooks/useCommandContext.ts
+++ b/cli/src/state/hooks/useCommandContext.ts
@@ -34,6 +34,13 @@ import {
 	taskHistoryLoadingAtom,
 	taskHistoryErrorAtom,
 } from "../atoms/taskHistory.js"
+import {
+	modelListPageIndexAtom,
+	modelListFiltersAtom,
+	updateModelListFiltersAtom,
+	changeModelListPageAtom,
+	resetModelListStateAtom,
+} from "../atoms/modelList.js"
 import { useWebviewMessage } from "./useWebviewMessage.js"
 import { useTaskHistory } from "./useTaskHistory.js"
 import { getModelIdKey } from "../../constants/providers/models.js"
@@ -120,6 +127,13 @@ export function useCommandContext(): UseCommandContextReturn {
 		previousPage: previousTaskHistoryPage,
 	} = useTaskHistory()
 
+	// Get model list state and functions
+	const modelListPageIndex = useAtomValue(modelListPageIndexAtom)
+	const modelListFilters = useAtomValue(modelListFiltersAtom)
+	const updateModelListFilters = useSetAtom(updateModelListFiltersAtom)
+	const changeModelListPage = useSetAtom(changeModelListPageAtom)
+	const resetModelListState = useSetAtom(resetModelListStateAtom)
+
 	// Create the factory function
 	const createContext = useCallback<CommandContextFactory>(
 		(
@@ -216,6 +230,12 @@ export function useCommandContext(): UseCommandContextReturn {
 				previousTaskHistoryPage,
 				sendWebviewMessage: sendMessage,
 				chatMessages: chatMessages as unknown as ExtensionMessage[],
+				// Model list context
+				modelListPageIndex,
+				modelListFilters,
+				updateModelListFilters,
+				changeModelListPage,
+				resetModelListState,
 			}
 		},
 		[
@@ -252,6 +272,11 @@ export function useCommandContext(): UseCommandContextReturn {
 			nextTaskHistoryPage,
 			previousTaskHistoryPage,
 			chatMessages,
+			modelListPageIndex,
+			modelListFilters,
+			updateModelListFilters,
+			changeModelListPage,
+			resetModelListState,
 		],
 	)
 
diff --git a/cli/vitest.config.ts b/cli/vitest.config.ts
index a17b093ec76..03b4dfbcb42 100644
--- a/cli/vitest.config.ts
+++ b/cli/vitest.config.ts
@@ -3,7 +3,7 @@ import { defineConfig } from "vitest/config"
 export default defineConfig({
 	test: {
 		// Test file patterns
-		include: ["src/__tests__/**/*.test.ts", "integration-tests/**/*.test.ts"],
+		include: ["src/**/*.test.ts", "integration-tests/**/*.test.ts"],
 
 		// Timeout for tests (integration tests may take longer)
 		testTimeout: 30000,