Your codebase already knows everything. It just can't talk yet.

“What is it? I think it's some kind of offline online context engine vector temporal quantum something or other.”

terminal

Request Alpha Access See What It Does

See it in action

Listen: AETHER gives your codebase a voice

0:00

What is it?

Robert says

"I think it's some kind of offline online context engine vector temporal quantum something or other."

Technical reality

AETHER generates Semantic Intent Records for every symbol in your codebase — structured descriptions of what functions actually do, their side effects, edge cases, and dependencies. These persist across sessions, update incrementally, and version with your git history.

Robert says

"I don't get these coding languages, I would just call that a bird"

Technical reality

Tree-sitter AST parsing across Rust, TypeScript/JavaScript, and Python. Your React app, your CLI tool, your API server — same pipeline.

Robert says

"I think there's an MCP server in there"

Technical reality

20+ structured MCP tools with typed schemas. Your AI agent doesn't just see code — it understands intent, risk, and blast radius.

AETHER's semantic intelligence architecture

“Look, you want databases? I think I've got at least three.”

Features

"I've got at least three databases"

SurrealDB for the structural graph. SQLite for metadata and vectors. LanceDB as a vector backend option. They talk to each other.

"I've got your front end right here"

Web dashboard with 15+ pages. D3 visualizations. Health scoring. Drift timelines. Coupling heatmaps. Blast radius explorer.

"I'm making them DBs clap"

Three-pass quality pipeline: flash scan → enriched triage → premium deep analysis. Gemini Embedding 2 with asymmetric task types.

"It works on your React stuff too"

Parses Rust, TypeScript/JavaScript, and Python. Point it at your Next.js project and find out which components are actually dangerous.

"Something about graphs"

Structural dependency graph with CALLS, TYPE_REF, and IMPLEMENTS edges. Louvain community detection. PageRank centrality scoring.

"I broke it up into little packages"

17 crates with clear single responsibilities. ~136K lines of Rust. 327 commits. 109 merged PRs. Built by one person.

“I think there's an MCP server in there somewhere”

MCP Tools

20 tools. Your AI agent doesn't just see code — it understands intent, risk, and what breaks if you touch something.

Core Intelligence

aether_search

Hybrid lexical + semantic search across your entire codebase

aether_symbol_lookup

Find any symbol by name, path, or pattern

aether_explain

Get a plain-English explanation of what a symbol does

aether_get_sir

Pull the full Semantic Intent Record — purpose, side effects, edge cases

aether_why_changed

See how a symbol's meaning evolved between commits

aether_symbol_timeline

Full version history with git linkage

Project Memory

aether_remember

Store architectural decisions, gotchas, context — with deduplication

aether_recall

Search everything you've stored

aether_session_note

Quick context capture during coding sessions

aether_ask

Unified search across code intelligence + notes + history

Analysis & Risk

aether_blast_radius

"What breaks if I change this?" — multi-signal coupling analysis

aether_health

Composite health scoring: structural + git + semantic dimensions

aether_drift_report

Detect when code meaning silently changed

aether_acknowledge_drift

Mark known drift as intentional

aether_trace_cause

Root cause tracing through causal change chains

aether_test_intents

Which tests actually guard this symbol?

aether_call_chain

Trace outgoing call chains N levels deep

aether_dependencies

Show who calls this and what it depends on

aether_verify

Run configured verification commands with structured results

aether_status

Workspace health check — symbol count, SIR coverage, provider info

The full walkthrough

1 / 23

“Or just use the command line like a normal person”

CLI

Getting Started

terminal

$ cargo install aetherd
$ cd your-project && aetherd --index-once
$ aetherd search "what handles authentication?"

Search & Query

terminal

$ aetherd search "payment validation" --search-mode hybrid --limit 10
$ aetherd ask "how does pub/sub work in this codebase?"
$ aetherd recall "why we chose SurrealDB"

Project Memory

terminal

$ aetherd remember "Chose SurrealDB over Neo4j — embedded, no external process"
$ aetherd recall "database decision"
$ aetherd notes --limit 20

Analysis

terminal

$ aetherd blast-radius src/payments/processor.rs
$ aetherd drift-report --window "50 commits" --min-drift 0.15
$ aetherd health
$ aetherd trace-cause process_payment --depth 4
$ aetherd communities --format table
$ aetherd coupling-report

Server Modes

terminal

$ aetherd --workspace .                    # Index + watch (daemon)
$ aetherd --workspace . --lsp --index      # LSP with background indexing
$ aether-query serve --index-path .        # MCP-over-HTTP query server

Every command, explained

1 / 15

“Hover over anything. I dare you.”

Editor Integration

AETHER plugs into VS Code via LSP. Mouse over any symbol and see what your editor has been hiding from you.

processor.rs — src/payments

validate_payment_amount

src/payments/processor.rs

Purpose:

Validates transaction amounts against account limits and available balance. Returns typed error for each failure mode.

Side Effects:

Logs to audit trail on rejection

Edge Cases:

Zero amount → InvalidAmount, negative → InvalidAmount, exceeds balance → InsufficientFunds, overflow → AmountOverflow

Health:

78/100| Drift: None

Test Coverage:

5/7 edge cases guarded

Coupled with:

src/payments/gateway.rs (0.87)

Project Note:

