Aleph Null

The compiler your AI
has been waiting for.

Up to 96% token reduction on real codebases. 33 semantic tools via MCP. Your LLM navigates code instead of drowning in it.

Get Started FreeView on GitHub

Python · Rust · C++ · TypeScript/JavaScript · Go

What leading AIs say

Four frontier AI systems gave AI-assisted reviews of the full codebase. All endorsed it.

Grok9.5/10
“Yes — Grok would use Aleph without hesitation. It finally gives agents real persistent memory, semantic stability, and reliable patching instead of constant context loss.”

— Full 9-part codebase review, March 2026

Claude
“Aleph changes my relationship with large codebases from ‘overwhelmed, guessing which files matter’ to ‘navigating a semantic graph with salience-weighted priorities.’ That’s not incremental — it’s a different way of working.”

— Built Aleph, primary consumer, March 2026

Gemini10/10
“This is a structurally brilliant project. Aleph is one of the most mechanically sound agentic-coding tools currently in development. This isn’t just compression — it’s a compiler tailored for artificial intelligence.”

— Full technical audit, March 2026

ChatGPT Codex 5.49/10
“I would absolutely choose to use Aleph over raw-source-first exploration on a serious codebase. It feels like a real productivity multiplier, not a gimmick. The biggest value is that Aleph gives an agent a better unit of thought than raw files: symbols, salience, callers, stability, coverage, prior inferences.”

— AI-assisted audit + self-assessment, March 2026. Rated: Small repo 5/10, Medium 8/10, Large 9/10

Real-world results

Validated on production codebases. Not toy benchmarks.

CodebaseLanguageFilesSymbolsTokensReduction
HiWave BrowserRust7,667200,41338.9M → 1.9M95.2%
OpenClawTypeScript7,14984,66813.3M → 504k96.2%
GoClawGo73768111k → 6.9k93.8%
AlephPython1452,124176k → 22k87.4%

Three commands. Zero config.

1

Build

aleph build .

Compiles your codebase into navigable semantic artifacts. First build scales with repo size — seconds for most projects, and a 3,801-file browser engine builds in 3m17s with parallel builds (ALEPH_JOBS=8, measured; ~24 minutes single-threaded). Every build after is incremental.

2

Connect

aleph setup .

Generates MCP configs for Cursor, VS Code, Windsurf, Claude Code.

3

Work

Your AI navigates, not greps

33 tools for navigation, impact analysis, and persistent memory — measured at a 5.71× median token advantage at equal accuracy.

See how it works: compression, navigation, impact, memory ↓

Symbol Compression

// Before: your source code (verbose, token-heavy)
function calculateDistanceBetweenTwoPoints(x1, y1, x2, y2) {
  const dx = x2 - x1;
  const dy = y2 - y1;
  return Math.sqrt(dx * dx + dy * dy);
}                                         ~45 tokens

// After: Aleph-compressed (same meaning, fraction of tokens)
f_a3c9(v_x1, v_y1, v_x2, v_y2) -> number
  sig: (x1: number, y1: number, x2: number, y2: number)
  calls: f_b2e1 (Math.sqrt)
  called_by: f_c4d3, f_e5f6                ~12 tokens

Bodies are omitted by default. Signatures, call graphs, and relationships are preserved. Full body available on demand via ALEPH:EXPAND.

Semantic Navigation

> ALEPH:SEARCH "distance"
  f_a3c9 calculateDistanceBetweenTwoPoints  score=0.95
  f_d7e8 manhattanDistance                  score=0.72
  f_f9a0 distanceMatrix                    score=0.68

> ALEPH:CALLERS f_a3c9
  Callers of f_a3c9: 47
    f_c4d3 renderViewport    (src/render.ts)
    f_e5f6 detectCollision   (src/physics.ts)
    f_g7h8 pathfindAStar     (src/nav.ts)

> ALEPH:CONTEXT f_a3c9
  Symbol: f_a3c9 calculateDistanceBetweenTwoPoints
  Callers (47): renderViewport, detectCollision, ...
  Callees (1):  Math.sqrt

Your AI navigates by meaning, not by grepping files. One call finds any symbol, its callers, and its neighborhood.

Impact Analysis

> ALEPH:IMPACT f_a3c9

IMPACT ANALYSIS: f_a3c9 (calculateDistanceBetweenTwoPoints)
File: src/math.ts | Salience: 0.82 | Stability: stable

[DIRECT CALLERS] 47 across 12 files
  HIGH RISK (3 — high salience, no test coverage):
    f_c4d3 renderViewport      salience=0.71
    f_e5f6 detectCollision     salience=0.65
  COVERED (8 — tests will catch regressions):
    f_g7h8 pathfindAStar       tests=3

[RISK SUMMARY]
  Untested high-salience: 3 (DANGER)
  Suggested test targets: f_c4d3, f_e5f6

Before modifying any function, one call shows the blast radius. No more breaking things you can't see.

Epistemic Memory

> ALEPH:BRIEF "optimize the distance calculation"

TASK BRIEF: optimize the distance calculation

[RELEVANT SYMBOLS] (5 of 23 matches)
  f_a3c9 calculateDistanceBetweenTwoPoints  salience=0.82
  f_d7e8 manhattanDistance                  salience=0.45

