KAVIA AI for VS Code

KAVIA AI brings codebase-aware engineering assistance into VS Code. It helps teams understand unfamiliar systems, plan and deliver changes, investigate failures, generate tests and documentation, and review proposed work before it is synchronized.

Build and evolve enterprise software with reliability and speed

Open a repository, describe the outcome you need, and add the files, folders, selections, logs, or documents that matter. KAVIA uses workspace context and shared project knowledge to help you move from a question or requirement to reviewable engineering work.

The VS Code extension extends KAVIA AI from the cloud into your local development environment. See the cloud version at chat.kavia.ai.

Why KAVIA

KAVIA is built for cross-functional engineering teams, not just individual developers. It supports common work across the software development lifecycle, including understanding existing systems, planning changes, implementation, testing, documentation, and review.

Most AI coding tools operate within the context window of a single prompt. KAVIA builds a persistent Enterprise Knowledge Graph that maps relationships across your codebase, documentation, workflows, and business logic. The graph is versioned per branch and stays accurate as the code evolves.

A new approach to code with workflows

KAVIA helps you ask system-level architecture questions, trace business logic across services and repositories, and get answers that account for component interactions instead of only a single function.

KAVIA is designed for teams working on:

• Brownfield modernization and large-scale refactoring
• RDK, OpenWrt, and Yocto projects
• Multi-repository enterprise applications
• Embedded and platform software
• Android and AOSP-based systems
• Cross-team feature development
• Root-cause and impact analysis
• Architecture documentation and knowledge transfer
• Reviewable, approval-driven delivery

Explore more use cases at KAVIA AI use cases.

Structured workflows for multi-step engineering tasks

KAVIA workflows break long-running engineering tasks into discrete stages that can be planned, executed, and verified independently.

Workflows coordinate specialised micro-agents across steps such as specification, design, implementation, testing, and pre-PR review. Each agent receives fresh, task-specific context, helping reduce the context overload associated with complex tasks.

Workflows define the artifacts and checks required at each stage. Built-in workflows can be reused, while custom workflows support team-specific processes such as post-release documentation updates.

Use Interactive Chat for quick questions, small fixes, and iterative work. Use workflows when a task needs coordinated steps, defined artifacts, or verification. The extension can enable or disable code-maintenance, code-generation, and documentation-generation workflow experiences independently through settings.

Codebase-grounded chat

Ask questions, investigate issues, and perform engineering work using:

• The active editor
• Selected code
• Open files
• Workspace files and folders
• Project structure
• Shared project knowledge

Type @ to add a file, folder, or editor selection to your request. The selected context remains visible before the request is sent, so you stay in control of what KAVIA uses.

Flexible context and attachments

Add supporting material directly to a session:

• Files and workspace folders
• Selected code
• Pasted text
• Images
• Build logs
• Test output
• Technical documents

Hold Shift while dragging content into KAVIA:

• VS Code Explorer: files and folders
• Operating-system file manager: files only

Interactive review and approval

Review agent-generated work before it is applied. You can compare original and proposed content, approve or reject changes, request revisions, add review comments, and continue synchronization after approval.

This creates a visible checkpoint between generation and delivery.

Git-aware synchronization

KAVIA works with familiar Git and branch workflows. Supported controls include handling uncommitted local changes, backup branch creation, conflict-aware merging, review before merge, generated branch cleanup, and Git operation retries and timeouts.

Inline code completion

Enable KAVIA-powered inline suggestions with:

kavia.enableAutocompletion

Inline completion pauses while an agent is editing the same document, preventing conflicting changes.

Session history and recovery

KAVIA supports session history and restoration, task progress tracking, approval recovery, authentication recovery, connection recovery, and eligible session-log downloads.

Recoverable interruptions are surfaced in the interface, and KAVIA attempts to restore the active session.

Secure authentication

KAVIA integrates with VS Code authentication. Authentication credentials are stored using VS Code Secret Storage and removed when you sign out.

Real-world examples

Use these prompts as starting points. Add @ references to the relevant files, folders, code selection, logs, test output, or technical documents before sending the request.

Onboard to an unfamiliar service

Explain how authentication requests move through this application.

Identify the entry points, main services, dependencies, data flows,
failure paths, and safe extension points.

Diagnose a failing CI test

Trace the cause of this failing authentication test.

Use the attached test output and the related test files. Identify the root
cause, explain why the failure occurs, and propose the smallest safe fix.

Assess the impact of a feature request

Plan organization-level access control for this application.

Identify affected modules, dependencies, risks, migration requirements,
API and data-model changes, rollout considerations, and the tests needed
to validate the change.

Fix a production defect safely

Fix the duplicate notification issue described in the attached incident notes.

