The ProblemWhat It RemembersTriggersKnowledge GraphHow It WorksLive ExampleCompareFAQGitHub
Engineering Memory

AI forgets.
Operator X02 remembers.

Traditional AI coding assistants start over every conversation. Operator X02 continuously builds an understanding of your engineering project — its architecture, its hardware, its history, and the reasons behind every decision.

Download Free See what it remembers

Memory is not about storing conversations.Memory is about understanding engineering.

Two hundred and eighty days

Every engineer has lived this story.

Nothing here is about AI. It is about what happens to a project when the person who understood it walks out the door.

Day 1 · 09:02
One engineer, one repository, one clear idea.

A long-range wireless sensor gateway. The radio driver goes in first. Everything about the design lives in one person's head, and that is fine — the project is four files old.

git init · sensor-gateway · first commit
Engineering Memory
172+ Triggers
Architecture Memory
Hardware Memory
Decision Memory
VCS Aware
~15ms Recall
100% Local
The problem

Every morning, you start from zero.

Not because the AI is weak. Because it has no memory of the system you spent two years building.

Today · 09:14
  • Open the AI chat
  • Explain the project
  • Paste the architecture
  • Upload six files for context
  • Finally ask the question
  • Get a good answer
  • Close the IDE
8 hours later
Tomorrow · 09:11
  • Open the AI chat
  • Explain the project
  • Paste the architecture
  • Upload six files for context
  • Finally ask the question
  • "What's this codebase again?"
  • Everything you taught it is gone
AI forgot everything.

Cursor has a context window. Copilot works inside the current session. Continue.dev needs you to index. None of them remember why the UART clock is initialised before the DMA.

What it remembers

Thirteen layers between the AI and your source code.

"∞ memory" means nothing. This is the actual stack — every layer is captured locally, indexed, and injected when it becomes relevant.

▲ AI Reasoning Layer reads down through every layer below
Engineering Memory
Project knowledge
folder graph · 412 files · 3 modules
Architecture
layer boundaries · IPC contracts
Requirements
what the system must do, and why
Design decisions
"we dropped RTOS in sprint 4 because…"
Coding style
tabs, naming, error handling, your idioms
Build system
Gradle · CMake · nvcc · Tauri targets
Documentation
README, datasheets, register maps
Dependencies
versions, pins, and what broke last time
Hardware targets
ESP32-S3 · STM32F4 · SX1276
Deployment history
what shipped, where, and when
Git / SVN history
commits, diffs, working-copy state
Conversation history
every question you already answered
User preferences
how you like to be answered
▼ Source Code where every other AI IDE starts and stops
Now the numbers mean something

Thirteen layers. One hundred and seventy-two ways in.

Memory you cannot reach is just storage. These are the phrases X02 watches for — when one appears in your question, the matching layer is pulled in before the model answers.

172+
Recall triggers
phrase patterns that map a question
to a memory layer
~15ms
Local search
full history scan, on your disk,
before the prompt is sent
100%
Local
nothing indexed in a cloud,
nothing to leak, nothing to cancel
A sample of the trigger table · green ones no other IDE watches for
Timewhen it happened
yesterdaylast weeklast monthtwo sprints agobefore the releasesince the last commit
Codewhat it is called
function nameclass namefile namemodulesymbolthat helper we wrote
Engineeringwhy it exists
requirement IDticketdesign decisiontrade-offdesign reviewwhy did we
Hardwarewhere it runs
boardGPIOUARTSPICANbaud ratepinrev C
Build & shiphow it got there
build errorcompiler flagtoolchaindeploy targetlast flashthat regression
…and roughly 140 more. Matched locally, in Rust, on every message you send. Nothing leaves the machine.Recall time measured on a local SSD; it scales with your disk and history size, not with a network.
The engineering knowledge graph

Your project is not a folder. It is a graph.

One real project — a LoRa sensor gateway — as X02 holds it. The AI does not read your source code. It reads everything your source code is connected to.

