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

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

Synchronization and Git controls

Connectivity and advanced settings

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.

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.