Preserve current behavior for other notification types, add regression tests,
and present the proposed changes for review before synchronization.

Modernize a legacy integration

Replace the deprecated API used by this module.

Preserve existing behavior, identify compatibility risks, and add regression
tests for the affected flows.

Prepare a refactoring plan

Remove duplicated retry logic from the payment integration.

Identify the shared behavior, propose a low-risk refactoring sequence,
preserve existing retry semantics, and add regression tests.

Document a system for a new team member

Create an architecture overview for this service.

Cover the main services, dependencies, request flows, operational boundaries,
and the best starting points for a developer who is new to the codebase.

Turn a product idea into a development blueprint

Design a service for processing asynchronous document analysis jobs.

Produce a development blueprint covering the architecture, APIs, data model,
implementation phases, risks, and validation strategy.

Getting started in minutes

The fastest way to begin is to open a repository, open KAVIA AI, sign in, and describe the engineering outcome you want. KAVIA can then guide the next step and request additional context when it is needed.

1. Install and open a project

Install KAVIA AI for VS Code from the Visual Studio Marketplace, then open the repository or project folder you want to work on in VS Code.

2. Open KAVIA AI

Select the KAVIA AI icon in the secondary sidebar, run KAVIA AI: Open KAVIA AI from the Command Palette, or use the shortcut:

• macOS: Cmd+Alt+K
• Windows and Linux: Ctrl+Alt+K

3. Sign in and make your first request

Authenticate with your KAVIA account. Then describe the engineering outcome in plain language:

Explain what this service does, how requests flow through it,
and where I should start if I need to change its authentication behavior.

4. Add context when it helps

Type @ to include the active file, selected code, workspace files, or folders. You can also attach logs, test output, images, documents, and pasted text.

For a quick investigation or small change, start in chat. When the work needs defined stages, deliverables, or verification, choose the workflow that best matches the outcome, such as maintenance, specification, documentation, or project generation.

5. Review before synchronization

Inspect explanations, plans, generated documentation, proposed code, tests, and approval requests. Approve the work, reject it, or request revisions before supported generated changes are synchronized with your workspace.

Core features

Explore the key KAVIA AI features:

• Skills: KAVIA AI Skills
• CodeWiki: KAVIA AI CodeWiki

CodeWiki and documentation workflows

KAVIA can generate and maintain CodeWiki documentation as part of supported local sessions. When local CodeWiki generation is enabled, agent-managed documentation is written into the workspace so it can be reviewed alongside code changes. The KAVIA AI: Sync Local CodeWiki Docs to Cloud command uploads an archive of local CodeWiki documentation to KAVIA when it is ready to be shared.

Documentation-generation workflows can also be enabled or disabled separately from code-maintenance and code-generation workflows.

Commands and shortcuts

View available commands

Command	Purpose
kavia.openChat	Open KAVIA AI
kavia.showLogin	Open authentication
kavia.newChat	Start a new session
kavia.clearChat	Return to the KAVIA home view
kavia.exportChat	Export stored chat history
kavia.reportIssue	Report an issue with KAVIA AI
kavia.syncLocalCodeWikiDocsArchive	Sync local CodeWiki documentation to KAVIA
kavia.openSettings	Open KAVIA settings
kavia.signOut	Sign out and clear stored authentication
kavia.addSelectionToChat	Add selected code to the current conversation

Shortcuts

Action	macOS	Windows and Linux
Open KAVIA AI	Cmd+Alt+K	Ctrl+Alt+K
Add selected code to chat	Cmd+L	Use Add to Chat

---

Settings

KAVIA settings are available under the kavia namespace.

Core settings

Setting	Default	Purpose
kavia.enableAutocompletion	false	Enable inline code completion
kavia.enableInteractiveApproval	true	Review supported changes before they are applied
kavia.generateCodeWikiLocally	false	Generate agent-managed CodeWiki content in the local workspace for supported local maintenance sessions
kavia.useLitePod	false	Use a lite pod for code-maintenance sessions
kavia.enableCodeMaintenance	true	Enable code-maintenance workflows and related UI actions
kavia.enableCodeGeneration	true	Enable code-generation workflows and related UI actions
kavia.enableDocGeneration	true	Enable documentation-generation workflows and related UI actions
kavia.enableEndOfBlockHeuristic	true	Reduce unnecessary suggestions at the end of code blocks
kavia.reviewBeforeMerge	false	Review generated commits before merge
kavia.workspaceRoot	~/kavia/workspace	Set the root directory for KAVIA-created projects
kavia.logLevel	info	Control extension log detail

Git synchronization settings

