local-first · one binary · written in Zig
the Veil is a desktop app for building software with AI. Unzip the application bundle and run
veil — a native three-pane workspace opens, and you give it a goal. Where most
tools hand the job to a single assistant, this one can split it across a swarm of agents
working the same files in parallel. It ships its own model, so there is no key and no account, and
local conversation state is stored in a data/ folder next to the binary.
Windows · macOS · Linux. Local models or optional cloud AI. Python required for coding tools; some checks also use Node.
Taters
Past 48 tools a tater’s belt is a map it walks with one verb, a long step is folded into a net instead of cut, and each model’s quirks are learned and healed as they show up.
The built-in belt stays listed; Agent Garrett’s catalogue is a map of families and groups. The step’s own words open the right group first, and the words that led to a tool are learned for next time.
/belt auto|map|flat chooses how a tater sees its tools.
A step that outgrows its model’s window keeps the results it rests on and lays the rest out as NEXT, ON DISK, RULED OUT and ESTABLISHED, verbatim. The same net carries into the next iteration.
A model that needs more room gets it first; one that goes silent hands the day to a fallback. A runtime edit that fails to deploy is flagged and can be reverted, and a newer veil’s runtime arrives as a revision.
Taters runtime 11 ran live on a Cloudflare account for 19 iterations: the map walked, Agent Garrett tools called by name, a step folded seven times and finished.
Seen working, on a real account. Three runs, each a tater-tot named Gary given the one-word goal
test at a 5-second pace: 1 of 18 iterations improved on the first; 21 of 49 on the second, which left
24 files of reports and 12 lessons it wrote itself; and on the third the runtime first wrote down
what test means as a checklist, then wrote and ran test_runner.py and reached
6/6 by iteration 11 (3 of 3 tests passing). The excerpt from its events.log is in the
README.
Gary’s 4tope
When a turn has to compact, the engine reads its working log as a dependency graph. The longest path back from the current step is what the work rests on, and it is never pruned. The rest is carried along a shortest-path tree, in the turn’s own words, with no model call and no summary.
The tool tree turns the tool belt into a map the model walks seven branches at a time, so even a small model can use hundreds of tools.
L(v) = max{ L(u) + w(v,u) : u ∈ deps(v) }
One linear pass, because every dependency points at something older. Followed from the current step, it names the results nothing may trim away.
d(v) = min{ d(u) + c(u,v) : u ~ v }, d(f) = 0
Dijkstra from the current step under a byte budget, laid out along the tree so each derivation reads as one run: NEXT, ON DISK, RULED OUT, ESTABLISHED.
One verb, open_tools, seven branches per view. The engine opens the likeliest group before the first call, a tool the model already knows opens its own branch, and the map learns which words lead to which tools.
Opt-in with NL_TOOL_MAP=1. Agent Garrett, plugins and MCP servers attach as branches of their own.
How Gary’s 4tope works The tool tree
Verified end to end on a live turn with a scripted model: the carry was written with no model call, and the turn continued and finished from it.
Agent Garrett
Agent Garrett brings its complete security toolkit to chats, swarms and tater-tots. Deploy it in your Cloudflare account, watch its runtime build, and choose which features use it.
The local NL-Veil harness handles your local evidence. Dedicated Cloudflare Containers handle Gary's cloud commands, files and tasks. No local Docker or separate Linux host is needed.
Live cloud command, shell-list and indicator-extraction calls verified through NL-Veil.
Download
veil.Full bundles include the desktop application and memory engine. Extract the bundle for your platform and run the app; model weights are downloaded separately.
What changed in each version is in its release notes, on the Releases page.
Take the veil-… archive — not “Source code (zip)”, which GitHub staples to every release and which needs a compiler, and not veil-server-…, the headless build for remote boxes with no desktop app.
The model comes too. The inference engine is compiled into the binary, so
the-veil-12b
is served by the server itself — no separate model runtime, no API key. Click download the
model in the app (or run veil model pull) and the whole thing works offline. Point it
at Ollama or any OpenAI-compatible endpoint instead whenever you would rather.
Already on v1.1.3 or later? Finish active work, then use Settings → Updates → App updates → Update & restart. Older versions need a manual installation of the full bundle. Updates and connection guide →
Building it yourself instead — needs Zig 0.16+:
git clone https://github.com/gary23w/nl-veil
cd nl-veil
zig build runArchitecture
The whole engine, laid out the way a request actually moves through it. Every node opens its annotated source document.
Hover a node to light its connections · drag to rearrange · click to read the module. Keyboard: Tab to a node, ←↑↓→ to move it, Enter to open.
Source documents
Generated from the tree and amended as the source moves: the server and its CLI, the server-side chat brain, and the native desktop app. Filter by module, path or file.
A cast, reconstructed
What the engine actually did on one ordinary evening. The chips open the module that did it.
The goal arrives: one line, typed at the desk. The gateway checks the key at the door, and the audit log writes down the knock before anything answers it.
The supervisor detaches a worker. Casts run as separate processes; a cast survives the server that started it, the way a boat survives the dock.
The blueprint is drawn. The goal declares its file tree and every file gets an owner; no mind writes a teammate’s slice. Eleven minds open one shared memory and begin.
A write misses. The failure is recorded with its exact path before anything else happens. The fix comes later; the record comes first.
The miss is written down before the fix. That order is the whole method.Edits from eleven minds meet in one file. Disjoint regions merge on their own. The same region is a conflict, and conflicts are said out loud, never papered over.
The checkpoint is rebuilt from the record: what completed, what’s blocked, what’s pending. No model is asked for its opinion — the ledger already knows.
Out of band, a reviewer reads the round’s real tool trace and mints a lesson into the live hive — only what the trace can ground, nothing a mind merely claimed.
A lesson nobody typed. It came off the trace.The crawler brings back the outside. A fetched fact enters the hive only with a verbatim quote from the page that said it; the rest stays outside where it belongs.
Smoke test. The deliverable is booted and probed, not admired. Passing tests are not a working app; a working app is a working app.
The judge scores the cast. The governor reads the fitness curve, trims what idles, keeps what moves. A plateau is information, not failure.
The score is not the goal. Read the curve.Collection. Files, the event stream, the metered spend, and the record of what was actually verified against what was merely assumed.
No cast is closed until somebody reads the record.
The memory underneath
Every observation any mind makes — a crawled fact, a failure with its path, a judge’s score — lands in one associative store that every other mind can reach. That store is its own project, and it runs without nl-veil.
Separate memories made polite strangers; one shared memory made a swarm. No private notebooks — the crawler’s facts, the builder’s failures and the judge’s scores all land where every mind can reach them.
In the engine: worker/oscillation.zig and worker/neuron/client.zig, both fail-open — if the store is down, the cast keeps running.
A typed-neuron associative store in Rust: recall in milliseconds over a million facts, plasticity that strengthens only what the evidence supports, and a browser build that runs the real core in WASM.
How it is built
Not marketing copy — these are the constraints the code is reviewed against.
It never learns what a goal means; it learns how goals move. The day a use case gets hardcoded into the loop is the day the loop stops deserving the name.
Every mechanism is general. A branch in the engine that knows what it is building is a bug report.
One hive, no private notebooks. Every observation any mind makes lands where every other mind can reach it — and that is measurable, not a slogan.
Tool availability depends on the configured integrations.
Outcome feedback strengthens what exists; it never creates what doesn’t. A win saturates a memory — it does not invent one, and a finished goal never comes back from the dead because a reward said it should.
Plasticity is a privilege of evidence.
A benchmark says the score is high. The smoke test says the app boots. Those are different sentences, and the engine pays the difference on every cast.
Knowing isn’t proof. The ledger records what was verified against what was merely assumed.