NewIntroducing Vexp SDK

The context engine for AI coding agents.

Vexp gives your AI agent the right context from your codebase, so it writes better code, makes fewer mistakes, and costs up to 70% fewer tokens. Works with 12 agents across 30 languages.

On mobile? Get the install links by email.

One-time email with install links. No spam.

Works with
Claude CodeCursorWindsurfCopilotContinue.devZedAugmentCodexOpencodeKilo CodeKiroAntigravityClaude CodeCursorWindsurfCopilotContinue.devZedAugmentCodexOpencodeKilo CodeKiroAntigravity

What developers are saying

“Since I implemented the extension this afternoon, I was able to switch back to Opus and the usage has magically slowed to a crawl.”

r/ClaudeCode

Reddit

Read the thread →
ARMKJLSD

Trusted by 10,000+ developers

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.

01

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
02

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
03

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. Ten 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
0
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 →

Pricing

Flat pricing. No credits. No surprises.

Start free with session memory on any project, no account or API key. Pro adds all 12 tools, multi-repo workspaces, and 50,000 nodes for $19/mo.

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
  • ✓7 MCP tools (4 core + 3 memory)
  • ✓20 pipeline + skeleton calls / day
  • ✓VS Code extension or standalone CLI
  • ✓Git manifest sync
Most popular
Pro
$19/month

The full context engine for professional developers. Under $20, so you can expense it without approval.

  • ✓50,000 nodes
  • ✓Up to 3 repos per workspace
  • ✓All 12 MCP tools
  • ✓Intent detection & CodeLens
  • ✓Email support

All plans work on unlimited individual repositories. The workspace limit defines how many repos can be linked together for cross-repo queries.

Get started

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

On mobile? Get the install links by email.

One-time email with install links. No spam.

No account · No credit card · Zero network calls