SWE-bench Pro81.7% with Opus 5 · Fable-5-level results at half the token price

The reliability layer for AI coding agents.

The right context before your agent writes a line, and a mechanical check before it says done. Up to 70% fewer tokens.33,000+ installs · 14 agents · 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

33,000+ installs across the VS Code Marketplace, npm and Open VSX

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

Fable-5-level results from Opus 5. At half the token price.

Measured on SWE-bench Pro: 731 real GitHub issues, one completed session per task, every session published.

81.7%

Resolved on SWE-bench Pro

597 of 731 tasks. Anthropic reports 80.3% for Fable 5.

$1.52

Cost per task

Claude Opus 5 tokens, metered by Claude Code, over the full run.

Token price vs Fable 5

Opus 5 is $5 / $25 per Mtok. Fable 5 is $10 / $50.

Network calls

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

Single run · 95% CI 78.7–84.3 · official Scale AI harness · every session published · See the full benchmark →

Two ways to save

Pay less per turn. Then pay less per token.

vexp trims what every agent turn costs. It also lets Claude Opus 5 do the job Anthropic prices Fable 5 for.

Intrinsic · fewer tokens per turn

The agent reads what matters, not the whole repo.

Before the first model turn, vexp hands the agent one orientation block: the ranked entry points and the blast radius of the task. Then a four-tool catalog instead of file-by-file exploration, and a mechanical check before the agent calls the work done.

Every exploration turn the agent skips is context the model never has to replay again. Zero network calls: the index lives on your machine.

CONTEXT CAPSULE8.2k → 2.1k tokens−74%

Model choice · half the token price

Opus 5 with vexp does Fable 5's job.

On SWE-bench Pro, Claude Code running Claude Opus 5 with vexp resolved 81.7% of 731 real GitHub issues. Anthropic reports 80.3% for Claude Fable 5, whose tokens cost twice as much: $10 / $50 per million against $5 / $25.

Claude Opus 5 + vexp 3.1.1

Claude Code 2.1.220 · this run

81.7%

$5 / $25 per Mtok

Claude Fable 5

Anthropic, vendor-reported

80.3%

$10 / $50 per Mtok

Claude Opus 5

Anthropic, vendor-reported

79.2%

$5 / $25 per Mtok

this runvendor-reported

0255075100%

Single run · 95% CI 78.7–84.3 · every session published · Full benchmark →

The two savings stack: fewer tokens replayed per turn, on a model that costs half per token, for a result at the level Anthropic publishes for its pricier tier.

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

Fable-5-level results from Opus 5. At half the token price.

Pay less per turn. Then pay less per token.

The agent reads what matters, not the whole repo.

Opus 5 with vexp does Fable 5's job.

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.