Setting	Default	Purpose
kavia.sync.uncommittedChangesStrategy	tempCommit	Control how uncommitted changes are handled
kavia.sync.autoMerge	true	Merge generated changes when no conflicts are detected
kavia.sync.createBackupBranch	true	Create a backup branch before merge
kavia.sync.branchCleanupPolicy	askUser	Control cleanup of generated branches
kavia.git.cloneTimeoutSeconds	90	Set the Git clone timeout
kavia.git.syncTimeoutSeconds	60	Set the synchronization timeout
kavia.git.mergeTimeoutSeconds	45	Set the merge timeout
kavia.git.checkoutTimeoutSeconds	30	Set the Git checkout timeout
kavia.git.maxRetries	2	Set the retry limit for failed Git operations

Setting	Default	Description
kavia.serviceAPI	Runtime or environment value	Defines the KAVIA HTTP service URL.
kavia.serviceWS	Runtime or environment value	Defines the KAVIA WebSocket service URL.
kavia.serviceAuth	Runtime or environment value	Defines the KAVIA authentication service URL.
kavia.rleBridgeUrl	Runtime or environment value	Defines the bridge URL for local execution sessions.
kavia.verboseLogging	false	Enables verbose network and autocomplete logging. This may include prompt and response content.
kavia.debugMode	false	Enables development behavior such as mock responses or startup history clearing.

Endpoint settings are machine-overridable so development and packaged builds can target different KAVIA environments.

Local MCP configuration and discovery

The MCPs category in KAVIA AI Settings can save, edit, and remove local stdio and Streamable HTTP MCP server definitions. Definitions are global, so the same saved list is available in every VS Code workspace. Non-secret fields are stored in VS Code global state; environment and HTTP-header values are stored separately in VS Code SecretStorage and are never sent back to the Settings webview. Native OAuth is not supported.

Reusable definition types, validation, normalization, and storage orchestration come from the shared @kavia/mcp package. KVE supplies the VS Code globalState and SecretStorage adapters, extension lifecycle integration, and Settings UI. This does not enable or implement Local MCP in the CLI.

Selecting Connect explicitly starts the saved command for stdio, or connects to the configured URL for Streamable HTTP. The shared @kavia/mcp runtime initializes an MCP client session, discovers the server's tools, and returns safe runtime state for KVE to display. Refresh tools repeats discovery, and Disconnect closes the MCP client and transport. Editing or removing a connected definition also disconnects it. Opening VS Code or Settings never connects a saved server.

All currently discovered tools from connected servers are eligible for use; the first release has no per-tool selection state. The shared runtime creates memory-only task tool IDs, validates invocation requests, and calls tools only after KVE obtains approval through a native VS Code modal. Approval can be granted once, granted for the same task and tool, or denied. Invocation timeout, cancellation, disconnect, configuration-change, and extension-shutdown cleanup are handled locally. RLE and CGA integration are added in later phases, so no discovered tool is sent to CGA yet. Opening VS Code, opening Settings, and saving a definition never automatically connects to an MCP server.

Authentication

KAVIA AI integrates with VS Code authentication through the kavia-auth provider and URI callback handling.

Sensitive values are stored through VS Code secret storage.

During sign-out, the extension removes stored sessions, user details, and refresh tokens, then notifies open chat and settings views.

In development mode, the extension may load a repository-root .env file when NODE_ENV is not production. Packaged production builds skip .env loading and resolve endpoints from packaged runtime defaults and user settings.

Architecture

The extension uses a layered architecture.

• Extension runtime: Owns VS Code APIs, commands, authentication, secrets, providers, storage, and lifecycle handling.
• React webview: Provides chat, login, settings, blueprint, documentation, approval, and session interfaces.
• Backend services: Coordinate KAVIA sessions, models, progress events, generated files, and agent responses.
• WebSocket coordination: Streams task state, responses, approvals, and recovery events.
• Synchronization services: Align generated work with the local workspace and Git state.
• Shared KAVIA packages: Provide reusable backend, flow, workspace, Git, authentication, and logging capabilities.

Typed webview messages connect the React interface to the extension host while keeping VS Code-specific privileges and secrets outside the webview.

Troubleshooting

KAVIA does not connect

Review the configured service endpoints and open the KAVIA AI output channel for connection details.

Sign-in fails or the session has expired

Run KAVIA AI: Show Login and authenticate again.

Use Sign Out first when stored authentication state needs to be reset.

Attachments are unavailable

Confirm that you are working inside a supported project session. Some project attachment capabilities are unavailable in generic chat sessions.

Inline completion does not appear

Confirm that:

• kavia.enableAutocompletion is enabled
• A file or untitled document is active
• An agent is not currently editing the document

A folder cannot be dragged into KAVIA

Use the attachment picker or drag the folder from the VS Code Explorer.

Operating-system file managers may not expose folder contents to VS Code webviews.

---

Support

For product support, visit kavia.ai/contact.