Getting Started
Everything you need to get Dalexor running and connected to Claude, Cursor, or Windsurf in under 2 minutes.
⚡ Quick Start — under 2 minutes
Run these four commands and you're done. Your AI assistant will have persistent memory of your codebase.
✓ Restart your AI client. Dalexor tools will appear automatically.
How Dalexor works
Dalexor runs quietly in the background, watching for meaningful changes as you code. It converts those moments into a private history that your AI assistant can search and understand instantly.
Your Machine
Watches your files, measures changes, and prepares context without slowing you down.
Secure History
AI summarizes your changes and stores them in a private, searchable vault.
AI Integration
Brings your project memory directly into Claude, Cursor, or Windsurf.
Key Concepts
Project Snapshots
A snapshot is a saved moment in your project's history. It contains exactly what changed, an AI-written summary of the work, and how it impacts the rest of your code.
Meaningful Changes Only
Dalexor doesn't just record every save. It reads what actually changed — the intent, the new functions, the structural shifts — and decides whether something is worth remembering. Reformatting a file or fixing an indent won't create a snapshot. Adding a new authentication flow will.
How Your Files Connect
As you work, Dalexor builds a live map of how your files depend on each other. When something changes in one place, your AI assistant already knows which other parts of the project are affected — before you even ask.
The Local Assistant
The local tool runs on your machine, watching your files and preparing updates before they are securely sent to your history.
How it helps:
Intelligent File Watching
Dalexor tracks file modifications in real-time. It's smart enough to ignore temporary files, build artifacts (like node_modules), and other noise, so it only focuses on your actual work.
Measuring Importance
Not every save is worth recording. Dalexor analyzes your change to see if it significantly alters the logic, structure, or function of your code before deciding to save a snapshot.
Connecting the Dots
As you work, the system maps out how your files are linked. It detects imports and references across dozens of languages, building a map of your project's architecture automatically.
Smart Updates
If you save a file ten times in a minute while debugging, Dalexor won't create ten separate entries. It waits for your work to settle, then creates one clean, meaningful record.
The Private Cloud
The cloud engine processes your updates, summarizes them with AI, and stores them in your private history vault.
How we handle your data:
Security & Isolation
Every request is locked down. We use industry-standard isolation to ensure that no one — not even our own engineers — can see your project history without your verified access keys.
AI Summarization
When you save code, an AI describes the change in plain English. This summary is what your assistant uses to remember your work — "Refactored login flow for performance" instead of just raw code changes.
Fast Natural Language Search
Your history is indexed so you can ask questions like "Why did we switch to Postgres last month?" and get an answer instantly.
Automatic History Chaining
Every snapshot is automatically linked to the version before it. This means you can trace the evolution of any feature or file from its first line of code to today.
Tool System
The system provides specialized tools that allow your AI assistant to query project information directly from your editor.
Neural Concept Search
What it does: Performs semantic discovery of your code based on intent, not just keywords.
Why it matters: You can search for "how we handle auth" and the system will find the relevant logic even if the files aren't named "auth".
Trace Logic Heritage
What it does: Reconstructs the historical reasoning and design shifts for a specific file or feature.
Why it matters: Instead of raw line diffs, you get a narrative summary of *why* the file evolved the way it did.
Evolution Snapshots
What it does: Lists every major architectural milestone and logical pivot in a file's history.
Why it matters: It provides a clean, searchable "time machine" of the logic, filtering out noise like formatting or minor fixes.
Atomic Diffing
What it does: Shows the exact, high-granularity differences between specific atomic versions of a code unit.
Why it matters: Essential for verifying exact code changes during code reviews or debugging regression issues.
Predict Conflicts
What it does: Warns you if someone else on your team is currently editing the same files or logic.
Why it matters: Prevents merge conflicts before they happen by giving you a "heads up" early.
Map Project Topology
What it does: Builds a visual or structural map of how your files are connected.
Why it matters: Helps your assistant understand the "lay of the land" when joining a new codebase.
Shield (Code Integrity Check)
What it does: Analyzes proposed code changes against your project's historical patterns and architectural rules.
Why it matters: Catches potential regressions, style violations, or architectural deviations before they are committed, acting as an intelligent guardrail.
Prediction (Next Step Suggestion)
What it does: Based on your current task and recent changes, suggests the next logical files to edit, functions to call, or tests to write.
Why it matters: Accelerates development by proactively guiding you through complex codebases and reducing cognitive load.
Global Symbol Provenance
What it does: Finds the absolute source of truth for any function, class, or variable across your entire project history.
Why it matters: Instantly jump to where a logic core is defined, even if it's imported through multiple layers of files.
Seal Project Milestone
What it does: Explicitly marks the current state of your project as a stable, significant milestone.
Why it matters: Forces the AI assistant to remember this specific version as a "fixed point," ideal for comparing before/after major refactors.
How your data flows
First: Local Detection
- You save a file in your editor
- The monitor detects the change
- Sentinel checks the file vs last version
- If changed, it marks the exact differences
- Measures how important the change is
- Detects code connections (imports)
- Adds to local memory buffer
- Sends grouping of changes to the cloud
Next: Cloud Sync
- Updates are sent via a secure connection
- The system confirms your project's identity
- Checks your current storage limits based on your plan
- Ensures your data is completely isolated from other projects
- If you have a private vault, your code is encrypted immediately
- The AI assistant summarizes the intent of your change
- Creates a searchable "memory marker" for the update
- Connects the new snapshot into your project's history chain
- Updates the map of which files depend on each other
Finally: Searching
- AI assistant uses a tool (e.g., search for code)
- Server receives the request
- Checks your access and security
- Runs search in the private history
- Decrypts if needed
- Returns results to the AI
- AI explains the answer to you
Security & Privacy
Your code is yours. Dalexor is built around the principle that developer work is private by default — not an afterthought.
Automatic Secret Protection
Before anything leaves your machine, Dalexor scans for and masks sensitive credentials — API keys, passwords, tokens — so they are never stored in your history. This happens locally, before any network call is made.
Private Vault (Paid Plans)
On Pro and Expert plans, your code history is encrypted before it ever leaves your machine using a private key that only you hold. We store an unreadable version of your data — only your authenticated connection can see the real content.
Total Privacy & Isolation
Every project exists in a completely sealed workspace. No account — not even ours — can access your data. Isolation is enforced at the storage level, not just the application layer.
Fair Usage
Usage limits scale with your plan to ensure a reliable experience for everyone. Higher tiers unlock more frequent syncing, deeper history, and faster query speeds. See our Pricing page for a full comparison.
Quick Start Integration
CLI Commands
Dalexor runs from a simple CLI. Each command has a clear, single purpose.
dx init
Links your local workspace to
a Dalexor project. Run this once in a new directory to get started.
dx watch
Starts passive monitoring.
Runs silently in the background and captures meaningful changes as you work.
dx sync
Scans your entire project at
once. Useful when joining an existing codebase or after a long offline session.
dx chat
Ask questions about your
codebase in plain English, directly from your terminal. Answers are grounded in your
actual project files.
dx restore
Recover lost code by intent.
Describe what you want to bring back (e.g. 'auth logic') and Dalexor finds the best
matching snapshot.
📌 Marking a Milestone
While dx watch is running, press S at any
time to manually mark your current state as a milestone. Dalexor will immediately record
everything in progress and tag it as a significant point in your project's history — useful
before a major merge or release.
Privacy Mode
Available on Pro and Expert plans, Privacy Mode gives you true ownership of your project history.
End-to-End Encryption
With Privacy Mode enabled, your code is encrypted on your own machine before it is ever transmitted. We hold an unreadable copy — only your authenticated session can access the real content. Not us, not anyone else.
Your Key, Your Control
You generate and own the Private Key. Share it with your AI assistant — but Dalexor never stores it. If you rotate or revoke it, your history becomes permanently inaccessible to anyone without the new key.
Advanced Features
Smart Grouping
Dalexor is smart enough to know when you're in the middle of a focused coding session. It won't flood your history with tiny updates while you're rapidly saving. It waits for you to finish a thought, then creates one clean record.
Dependency Recovery
When you create a brand new file, the system instantly links it to any other code in your history that might use it. Your map stays accurate from the very first second.
Recent Priority
Search results are weighted toward your most recent work. This ensures that when you ask questions, the answer is based on how your project looks now, not how it looked six months ago.