AI Context & Memory Engine for Coding Agents
Xanther gives your coding agents deep codebase understanding and persistent session memory — delivering precise architectural context and long-term recall on every tool call via MCP.
Your agents are smart enough. They just need better context.
On mini-swe-agent: Sonnet 4.0 + XCE went from 66% → 73.4% — an older-gen model beating raw Sonnet 4.6 and reaching Opus-level with cascade hybrid at 76.8%
SWE-bench Verified
/instance
Cost per resolved instance
cheaper than frontier
vs Claude 4.5 Opus
fewer tokens per task
Same model, less waste
Measured impact
Up to 50% fewer tokens per task
When your agent gets the right context up front, it stops burning tokens exploring the wrong files. Xanther delivers precise architectural context and cross-session memory — so every run is cheaper, faster, and more accurate.
Fewer tokens
Up to 50% reduction on large repos — less wasted exploration
Lower cost
MiniMax M2.5 + XCE matches frontier at a fraction of the price
Higher accuracy
Sonnet 4.0 + XCE: 66% → 73.4% on SWE-bench Verified
Zero re-learning
Cross-session memory means no re-reading the codebase every session
Measured on indexed open-source repos (httpx, Flask, Django) with mini-swe-agent · results vary by codebase size
Multi-Layer Indexing
Powered by RAFT Data Structure
RAFT (Recursive Abstract Fact Tree) builds a multi-layer knowledge graph from your codebase. Each layer adds richer context — from raw AST nodes up to architectural understanding. When your agent queries, RAFT traverses the right layer for the right answer.
High-level design per module — design patterns, integration points, quality attributes.
Generated once per directory. Gives agents module-level reasoning without reading every file.
~60 nodes
Algorithm descriptions, data flow, error handling, edge cases for each component.
LLM-generated documentation that smaller models can consume instead of reading raw source.
~400 nodes
One-sentence descriptions of each function and class — responsibilities and dependencies.
Fast retrieval layer. Agents scan summaries to decide which code to read in full.
~500 nodes
Every function, class, method, variable, and import — parsed by tree-sitter across 12 languages.
The foundation. Relationships (CALLS, IMPORTS, INHERITS, CONTAINS) are edges in the graph.
~1,800 nodes
Multi-Layer Linking — How RAFT Connects Everything
Vertical Links (L4 → L1)
Architecture nodes link down to component docs, which link to summaries, which link to AST nodes. One query at L4 can drill down to the exact line of code.
Horizontal Links (within layer)
CALLS, IMPORTS, INHERITS edges connect nodes within the same layer. This is how impact analysis traces affected code across the codebase.
Memory Links (XME ↔ XCE)
Past decisions, preferences, and session history from XME connect to code nodes. Your agent recalls what it learned last session about this module.
┌─────────────────────────────────────────────────────────────────┐ │ L4: Architecture ┌──────────┐ │ │ (module-level HLD) │ API Layer│──────┐ │ │ └────┬─────┘ │ │ ├───────────────────────────────┼────────────┼────────────────────┤ │ L3: Deep Docs │ │ │ │ (algorithm, data flow) ┌───▼────┐ ┌────▼───┐ │ │ │ Client │ │ Auth │ │ │ │ .send()│ │ .check│ │ │ └───┬────┘ └────┬───┘ │ ├──────────────────────────────┼────────────┼─────────────────────┤ │ L2: Summaries │ │ │ │ (one-line descriptions) ┌───▼────┐ ┌────▼───┐ │ │ │"Sends │ │"Verify │ │ │ │ HTTP" │ │ creds" │ │ │ └───┬────┘ └────┬───┘ │ ├──────────────────────────────┼────────────┼─────────────────────┤ │ L1: AST Parse │ │ │ │ (functions, classes, ┌───▼────┐ ┌────▼───┐ ┌─────────┐ │ │ methods, imports) │send() │──│verify()│──│httpcore │ │ │ │L:142 │ │L:89 │ │(import) │ │ │ └────────┘ └────────┘ └─────────┘ │ ├─────────────────────────────────────────────────────────────────┤ │ XME: Memory Layer │ │ ┌──────────────┐ ┌───────────────┐ ┌────────────────────┐ │ │ │ Episode: │ │ Fact: "auth │ │ Decision: "Use JWT │ │ │ │ "Fixed bug │ │ uses bcrypt" │ │ over sessions" │ │ │ │ in send()" │ │ confidence: │ │ rationale: "..." │ │ │ │ 2026-08-20 │ │ 0.95 │ │ 2026-08-15 │ │ │ └──────────────┘ └───────────────┘ └────────────────────┘ │ └─────────────────────────────────────────────────────────────────┘
Live Graph — httpx indexed by Xanther
2,392 nodes · 4,213 edges · 12 modules · 4 RAFT layers. Click nodes, filter by layer, zoom to explore.
RAFT Layers
Node Types
2,392 nodes · 4,213 edges · httpx · 100%
Click · Scroll to zoom · Drag to pan
Two engines. One smarter agent.
Context Engine gives your agent expertise. Memory Engine gives it memory.
Context Engine
Deep codebase understanding — your agent gets precise architectural context on every tool call, so it always knows where it is and what matters.
Memory Engine
Persistent memory and cross-session state management — your agent remembers decisions, preferences, and context across conversations.
Persistent memory · XME
Your agent stops forgetting
Every new session, a stateless agent starts from zero — re-reading code, re-proposing rejected ideas, re-explaining your stack. XME gives it long-term memory so progress compounds across days, sessions, and teammates.
Cross-session recall
Pick up a multi-day refactor exactly where you left off. The agent remembers what it explored, what it chose, and what is left — no re-explaining.
Decision tracking
Every architectural choice and rejected approach is logged with its rationale. Ask "why did we do it this way?" months later — the answer is one query away.
No repeated mistakes
Failed approaches are remembered. The agent will not re-suggest the caching layer you already tried and reverted — it learns from your project's history.
Works with your stack
One MCP tool. Every coding agent.
Xanther democratizes your development workflow — operate across any IDE or agent while maintaining persistent context and session state via MCP. No more starting from scratch when you switch tools.
Claude Code
Anthropic
Kiro
AWS
Cursor
Anysphere
OpenCode
CLI Agent
Windsurf
Codeium
+ any MCP-compatible agent, IDE, or CLI tool
Switch IDEs without losing context
Start debugging in Cursor, continue in Claude Code, review in Kiro — Xanther maintains your codebase context and session state across every tool via MCP. Your knowledge graph and memory travel with you.
Add to your MCP config:
{
"mcpServers": {
"xanther": {
"url": "https://mcp.xanther.ai/sse",
"headers": { "Authorization": "Bearer YOUR_API_KEY" }
}
}
}See it in action
Watch XCE index a codebase and deliver architectural context to a coding agent in real time.
Real results on SWE-bench Verified
All on mini-swe-agent: Sonnet 4.0 + XCE 66% → 73.4% — older-gen beating raw Sonnet 4.6, reaching Opus-level at 76.8% with cascade hybrid
MiniMax M2.5 + XCE: 78.2% on SWE-bench Verified — beating Claude Opus at 76.8%, at 16x lower cost
XCE reduces token usage by ~20% per task — fewer wasted steps, less exploration of wrong code paths
SWE-bench Verified
MiniMax M2.5 + XCE
Per Instance
16x cheaper than frontier
Sonnet 4.0 + XCE
Up from 66% → 76.8% cascade hybrid