“Chose rust_decimal over f64 — precision requirement from Payment Gateway v2 spec”3 weeks ago

What your editor actually shows you

1 / 13

Intent, not just types

See what a function means, not just its signature

Risk at a glance

Health scores, drift warnings, and test coverage gaps right in the tooltip

Memory built in

Relevant project decisions and coupling data surface automatically

Two lists. One tool.

Whether you actually know what you're doing or you're just vibing with AI, AETHER has you covered.

If You're a Programmer

1
Know what every function actually does
SIRs describe intent, not just signatures
2
Find code by meaning, not names
"what validates payments" works even if the function is called check_amt
3
See what breaks before you break it
Blast radius analysis before every refactor
4
Detect silent drift
When someone changes what a function does without changing its name
5
Trace root causes through the graph
Not just "what changed" but "what caused the change"
6
Health-score your codebase
Structural + git + semantic dimensions, not just line counts
7
Community detection on real dependencies
Louvain clustering on TYPE_REF + CALLS edges, not file proximity
8
Version your intent, not just your code
SIRs version with git history
9
Run it offline
Ollama + local models, no cloud required
10
Give your AI agent actual context
20 MCP tools, not just "here's a file"

If You're a Vibe Coder

1
Ask it what your code does
Because honestly, do you even know?
2
Find that one function
You know, the one that does the thing with the stuff
3
Check if you're about to break everything
Before your AI breaks it for you
4
Remember decisions you made at 2am
Project memory persists across sessions
5
Explain your code to your code
Let AETHER be the one who understands it
6
Get a health report
Like a doctor's visit for your repo
7
See the dependency spaghetti
Graph visualization of what calls what
8
Track when AI changed your function's meaning
Because it will
9
Works with Rust, TypeScript, Python
Whatever your AI is generating today
10
Three commands to start
cargo install, index, search. That's it.

It analyzed itself. Then it fixed itself.

The Problem

aether-store/src/lib.rs — 6,817 lines. AETHER flagged it as a God File. Health score: 42/100.

The Experiment

Same LLM (OpenAI Codex) given the same refactoring task twice.

Aspect	Blind (no AETHER)	With AETHER
Modules proposed	15	13
Grouping basis	Name similarity	Proven dependency clusters
Evidence used	Just the source code	TYPE_REF edges + community detection + SIR intents

The Result

0 → 0

lines (façade)

1 → 0

focused modules

RESOLVED

God File archetype

Zero public API changesAll tests pass

Refactoring Plan Quality — Tested Across 5 File Refactors

Each tool was given the same refactoring task and scored on plan quality (1–10).

6.0

Gemini

8.0

ChatGPT 5.4 Xhigh

9.25

ChatGPT 5.4 Xhigh + AETHER MCP

“AETHER then re-scanned itself and confirmed the improvement. The tool that diagnosed the problem validated the fix.”

Comparisons

“How it compares”

Capability	AETHER	grep/ripgrep	GitHub Copilot	RAG tools
Knows function intent	Per-symbol, persistent	✗	Session only	Chunk-level
Tracks side effects	In every SIR	✗	✗	✗
Detects semantic drift	Automatic	✗	✗	✗
Works offline	Ollama + local everything	✓	✗	Depends
Graph relationships	TYPE_REF, CALLS, IMPLEMENTS	✗	✗	Basic
Health scoring	Structural + git + semantic	✗	✗	✗
Survives restart	Fully persistent	✓	✗	Partial

Things AETHER does that literally no other tool does

Not “does better.” Does at all.

Semantic Intent Records

Every symbol gets a structured description of WHY it exists: purpose, side effects, edge cases, dependencies. Not comments. Not docstrings. AI-generated, cross-symbol-enriched, versioned intelligence.

Closed-loop self-analysis

AETHER can analyze its own codebase, diagnose problems, guide the fix, and verify the result. No other tool validates its own recommendations.

Three-pass quality pipeline

Flash scan for speed, enriched triage with cross-symbol context, premium deep analysis for critical symbols. The enrichment pass is the secret weapon — context matters more than model size.

TYPE_REF structural edges

Not just "who calls who" but "which functions use which types as parameters and returns." This is what makes community detection actually work on real code.

Asymmetric embeddings

Documents and queries are embedded differently using Gemini Embedding 2's native task types. Code goes in as RETRIEVAL_DOCUMENT, searches come in as CODE_RETRIEVAL_QUERY.

Graph-aware community detection

Louvain clustering on real structural edges (CALLS + TYPE_REF + IMPLEMENTS), not filename proximity or directory structure. Identifies natural module boundaries your code is already organizing around.

Semantic drift detection

Automatically detects when a function's behavior changed but its name didn't. The silent killer of codebase understanding.

Causal chain tracing

Not just "what changed" but "what caused the change" traced through the dependency graph across commits.

Intent versioning

SIRs version with your git history. See how a function's purpose evolved over time, not just its code.

I need people to break this thing.

Request early access. Got a repo? Even better — drop the URL and we'll prioritize your codebase.

AETHER: Persistent Semantic Intelligence for Code

Three commands. That's it. (Coming soon.)

terminal

$ cargo install aetherd
$ cd your-project && aetherd --index-once
$ aetherd search "what handles authentication?"

AETHER is in private alpha. These commands will work when we ship. For now — request early access and we'll set you up personally.

Request Alpha Access