Integrations

VS Code Extension

The Krnl Code extension runs the agent in a webview panel inside VS Code. It auto-manages the Python backend — detecting Python 3.9+, creating a private venv, installing the krnl-code package, and spawning the server. API keys are stored in VS Code's encrypted SecretStorage.

Installation

Install from the VS Code Marketplace, or use Open VSX for Cursor, VSCodium, and Windsurf.

Commands

All commands are prefixed with Krnl: in the Command Palette (Ctrl+Shift+P):

Settings

How It Works

1. Extension detects Python 3.9+ on your system
2. Creates a private Python environment in VS Code's global storage
3. Installs the krnl-code package
4. Starts the agent backend process on a local port
5. Opens a streaming connection for provider + key configuration
6. Sends the user's task to the backend
7. Events stream back: tokens, tool_start, diff, approval_request, done

Supported Editors

The same extension works across editors compatible with VS Code extensions:

CLI (Terminal)

The full agent runs in any terminal — no editor needed. Install with a single command: irm https://github.com/saurabhgk7tech/Krnl-Coding-Agent-Releases/releases/latest/download/install.ps1 | iex (Windows) or curl -fsSL https://github.com/saurabhgk7tech/Krnl-Coding-Agent-Releases/releases/latest/download/install.sh | sh (macOS/Linux). The CLI shares credentials with the VS Code extension via ~/.krnl/credentials.json.

# Interactive session
krnl-code

# One-shot task
krnl-code run "add a /health endpoint" -y

# Environment check
krnl-code doctor

LLM Providers

Krnl works with any OpenAI-compatible API plus native Anthropic support. Configure via /provider, /key, and /model slash commands, or set environment variables.

Web Search Providers

The agent can search the web during tasks. Four providers are supported, auto-detected from environment variables:

The agent also has a web_fetch tool that retrieves and extracts readable text from any URL — no API key needed.

Deployment Platforms

Krnl can deploy to 16 targets. Each requires a CLI tool and a credential environment variable. Run krnl-code deploy --check to see which are ready.

Monitoring & Observability

Krnl integrates with five monitoring platforms. Set the environment variable and the agent wires instrumentation automatically.

The krnl-code monitor command detects which providers are configured and pulls live status. The self-heal loop (krnl-code heal) health-checks the deployed URL, auto-rollbacks on failure, and files a PR for production errors.

Notifications & Ticketing

Receive agent completion or error notifications via your team's messaging platform:

notifications:
  on: [done]                # Events: done, error
  slack_webhook: null
  discord_webhook: null
  telegram_token: null
  telegram_chat_id: null
  linear_api_key: null
  linear_team_id: null

GitHub Actions CI

Run headless agent tasks in CI/CD — automated PR review, security scanning, and test generation. Use krnl-code init-ci to scaffold a workflow file, or write one manually:

name: Krnl Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: curl -fsSL https://github.com/saurabhgk7tech/Krnl-Coding-Agent-Releases/releases/latest/download/install.sh | sh
      - run: ~/.krnl/bin/krnl-code run "review this PR" --json --yes
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}

The --json flag outputs structured results for CI processing. --yes auto-approves all actions (required for non-interactive mode). The generated workflow also runs secret_scan and dependency_audit on every PR.

Git Integration

Krnl has full Git support for working with repositories:

MCP Servers (Model Context Protocol)

Krnl supports the Model Context Protocol for connecting external tools. MCP servers expose their capabilities as mcp__server__tool function calls that the agent can invoke just like native tools.

# MCP servers are configured in config.yaml
# No additional install needed — MCP is built into the CLI

# Config (config.yaml)
mcp:
  servers:
    filesystem:
      command: npx
      args: ["-y", "@modelcontextprotocol/server-filesystem", "/path"]
    my_api:
      url: https://example.com/mcp   # SSE endpoint

Both stdio (local processes) and SSE (remote HTTP) transports are supported. MCP servers can also be bundled in plugins.

Plugin System

Install plugin bundles containing skills, custom commands, and MCP server configs from a directory or remote .zip URL:

# CLI
krnl-code plugin add ./my-plugin
krnl-code plugin add https://example.com/plugin.zip
krnl-code plugin list

# Plugin directory structure:
~/.krnl-code/plugins/<name>/
  skills/<name>/SKILL.md
  commands/*.md
  krnl-plugin.yaml  (manifest + MCP servers)

Lifecycle Hooks

Run shell commands at key agent lifecycle events. Hooks can block tool execution (non-zero exit on PreToolUse prevents the tool from running).

# Config (config.yaml)
hooks:
  PreToolUse:
    - matcher: "write_file|edit_file"
      command: "ruff check ."         # Blocks tool if lint fails
  PostToolUse:
    - matcher: "*"
      command: "echo done > /dev/null"
  Stop:
    - command: "notify-send 'agent finished'"
  UserPromptSubmit:
    - command: "echo prompt received"

Four events supported: PreToolUse (blocking), PostToolUse, Stop, UserPromptSubmit. Hooks default to a 30-second timeout.

Firebase (Usage Tracking)

Krnl can record usage metrics to Firebase Realtime Database when configured with a service account:

# Environment variables
FIREBASE_SERVICE_ACCOUNT=<JSON or base64-encoded key>
FIREBASE_DATABASE_URL=https://<project>.firebasedatabase.app/

# Recorded data:
# /usage/{uid}/history/{push_id}  — timestamped per-turn records
# /usage/{uid}/totals/            — accumulated provider and model totals