The agent doesn't knowwhere anything is.
So it reads everything. Every session, your coding agent rediscovers your repository from zero. It greps a name, opens six files, follows a wrong import, reads a test fixture, and eventually finds the function you already knew the path to. You paid for all of it.
Zaguán Blade gives the model a map first. A live index of your codebase — symbols, resolved references, exact byte ranges — so the agent navigates by structure instead of searching by hope.
The Cost of a
Blind Agent
You've watched all of these happen.
- →It reads forty files to change one function, and three of them were vendored.
- →It announces "I've refactored
parseConfigeverywhere" after finding two of the five call sites. - →By the time it edits, the file it needed is forty tool calls back and no longer in context.
- →It fixes the symptom, because it never found the cause.
- →Your weekly limit is gone on Wednesday and you're not sure what you bought.
None of this is the model failing. Frontier models reason about code extremely well — when they can see the right code. The failure happens before the model ever thinks: the tool never told it where to look.
And the standard fix makes it worse. "Give it more context" means pouring the repository into the window: dead paths, compatibility shims, generated files, three versions of the same helper. You haven't made the model smarter. You've asked it to find a needle while you keep adding hay.
A big context window is a capability. It is not a discipline.
Blade Reads Your Code
The Way You Do
Open a project and Blade builds a local index with tree-sitter: every function, method, class, type, component and constant — plus the resolved edges between them. Who calls this. What implements it. What breaks if it changes.
It lives in SQLite on your disk. No embeddings. No cloud. No upload. It updates incrementally as you edit, and it knows about buffers you haven't saved yet.
The Agent Queries Structure
symbol_search
where this is defined, actuallysymbol_references
who calls it — resolved, not text-matchededit_impact
what breaks if I change thisread_file_range
the exact bytes, once it knows which bytes
References, Not Text enforced
Here is the part that matters: those tools return locators, not text. A path, a byte range, a signature. Not the file.
The model reads the exact range it decided it needed — and nothing else lands in context by accident. A build test fails if a bulk result ever embeds a docstring.
Read less, later, with intent.
Evidence In.
Scoped Change Out.
Every Step Visible
- You ask for a change — Plan mode for the investigation first, Code mode to get it done.
- The agent works the index: finds the symbol, checks the references, measures the impact.
- You watch it happen. Not a spinner — the actual tool calls, the actual reasoning.
- A scoped diff appears, per file.
- Accept it, or reject it back to the pre-edit snapshot.
You are not reviewing a diff after the fact. You are watching the investigation that produced it.
Nothing Runs Behind Your Back
Shell commands require your approval before they run. Not a setting you hope defaults correctly — a card in the chat with the command on it.
There's a YOLO mode when you genuinely want it. Per project. Never global.
Git stays the source of truth, with a full panel for staging, commits, branches and AI-written commit messages. Every AI edit is snapshotted before it lands, so reject always has somewhere to go back to.
The Model Is a Setting,
Not a Lock-In
Local
Ollama, Ollama Cloud, or any OpenAI-compatible server — llama.cpp, vLLM, LocalAI. No subscription, no key, no account. Your code stays on your machine.
This is where the index earns its keep hardest. A 20B local model with a precise 4K context is a genuinely useful engineer. The same model handed 100K of repository sludge is a toy.
Hosted
One Zaguán AI subscription, every frontier model — Claude, GPT, Gemini, Kimi, MiniMax, Qwen — routed through the Zaguán Coder Daemon. Switch models mid-conversation.
The daemon is the brain: orchestration, tool execution and prompt discipline live there, so the editor stays a fast, native shell rather than a place where your CPU goes to die.
Your Conventions Come With You
AGENTS.md is read as workspace instructions — root file, nested files, and local Markdown includes.
Agent Skills (SKILL.md) work from your repo and your home directory — and the catalog stays out of the prompt. The model searches a compact index and loads one skill body when it actually needs it, inside a measured token budget.
No telemetry. Conversations can stay in .zblade/ inside your project, and .gitignored files are excluded from AI context by default.
"I Already Have
a CLI Agent."
Fair. Keep using it — this isn't an argument about which model is smarter. It's about what the model can see before it starts.
A CLI agent explores your repository with grep, glob and file reads, from scratch, every session. That's a reasonable design for a tool that has to work in any directory on any machine with no setup. It also means the first several minutes of every task are spent rebuilding knowledge that was already thrown away.
Blade keeps that knowledge. The index persists, updates incrementally as you edit, and knows unsaved buffers. The agent starts oriented.
The rest follows from being an environment instead of a terminal. You see the diff in a real editor before you accept it. You capture a window, annotate the screenshot, and show the model the broken UI instead of describing it in prose. You have a Git panel, a terminal, a PDF viewer, rendered Markdown — because sometimes the fastest way to help the model is to look at the thing yourself.
And if you love the terminal, say so. Blade is a desktop app. That's a real trade. It buys you a persistent index, visible investigation, and per-file review. If that trade isn't worth it to you, the honest answer is that it isn't.
Built on Ugly Repos,
Not Demos
Firefox 469,627 files
C++, Rust, JavaScript, thirty years of history, generated files, deliberately malformed web-platform-tests, and YAML containing build-time placeholders that aren't legal YAML.
It indexes clean in about thirty minutes and produced 5.16 million symbols — on a spinning disk over USB. Getting there meant fixing three latent crashes and a checkpoint stall no benchmark repo would ever have surfaced.
And Everything Else
The Linux kernel. 77,000 files, bounded memory, no special-casing.
Blade itself. Zaguán Blade and the Coder Daemon have been built with Zaguán Blade since it could edit its own source. Six months, daily. Every rough edge you'd hit, I hit first.
The stack. Rust and Tauri v2 for the editor, Go for the daemon, Gitoxide for Git. No Electron — Blade idles at a few hundred megabytes, not a few gigabytes.
This Is Not for You If
- →You want a VSCode clone with a marketplace. Blade has no extension ecosystem and won't get one soon.
- →You want an agent that runs unattended for an hour and opens a PR. Blade is built to be watched.
- →You want a prompt to generate a whole app. Blade is for repositories that already exist and already matter.
This Is for You If
- →You run agents on real codebases and you've stopped trusting diffs you didn't watch get made.
- →You think a model call should have to earn its cost.
- →You'd rather the tool understand your code than hope the model guesses right.