KAVIA AI for VS Code

Bring enterprise software engineering intelligence into your editor

KAVIA AI for VS Code connects the editor you already use to KAVIA’s shared project knowledge, agentic workflows, and governed delivery experience.

Work with complex codebases directly from VS Code. Ask architecture questions, investigate failures, plan changes, generate or maintain code, create project documentation, review proposed updates, and carry work from intent to validated, reviewable change without repeatedly rebuilding context.

KAVIA is designed for enterprise software delivery, not just isolated file edits. The extension connects your local workspace to persistent project knowledge so developers can move faster while teams retain shared understanding, workflow visibility, and control.

Understand the system. Plan with context. Build reviewable change. Validate before delivery.

Product demo

A strong end-to-end demo should show a developer:

1. Opening the KAVIA AI panel.
2. Signing in.
3. Starting a workspace maintenance session.
4. Adding the current file, selected code, or workspace content with @.
5. Asking KAVIA to investigate or implement a change.
6. Reviewing the proposed result.
7. Approving, rejecting, or requesting changes before synchronization.

From intent to trusted software change

When you want KAVIA AI to do more than answer a question, you can ask it to:

KAVIA connects the development pathway inside VS Code.

Understand

Explore unfamiliar code, dependencies, modules, services, and system behavior using codebase-grounded context.

Plan & Design

Turn requirements and engineering intent into implementation plans, architecture guidance, project documentation, and reviewable development blueprints.

Build

Generate or maintain code using the current workspace, selected files, project knowledge, and familiar Git-oriented workflows.

Test

Create tests, investigate failures, inspect the impact of a proposed change, and gather evidence that the work is ready to move forward.

Modernize & Operate

Refactor existing systems, trace root causes, preserve project knowledge, and maintain continuity across sessions, repositories, and teams.

Built for complex codebases

Traditional coding assistants are often bounded by the current file, recent prompts, or manually supplied context. KAVIA connects VS Code to a broader understanding of the software system.

Use KAVIA AI for:

• Brownfield modernization and large-scale refactoring.
• Multi-repository enterprise applications.
• Embedded and platform software.
• Android and AOSP-style systems.
• RDK, OpenWrt, and Yocto-style projects.
• Cross-team feature delivery.
• Root-cause analysis across services and repositories.
• Impact analysis before major changes.
• Project onboarding and knowledge transfer.
• Reviewable, approval-driven software change.

Key capabilities

Codebase-grounded workspace chat

Chat with the current workspace using context from the active editor, selected code, open files, workspace files, and project structure.

Type @ in the composer to reference:

• The current file.
• The current selection.
• A workspace file.
• A workspace folder.

Selected context appears before the message is sent, helping you see and control what KAVIA will use.

Shared project knowledge and CodeWiki

Open CodeWiki from the KAVIA AI header to access the agent-managed knowledge base for the current workspace.

CodeWiki helps teams preserve and reuse understanding of:

• System structure and behavior.
• Important files and modules.
• Dependencies and relationships.
• Architecture decisions.
• Development conventions.
• Prior investigation and implementation context.

This shared knowledge reduces the need to repeatedly explain the codebase and helps ground future plans, code changes, tests, and documentation.

Code maintenance sessions

Start or resume an agentic maintenance session for an existing workspace.

Maintenance sessions support work such as:

• Fixing defects and failing tests.
• Investigating runtime or build failures.
• Refactoring services and modules.
• Cleaning up technical debt.
• Updating dependencies and APIs.
• Adding or modifying features.
• Improving tests and documentation.
• Modernizing legacy code.

KAVIA tracks activity, progress, connection state, session history, and restoration state so work can continue without restarting the entire investigation.

Spec-based code generation

Create a new application or project from a natural-language description.

When KAVIA produces a generation blueprint, the extension opens a dedicated blueprint editor where you can inspect the proposed development pathway before implementation continues.

Review the blueprint, refine the direction, and approve the plan before KAVIA generates the project.

Interactive approval and reviewable change

Keep developers in control of agent-generated work.