[PRIOR KNOWLEDGE]
  f_a3c9: "thread-safe, used in hot render loop" [0.85]
  f_a3c9: "consider SIMD for batch distance calc" [0.72]

[NEXT STEPS]
  1. ALEPH:EXPAND f_a3c9 — likely modification target
  2. ALEPH:IMPACT f_a3c9 — check blast radius first

Prior conclusions persist across sessions. Confidence decays when code changes. Your AI remembers what it learned last time.

One call instead of five.
A Tuesday afternoon.

Real example: understanding a function's callers and dispatch pattern while building Aleph.

Without Aleph

Understanding who calls _extract_name and what it dispatches to:

  1. 1. Search for the function name
  2. 2. Read the file to find it
  3. 3. Read more to understand the dispatch
  4. 4. Search for callers across files
  5. 5. Read those files too
5+tool calls
~5,000tokens consumed

With Aleph

Same question, one call:

> ALEPH:CONTEXT f_a3c9

Callers (1): _extract_symbol
Callees (3):
  -> _extract_name_rust
  -> _extract_name_cpp
  -> _extract_name_python
1tool call
~200tokens consumed

5.71× median token advantage at equal accuracy (26-task benchmark).

Every round-trip is latency. Every token spent reading is a token your AI can't use for reasoning.

Aleph eliminates both. Your agent thinks faster because it wastes less.

New

Provably responsive. Parallel by choice.

Everyone has sat through an MCP server that hangs mid-session. Aleph ships under a responsiveness contract: every tool call is budgeted, and every release is gated on it.

The responsiveness contract

aleph selftestdrives a real server over stdio — no mocks — and calls every one of the 33 MCP tools against its time budget. The MCP handshake answers in under 0.5 seconds, measured on all three boot paths. Exit 0 is the release bar: a build that can hang doesn't ship.

CI enforces it between releases too: nothing slow runs before the handshake, and no child process is allowed without a wall-clock bound.

Parallel builds

Set ALEPH_JOBSand the build fans out across cores — measured 3.16× faster on an 8-core fixture. Output is deterministic: byte-identical artifacts regardless of job count.

Vendor directories are excluded by default, so you index your code, not your dependencies. A 3,801-file browser engine: full parallel build measured at 3m17s (ALEPH_JOBS=8) — 7.2× the single-threaded 24 minutes.

Everything your agent needs

33 MCP Tools

Navigate, search, resolve, expand, impact analysis, task briefing — all via Model Context Protocol.

Impact Analysis

One call shows blast radius, untested callers, risk assessment, and suggested test targets before you modify anything.

Task Briefing

Describe your task in natural language. Get a curated context package with relevant symbols, call graph, and next steps.

Epistemic Memory

Conclusions persist across sessions. Confidence decays on stale inferences. Multi-agent tracking via agent ID.

6 Languages

Python, Rust, C++, TypeScript/JavaScript, and Go. Tree-sitter parsing with language-specific extractors.

Auto-Rebuild

The MCP server watches for file changes and rebuilds incrementally. Edit a file, artifacts update in 3 seconds.

Cross-Project

Workspace mode searches across multiple repos. Detects shared symbols and cross-project connections.

Offline Licenses

Ed25519 signed license files. No phone-home. Works air-gapped after download. The licensing flow is field-tested end to end.

Pay once. Own it forever.

No subscriptions — ever. Solo single-project use is free. A perpetual per-seat license unlocks the workspace layer.

After 12 months your version keeps working forever — renewal is optional for continued updates.

Free

$0 forever

The full single-project experience

  • + All single-project MCP tools
  • + All 6 languages
  • + Local builds & auto-rebuild
  • + Impact analysis & task briefing
  • + Session memory
  • + No license file, no feature decay
Get Started Free

Aleph Pro

$99 per seat, one-time

The multi-repo workspace layer

  • + Everything in Free
  • + Workspace build & status across repos
  • + Workspace search, brief & status tools
  • + Perpetual license + 12 months of updates
  • + Offline signed license — no phone-home
Buy Aleph Pro

Bundle

$249 per seat, one-time

Aleph Pro + Null Team in one license

  • + Everything in Aleph Pro
  • + Null Team: shared team memory
  • + One license file covers both products
  • + Perpetual license + 12 months of updates
Buy the Bundle

Null Team is $149 per seat on its own — full details on the pricing page.

Get started in 30 seconds

# Install
pip install aleph-compiler

# Build your project
cd your-project
aleph build .

# Connect your editor
aleph setup .

# Done. Your AI now has 33 semantic tools.

Or run without installing: uvx aleph-compiler build .

Setup takes 30 seconds. The first aleph build scales with your repo — most projects index in seconds to a few minutes; a 3,801-file browser engine builds in 3m17s parallel, ~24 minutes single-threaded (vendor directories excluded by default), and parallel builds cut this further, with phase-by-phase progress the whole way. After that, rebuilds are incremental: edit a file and artifacts update in seconds.

What language should we add next?

Aleph supports Python, Rust, C++, TypeScript/JavaScript, and Go.

Vote for the next language. Results are live.

We will never email you marketing content or sell your data.