The reliability layer for AI coding agents.

Vexp gives your AI agent the right context from your codebase, and mechanically verifies the work before the agent calls it done. Better code, fewer mistakes, up to 70% fewer tokens. Works with 14 agents across 34 languages.

Install Free for VS Code npm install -g vexp-cli

Free · No account · No credit card · Zero network calls · Runs entirely on your machine

On mobile? Get the install links by email.

One-time email with install links. No spam.

Works with

What developers are saying

“If you are working on enterprise software with complex, interconnected modules, you already know the pain of token bloat. Vexp does exactly what it promises: it actually maps out the internal calls and dependencies between modules and drastically reduces API bills.”

Dhiraj S.

Verified buyer

ARMKJLSD

20,000+ installs across VS Code, CLI and OpenVSX

The problem

Agents read everything. They understand nothing.

Every session, the agent scans files, guesses dependencies, and floods its context with code it never uses. Vexp gives it precise structure instead.

Without vexp

8,247tokens

import { authenticate } from "./auth"

import { RateLimiter } from "./limiter"

import { db } from "./database"

import { logger } from "./logger"

import { config } from "./config"

import { User } from "./types/user"

import { Session } from "./types/session"

import { CacheService } from "./cache"

export async function middleware(req, res, next) {

const token = req.headers.authorization

if (!token) return res.status(401).json({ error: "Unauthorized" })

try {

const user = await authenticate(token)

req.user = user

logger.info(`Request from ${user.id}`)

next()

} catch (err) {

logger.error("Auth failed:", err)

res.status(401).json({ error: "Invalid token" })

}

export class RateLimiter {

private redis: Redis

private limits: Map<string, number>

constructor(config: RateLimitConfig) {

this.redis = new Redis(config.redisUrl)

this.limits = new Map(Object.entries(config.limits))

}

async check(key: string): Promise<boolean> {

const count = await this.redis.incr(key)

const limit = this.limits.get(key) ?? 100

return count <= limit

}

import { authenticate } from "./auth"

import { RateLimiter } from "./limiter"

import { db } from "./database"

import { logger } from "./logger"

import { config } from "./config"

import { User } from "./types/user"

import { Session } from "./types/session"

import { CacheService } from "./cache"

export async function middleware(req, res, next) {

const token = req.headers.authorization

if (!token) return res.status(401).json({ error: "Unauthorized" })

try {

const user = await authenticate(token)

req.user = user

logger.info(`Request from ${user.id}`)

next()

} catch (err) {

logger.error("Auth failed:", err)

res.status(401).json({ error: "Invalid token" })

}

export class RateLimiter {

private redis: Redis

private limits: Map<string, number>

constructor(config: RateLimitConfig) {

this.redis = new Redis(config.redisUrl)

this.limits = new Map(Object.entries(config.limits))

}

async check(key: string): Promise<boolean> {

const count = await this.redis.incr(key)

const limit = this.limits.get(key) ?? 100

return count <= limit

}

With vexp

2,140tokens

● pivotmiddleware/auth.ts

export async function authenticate(token: string): Promise<User>

export async function middleware(req, res, next): Promise<void>

○ skeletonservices/cache.ts

class RateLimiter

check(key: string): Promise<boolean>

reset(key: string): Promise<void>

○ skeletonconfig/limits.ts

export const rateLimits: Record<string, number>

● pivotmiddleware/auth.ts

export async function authenticate(token: string): Promise<User>

export async function middleware(req, res, next): Promise<void>

○ skeletonservices/cache.ts

class RateLimiter

check(key: string): Promise<boolean>

○ skeletonconfig/limits.ts

export const rateLimits: Record<string, number>

74%

fewer tokens per query

Not an optimization. Precise context, retrieved locally.

How it works

Graph-native context. Deterministic, local, zero network calls.

Three steps in, one check out: when the agent declares the work done, Horizon verifies it mechanically against the same graph.

Index

Parse. Graph. Persist.

tree-sitter parses your code into a dependency graph: functions, classes, and types as nodes; calls and imports as edges. Secrets are filtered out by default, then everything is stored in local SQLite, never uploaded.

.vexp/index.db (local) + manifest.json (git) · 34.8k nodes | 89.2k edges

< 15sfull index

Traverse

Hybrid search, graph-ranked.

Full-text and TF-IDF search find candidate pivots, then graph centrality ranks them. Intent detection picks the strategy automatically. No embeddings, no external API, with an optional GPU-accelerated on-device model for about 30% more savings.

FTS5 + TF-IDF → 423 candidates → intent: debug → centrality rank → top 12 pivots

< 500msP95 query

Capsule

Pivots in full, the rest skeletonized.

Pivot nodes return full source. Adjacent nodes collapse to signatures and return types, no bodies. The capsule stays bounded to your token budget.

pivot: 350 lines → skeleton: 8 lines (97.7% reduction)

70-90%skeleton reduction

MCP Tools

One primary call. Eleven specialized tools.

Reach for run_pipeline first. The rest are precise instruments, including a session memory that remembers your decisions and learns your conventions.

Specialized tools

Performance

Same model. Better context. More bugs fixed.

Benchmarked on 100 real GitHub issues from SWE-bench Verified, with every agent running the same model. The only variable was the context layer.

73%

Pass@1 resolution

Highest of every agent tested on the 100-task set

$0.67

Cost per task

22% cheaper than the next best agent

7–10

Unique wins

Issues no other agent could resolve

Network calls

Runs entirely on your machine. Your code never leaves it.

Open benchmark · 95% CI ±8.7pp · reproducible in one command · See the full methodology →

For platform teams

The same engine, as an SDK.

Running fleets of agents, CI pipelines or your own product? The vexp SDK serves context, verification and Shield over REST: self-hosted, capacity-licensed, no per-seat math. Cross-repo blast radius across up to unlimited repositories, with per-repo union merging so one clean repo never masks another's broken imports.

Explore the SDK

Pricing

Flat pricing. No credits. No surprises.

Start free, no account or API key. Pro at $19 for professionals, Team at $29 per seat with shared context and analytics, and the Enterprise SDK when your fleet or pipeline needs the engine itself.

Spend $20–200/mo on AI coding? Vexp pays for itself in the first week. 65–70% fewer tokens means 2–3x more work before you hit a limit.

Starter

$0forever

Try vexp on a personal project. No account required.

✓≤ 2,000 nodes
✓Single-repo workspace
✓20 pipeline + skeleton calls / day
✓Context search & session memory
✓VS Code extension or standalone CLI
✓Git manifest sync

Install, open, done

Three steps to context-aware AI. No account, no config, no network calls.

Step 01

Install the extension or CLI

Add Vexp from the VS Code marketplace, or install the standalone CLI. It auto-detects your agent and writes its MCP config for you.

VS Code / Cursor / Windsurf

# Search in the Extensions panel

Extensions → Search "vexp" → Install

✓ Auto-detects your AI agent and configures MCP

Standalone CLI

# Install globally via npm

npm install -g vexp-cli

# Or run the daemon directly

vexp-core mcp --workspace .

✓ Works with Claude Code, Codex, Opencode & more

Install VS Code Extension npm install -g vexp-cli

On mobile? Get the install links by email.

One-time email with install links. No spam.

Give your AI the context it's missing.

Install in 30 seconds. Free forever on small projects. No account needed.

Install free for VS Code

or npm install -g vexp-cli·read the docs

On mobile? Get the install links by email.

One-time email with install links. No spam.

No account · No credit card · Zero network calls

The reliability layer for AI coding agents.

Agents read everything. They understand nothing.

Graph-native context. Deterministic, local, zero network calls.

Index

Traverse

Capsule

One primary call. Eleven specialized tools.

run_pipeline

verify_done

get_context_capsule

get_impact_graph

search_logic_flow

get_skeleton

index_status

workspace_setup

expand_vexp_ref

get_session_context

search_memory

save_observation

Same model. Better context. More bugs fixed.

The same engine, as an SDK.

Flat pricing. No credits. No surprises.

Install, open, done

Install the extension or CLI

Give your AI the context it's missing.