When interactive approval is enabled, KAVIA can pause before applying changes and present the proposed result for review. You can:

• Approve the changes.
• Reject the changes.
• Request revisions.
• Add review comments.
• Compare original and proposed content.
• Continue synchronization after approval.

This creates a visible checkpoint between generation and application, supporting governed delivery without forcing developers out of their normal workflow.

Project documentation

Open project documentation directly from the KAVIA AI header.

Use the documentation workspace to create and maintain knowledge-aware engineering artifacts such as:

• Project overviews.
• Architecture documentation.
• Implementation guidance.
• Development notes.
• Technical specifications.
• Test and validation guidance.
• Onboarding material.

File, folder, text, and image attachments

Add supporting context to project sessions through the composer.

You can:

• Select files or folders using the attachment controls.
• Drag supported files from the operating system.
• Drag supported items from the VS Code Explorer.
• Convert large pasted text into an attachment.
• Add images as visual context.
• Remove attached context before sending.

Attachments are displayed as visible chips or thumbnails so the request remains inspectable.

Drag and drop attachments

Always hold Shift while dragging into KAVIA AI, regardless of the drag source or platform.

• VS Code Explorer — supports both files and folders.
• OS file manager — supports files only; folder drops are not available.

Inline code completion

Enable KAVIA inline completion for file and untitled documents.

Inline suggestions are controlled by:

kavia.enableAutocompletion

To avoid conflicting edits, inline completion is intentionally paused while an agent is streaming content into a document.

Session history and continuity

Return to previous work without losing the thread.

The chat experience supports:

• Session history.
• Session restoration.
• Active-session exit handling.
• Task progress updates.
• Completion state.
• Eligible session-log downloads.
• Approval recovery.
• Authentication recovery.

Resilient agent communication

The extension tracks WebSocket state, reconnection attempts, authentication failures, task completion, and approval state.

When a recoverable interruption occurs, KAVIA updates the interface and attempts to restore a usable session rather than silently abandoning the workflow.

Git-aware synchronization

KAVIA supports familiar branch and review practices when synchronizing generated work into a local workspace.

Configurable controls include:

• Handling uncommitted local changes.
• Automatic merge behavior.
• Backup branch creation.
• Review before merge.
• Feature-branch cleanup.
• Git operation timeouts.
• Retry behavior.

This keeps agentic work aligned with existing engineering practices instead of introducing an artificial delivery path.

Authentication

Sign in through the KAVIA authentication provider.

Authentication material is stored in VS Code secret storage. Signing out removes stored KAVIA sessions, tokens, and user details, then updates active KAVIA views.

Common workflows

Understand an unfamiliar codebase

Ask KAVIA to explain a subsystem, trace a request flow, identify dependencies, or locate the implementation behind a feature.

Investigate a failure

Attach the relevant file, build output, test result, or log. Ask KAVIA to trace the likely root cause and propose a codebase-grounded fix.

Plan a change before coding

Describe the desired outcome and ask KAVIA to identify affected modules, implementation steps, risks, and validation requirements.

Implement a feature

Start a workspace maintenance session, add relevant files with @, describe the feature, and review the generated changes before applying them.

Modernize legacy code

Use a maintenance session to refactor deprecated APIs, upgrade dependencies, improve architecture boundaries, or migrate an existing implementation.

Create a new project

Describe the application, review the generated blueprint, approve the development pathway, and follow progress as files are created.

Generate documentation

Open the documentation experience or ask KAVIA to create architecture notes, onboarding content, implementation guidance, or technical documentation grounded in the workspace.

Getting started

1. Open a workspace

Open an existing repository folder in VS Code.

2. Open KAVIA AI

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

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

3. Sign in

Authenticate with KAVIA AI.

4. Choose a workflow

Start a new chat, open a workspace maintenance session, resume previous work, or begin a code generation workflow.

5. Add context

Type @ to reference the current file, current selection, workspace files, or folders. You can also attach supporting files, folders, text, or images.

6. Describe the outcome

Focus the request on the engineering result you want, for example:

Trace the cause of the failing authentication test and propose the smallest safe fix.

Analyze the impact of replacing this service interface across the workspace.

Refactor this module to remove duplicate retry logic and add regression tests.

7. Review the result

Inspect KAVIA’s response, proposed changes, blueprint, or approval request. Approve, reject, or request revisions before work is synchronized.

Commands and shortcuts

Command	Title	Purpose
kavia.openChat	Open KAVIA AI	Reveals the KAVIA AI view.
kavia.showLogin	KAVIA AI: Show Login	Opens the authentication experience.
kavia.newChat	New Chat	Opens the new-session workflow.
kavia.clearChat	Home	Returns the current chat view to its home state.
kavia.exportChat	Export Chat History	Exports stored chat history as JSON.
kavia.openSettings	KAVIA AI Settings	Opens KAVIA settings.
kavia.signOut	Sign Out	Signs out and clears stored KAVIA authentication state.
kavia.addSelectionToChat	Add to Chat	Adds the current editor selection to chat context.
kavia.addReviewComment	Request Changes	Adds feedback during an approval workflow.
kavia.closeReviewComment	Close	Closes a KAVIA review comment thread.

Additional shortcuts:

• Open KAVIA AI: Cmd+Alt+K on macOS or Ctrl+Alt+K on Windows and Linux.
• Add selected code to chat: Cmd+L on macOS when editor text is selected.

Settings

KAVIA AI contributes settings under the kavia namespace.

User experience and agent controls

Setting	Default	Description
kavia.enableAutocompletion	false	Enables automatic inline code completion.
kavia.enableInteractiveApproval	true	Requests approval before supported agent-generated changes are applied.
kavia.generateCodeWikiLocally	true	Generates agent-managed CodeWiki documentation in the local workspace for supported local maintenance sessions.
kavia.enableEndOfBlockHeuristic	true	Reduces unnecessary completion suggestions at the end of code blocks.
kavia.reviewBeforeMerge	false	Opens review UI for generated commits before automatic merge.
kavia.workspaceRoot	~/kavia/workspace	Defines the root folder used for KAVIA-created and cloned projects.
kavia.logLevel	info	Sets the KAVIA AI output-channel log level.

Synchronization and Git controls

Setting	Default	Description
kavia.sync.uncommittedChangesStrategy	tempCommit	Controls how uncommitted local changes are handled during synchronization.
kavia.sync.autoMerge	true	Automatically merges generated changes when no conflicts are detected.
kavia.sync.createBackupBranch	true	Creates a backup branch before generated changes are merged.
kavia.sync.branchCleanupPolicy	askUser	Controls cleanup of generated feature branches after synchronization.
kavia.git.cloneTimeoutSeconds	90	Sets the Git clone timeout.
kavia.git.syncTimeoutSeconds	60	Sets the Git synchronization timeout.
kavia.git.mergeTimeoutSeconds	45	Sets the Git merge timeout.
kavia.git.checkoutTimeoutSeconds	30	Sets the Git checkout timeout.
kavia.git.maxRetries	2	Sets the maximum retry count for failed Git operations.

Connectivity and advanced settings

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 supports local stdio and Streamable HTTP servers with no authentication, static headers, or browser OAuth.

See the Local MCP user guide for setup, OAuth behavior, credential storage, limitations, and troubleshooting.

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 AI does not connect

Check the configured API, WebSocket, authentication, and local-execution bridge URLs. The extension logs resolved endpoint sources during activation and displays WebSocket state in the interface.

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 cleared.

Attachments are unavailable

Confirm that you are inside a supported project session with a project identifier. Generic chat does not enable every project attachment capability.

Inline completion does not appear

Confirm that kavia.enableAutocompletion is enabled and that the active editor contains a file or untitled document. Inline completion is paused while an agent is streaming content into a document.

A folder cannot be added by drag-and-drop

Some operating-system drag contexts do not expose folder contents to a VS Code webview. Use the attachment picker or drag the folder from the VS Code Explorer.

Support

For product support, visit kavia.ai/contact.