↔ scroll to explore the graph

AI REASONING MEMORY GRAPHlocal · indexed · permanent RequirementREQ-114 · 30-day batteryArchitectureapp / hal / radioSource codelora_drv.c · sensor_drv.cHardwareESP32-S3 · SX1276 · STM32BuildCMake · idf.py · flashGit historya3f19c2 · 7c1e4abDesign review14 Mar · UART vs SPIDeploymentv0.9.4 → 3 boards

Ask about the UART fix and the graph returns the commit, the review that preceded it, the board it runs on, and the requirement it satisfies. Not because they contain the word "UART" — because they are connected to it.

How it works

Memory, in the editor.

Ask a question in plain English. X02 detects the reference, searches local history in ~15ms, pulls in VCS state, and injects it before the model ever sees your prompt. You never see the plumbing.

🧠

Engineering memory that saves full context across sessions, makes smarter decisions on large codebases, and scales to massive projects.

⚡AI Code IDE - OperatorX02 BETA
─
☐
✕
☰FileProjectView▶ RunPluginGit▶ npm (Node.js) · 4 scripts
Files
Terminal
Search
SVN
📁 MY-AUTH-PROJECT
AllStructMinimalCode
📁src
📄  auth.tsM416B
📄  main.tsM235B
📄  api.tsA189B
📄  utils.ts97B
📁components
📄  Login.tsx364B
📄  Dashboard.tsx512B
📦package.json698B
📋tsconfig.json611B
◆ auth.ts (416)×
◆ main.ts (235)
C: > Users > dev > projects > my-auth-project
1import { jwtDecode } from'jwt-decode'
2import'./auth.css'
3
4export classAuthService {
5  private token: string | null = null
6
7  // Fixed: auto-refresh before expiry
8  asyncrefreshToken() {
9    const decoded = jwtDecode(this.token!)
10    if (decoded.exp * 1000 < Date.now()) {
11      this.token = awaitthis.fetchNew()
12    }
13  }
14
15  asynclogin(email: string) {
16    const res = awaitfetch('/api/auth')
💬
📝
📊
⚙️
Operator X02
▾ 29 earlier messages
What did we fix yesterday in auth?
🔍Trigger: "yesterday" + "fix"
🧠History: 3 matches · 15ms
🔄SVN: 2 modified files
⚡Context injected: 2,335 chars
12:23 PM Operator X02
🧠 Memory🔄 SVN
Yesterday we fixed the JWT token expiry bug in auth.ts. The token wasn't auto-refreshing before expiry, causing logout loops.

I see auth.ts and main.ts modified in SVN — the fix is in place. Ready to commit.
Generate commit message
12:23 PM Operator X02
🔄 SVN
fix(auth): resolve JWT refresh loop on token expiry
Ask me anything...
✨
➤
<>
🔍
📎
📷
📄
🔗
⎇ main
TypeScript
Ln 9, Col 12
UTF-8
Spaces: 2
🟢 OperatorX02 Beta Released! NEW
How Engineering Memory Works
💬
User Message
"What did we fix yesterday?"
🔍
172+ Triggers
Auto-detect past references
🧠
History Search
~15ms local search
🔄
VCS Context
SVN/Git status + diffs
⚡
Context Inject
Invisible to user
✨
AI Response
Context-aware answer
User sees clean messages · AI receives full context with history + VCS data · 100% local, no cloud
💾

Saves Full Context

Every conversation, every decision, every bug fix — stored locally and searchable. Ask "why did we change this?" and AI finds the exact conversation from weeks ago. No cloud. No token limits.

172+Trigger patterns
∞History depth
~15msSearch speed
🎯

Better Decisions

With full project history, AI understands why code exists — not just what it does. It knows your architecture patterns, past trade-offs, and team conventions.

🔄 Session 1"Here's a generic auth implementation..."
🧠 Session 47"Based on your JWT refresh pattern, here's a fix that matches your existing auth flow..."
📁

Scales to Big Projects

Large codebases with hundreds of files need AI that understands the full picture. Operator X02 injects project structure, file relationships, and VCS status — so it never suggests changes that break other parts.

Multi-fileAwareness
VCSIntegration
LocalStorage only
Live example

"Where is UART initialised?"

One question. Two very different answers.

A typical AI IDE
Where is UART initialised?

It greps the open buffer, finds HAL_UART_Init in whatever file you happen to have focused, and answers from that alone.

It does not know there are three call sites. It does not know one of them was added to fix a boot race. It has never seen your board file.

Operator X02 · engineering memory
Where is UART initialised?
Source
uart.c:88 → HAL_UART_Init()called from board.cpp:41 during early bring-up
Driver
STM32 HAL, USART2 @ 115200 8N1clock enabled before DMA, on purpose
Architecture
Sits under the hal/ boundary — the app layer never touches it directly
Commit
a3f19c2 — "fix: UART clock init before DMA"you wrote it 6 weeks ago
Discussion
You and the AI debugged a boot race here on 12 May"the DMA request fired before the peripheral clock was up"
Hardware
Wired to the ESP32-S3 bridge on the same boardchanging the baud rate breaks the IoT link
Deployment
Shipped in v0.9.4 to 3 boards on the bench
The question no other AI IDE can answer
"Why did we choose UART instead of SPI, eight months ago?"
Design review
12 Sep — SPI rejected, chip-select routing conflicts with the radio
Performance test
SPI 4 MHz vs UART 115200 — bandwidth was never the constraint
Commit
b91d02f — "revert to UART, see review 12 Sep"
Architecture
The HAL boundary already had a UART transport. SPI would have needed a second one.
Recommendation
Do not revisit unless the radio moves off CS0

Nothing in that answer is in your source code. It is in a review, a benchmark, a commit message and a conversation — four artifacts, three tools, eight months apart. A context window cannot reach them. A vector index does not know they are the same decision. This is what an engineering memory is for.

That's not chat history.  That's engineering memory.

Memory over time

It doesn't ship smart. It gets smart.

The first answer is average. The four-hundredth answer knows your board better than the new hire does.

Day 1
Project imported
File graph, languages and build targets indexed locally.
Day 5
Architecture learned
Module boundaries and which layer is allowed to call which.
Day 12
Style learned
Your naming, your error handling, your idea of a clean diff.
Day 30
Hardware learned
Which pin, which bus, which board, and what breaks when it changes.
Day 90
Engineering expert
It answers with the reasons, not just the lines. It cites your own commits.

Illustrative. Memory grows with use, not on a schedule — a project touched twice a week gets there sooner than one touched twice a year.

Memory capability

Not a criticism. A category.

Every tool below is excellent at what it was built for. None of them were built to remember an engineering system.

Memory capabilities compared: a typical AI IDE versus Operator X02
Memory capabilityTypical AI IDEOperator X02
Current file✓✓
Current conversation✓✓
Multiple files at onceLimited✓
Project architectureLimited✓
Build history✕✓
Hardware configuration✕✓
Engineering decisions & trade-offsCurrent chat only✓ Permanent
Version-control state & diffsPlugin✓
Long-term engineering memory✕✓
Stored where?Cloud✓ On your machine
Why it matters

No vectors. No embeddings. Just this.

What persistent engineering memory actually buys you, in the order you will notice it.

✓

Never explain your project twiceThe context you typed on Monday is still there on Friday.

✓

The AI remembers your architectureIt stops suggesting edits that cross a boundary you drew.

✓

It understands previous fixesAsk "why is it written like this?" and get the real reason.

✓

It remembers hardware connectionsChange the baud rate and it warns you about the ESP32 bridge.

✓

It learns your engineering conventionsMISRA rules, naming, error handling — matched, not guessed.

✓

It recalls deployment historyWhat shipped, to which board, and what happened after.

Open Source

Your IDE, Your Rules

Fork it. Modify it. Make it yours. No restrictions.

🔓

Fully Open Source

Complete source on GitHub. MIT license. Use, modify, distribute.

🎨

Full Customization

Change the UI, add features, modify AI prompts. Every line is yours.

🤝

Community Driven

Built by devs, for devs. Contribute features, shape the roadmap.

🔧

Self-Hostable

Run your own instance. Deploy for your team. Full control.

Fine-tune every AI provider for every task. Your matrix. Your rules. Total control over how each model performs.

⚙️Provider Calibration✕
📊 Matrix
📋 Summary
🕐 History
⚙️ Settings
High (70%+)
Medium (40-69%)
Low (<40%)
Disabled
Override
Provider
<>CODE
🔧FIX
📖DOCS
⚡QUICK
🧠THINK
✍️WRITE
👁️VISION
🌐LANG
📝SUM
💬CHAT
⚡ OPERATOR X02
50%
50%
50%
50%
20%
20%
OVERRIDE
20%
20%
20%
🔥 GROQ
20%
20%
20%
50%
20%
20%
OVERRIDE
50%
50%
20%
✨ GEMINI
20%
20%
20%
20%
20%
50%
50%
20%
50%
50%
🔵 DEEPSEEK
50%
50%
50%
20%
50%
20%
OVERRIDE
20%
20%
20%
🟠 CLAUDE
50%
50%
20%
20%
50%
50%
50%
20%
50%
50%
🟢 OPENAI
50%
50%
20%
20%
20%
50%
50%
20%
50%
50%
🗑 Reset All
⬆ Export
Done
6+
AI Providers
More Coming Soon
10
Task Types
60
Calibration Points
Questions engineers actually ask

Before you download.

The honest answers, including the ones that are not pure marketing.

Does my code or project history ever leave my machine?
Memory is stored and searched entirely on your disk. Nothing is uploaded, indexed, or retained in a cloud.

To be precise, because it matters: when you ask a question, X02 injects the relevant memory into the prompt that goes to whichever AI provider you configured — the same text you would otherwise have pasted by hand. Point it at a local model and nothing leaves the machine at all.
How is this different from RAG or a vector index?
A vector index retrieves text that looks like your question. Engineering memory retrieves artifacts that are connected to it — the commit, the review that preceded it, the board it runs on, the requirement it satisfies.

No embeddings. No similarity threshold. The relationships are recorded as you work, and matched by trigger phrases in Rust, locally, before the prompt is sent.
Where is the memory stored? Can I delete it?
In a plain local store inside your project folder. You can inspect it, back it up with the rest of the project, or delete it. There is no account, no server-side copy, and nothing to cancel.
Does it work with Git and SVN?
Both. X02 reads working-copy state and diffs directly — modified, added, last commit, last revision — so the AI knows what changed since you last asked. No plugin required.
Is ~15 ms realistic on a large project?
Recall is a local scan, so it scales with your disk and the size of your history rather than with a network round trip. Expect single-digit to low-tens of milliseconds on an SSD. Your numbers will differ.

The claim that matters is not the number — it is when it happens: before the prompt is sent, not after the model has already answered without context.
What does it cost, and which platforms?
Free. MIT licensed. Windows and Linux. Memory, history and search are part of the open core — no account, no telemetry, no paid memory tier.

Still unsure? Open an issue or ask on GitHub Discussions.

Code can be regenerated.Engineering knowledge cannot.

Operator X02 remembers both.
It understands your project, and grows with it.

Free forever. MIT licensed. Every byte of memory stays on your machine — no account, no telemetry, no cloud lock-in.

⬇ Download Free View on GitHub Watch the demo
✓ MIT License · ✓ Windows & Linux · ✓ 100% offline capable · ✓ Memory never leaves your disk