Why Your AI Coding Assistant Keeps Making Stuff Up (And How to Fix It)

Let's be honest: you've caught your AI coding assistant lying to you.

Not maliciously, of course. These tools aren't trying to deceive you. But when you're deep in a complex refactor and your agent confidently creates a function that doesn't exist, imports a package you've never installed, or completely ignores yesterday's architectural decision that took your team three hours to agree on—that's hallucination. And it's costing you real time.

The Context Compaction Problem

Here's what's happening: AI coding agents work from compressed context windows. When memory gets tight, the model falls back to training data patterns rather than your actual codebase. It writes code that looks plausible but doesn't fit your architecture. It suggests imports for packages that don't exist in your package.json. It implements patterns that were appropriate for some other project—because that's what the training data showed it.

This isn't a minor inconvenience. On large codebases, agents waste enormous amounts of tokens reading the wrong files, chasing dead ends, and writing code that breaks your existing patterns. You're essentially paying for two jobs: the agent trying to understand your code, and you cleaning up its misunderstandings.

Enter Sverklo: Repo Memory for AI Agents

Sverklo is a local-first MCP server that gives your coding agent actual memory of your repository. It runs entirely on your laptop, requires no API keys, and exposes 37 specialized tools that your agent can call before touching your code.

Think of it as giving your AI assistant a detailed briefing document that updates automatically every time your codebase changes. When your agent needs to understand a function, it can look up the actual definition with file and line number. When it wants to verify a symbol exists, it gets caller context. When it references a past design decision, it knows exactly which git commit that decision was made at.

The magic is in the architecture. Sverklo doesn't just search for strings—it understands your code at the symbol level. It knows which functions call which other functions, which variables are in scope where, and how changes cascade through your codebase.

Hybrid Search That Actually Works

Sverklo combines three search strategies: BM25 for exact text matches, ONNX embeddings for semantic understanding, and PageRank for relevance. This isn't marketing speak—it means your agent can find code even when it doesn't know the exact terminology your team uses.

If someone on your team called a function computeAuthToken instead of generateAuthToken, a traditional search would miss it. Sverklo's semantic layer understands these are related and surfaces the right code anyway.

Bi-Temporal Memory: Your Time Machine for Decisions

This is where things get genuinely interesting. Sverklo timestamps every memory against your git history. Each memory carries a valid_from_sha and valid_until_sha—when those values change, the system doesn't overwrite history, it creates a new row and links to the superseded version.

This means you can ask "what did this team believe about the auth flow at commit abc123?" and get a real answer. When your agent reads a design decision from three weeks ago, it knows exactly which version of that decision was current at that point in time.

This is critically important for teams working on long-lived codebases. Design decisions made in January might have been wrong by March, but your agent doesn't know that. Sverklo does.

The Offline Reality

Here's what most tools don't tell you: after the initial 90MB model download, Sverklo never makes another network call. Indexing, search, embeddings, memory, dashboard—all run locally. Your code never leaves your laptop.

For companies worried about IP exposure, this matters. Your proprietary code, your internal patterns, your architectural decisions—all stay on your hardware. There's no telemetry by default, and it's opt-in even when enabled.

When to Use This (And When Not To)

Sverklo earns its place on large, interconnected codebases where context matters. If you're working on a 30-file project, grep is faster and more reliable. The investment only pays off when your codebase is complex enough that your agent regularly reads the wrong files or forgets important context.

If you're debugging a complex refactor, working on cross-repository dependencies, or maintaining a codebase where design decisions evolve over time—Sverklo is worth the setup.

The Bigger Picture

What excites me most about tools like Sverklo isn't any single feature—it's the shift toward local-first AI infrastructure. We've spent years building cloud-dependent AI tools that promise convenience but deliver risk. Local inference, local indexing, local context retrieval—these aren't just technical choices, they're philosophical ones. They say: "your code is yours, and your tools should respect that."

If you're running Claude Code, Cursor, Windsurf, or any MCP-compatible client, Sverklo is worth a look. It's MIT licensed, free forever, and the setup is as simple as npm install -g sverklo followed by sverklo init.

Give your AI coding assistant real memory. Stop letting it hallucinate.