Patch engine, not rewrite engine
Your AI still rewrites the whole file to change one line. Venkai doesn't.
Every model you already pay for — Claude, GPT, Copilot, local — burns tokens re-emitting code that didn't change. Venkai turns "rewrite the function" into a 2-line patch: same model, same subscription, a fraction of the tokens.
- output tokens vs. rewriting the symbol
- −95.9%output tokens vs. rewriting the symbol
- applied edits, 25-task corpus
- 100%applied edits, 25-task corpus
- wall clock, local, no network
- 1.04swall clock, local, no network
$ python benchmarks/see_bench.py --limit 25 · measured 2026-08-03 · output tokens only, input context excluded
The problem
A model can't say "change that one line" — so it rewrites everything around it.
Same story whether it's you alone hitting your Claude quota at 11pm, or a thousand-seat engineering org watching its agent spend triple. The model doesn't have a name for the six tokens that actually need to change, so it re-emits the whole function — or file — and hopes nothing else moved.
Instruction given to the model
“The timeout in fetch_manifest is too short for large manifests — make it 30 seconds.”
One character changes. Here is what the model has to emit in each case.
def fetch_manifest(url: str, retries: int = 3) -> dict: """Fetch the remote manifest and validate it.""" session = _session_for(url) last_err = None for attempt in range(retries): try: resp = session.get(url, timeout=30) resp.raise_for_status() except RequestException as err: last_err = err time.sleep(backoff(attempt)) continue data = resp.json() if not isinstance(data, dict): raise ManifestError(f'malformed manifest: {url}') return data raise ManifestError(f'{retries} attempts failed') try:- resp = session.get(url, timeout=10)+ resp = session.get(url, timeout=30) resp.raise_for_status()what the model actually emits:edit("core/manifest.py",
"timeout=10", "timeout=30")→ resolved by AST, refused if the anchor is
ambiguous, rolled back if it no longer compiles.−87% on this specific example — not −95.9%. The function above is short so that it fits on screen, and short symbols are our worst case. We show it rather than the flattering one.
Why now
Whoever fixes the edit layer first owns the default.
Every team running AI agents is bleeding tokens on rewrites right now, today — not in some future roadmap. The window to be the answer to that, instead of one more workaround, is open. It won't stay open.
Everyone building with AI hits the same wall
Solo indie hacker on a monthly quota, or engineering org on a metered API — same failure, different zero. Agent spend now grows faster than agent budgets in every team that has adopted them, because the cost scales with how much the model rewrites, not with how much actually changed.
Nobody has fixed the edit itself
Bigger context windows and cheaper tokens both treat the symptom — pay more, fit more — not the cause: models that can't address six tokens by name. The engine that fixes the cause, not the budget, doesn't exist as a shipped product yet.
The gap closes the moment someone ships it
This isn't a research problem anymore — the parsing and graph infrastructure it needs is already commodity. The only thing standing between "idea" and "category" is someone building the patch layer and proving it works. We already have.
Architecture
Seven stages. Five of them run today.
The actual shape of the system, not an illustration of one. Operational runs today and is covered by the benchmark below. Specified is specified, not built yet.
- 01 · INPUTOperational
Sources
Source trees, documents and structured records, read where they already live. Nothing is uploaded and nothing is mirrored — the engine runs on the machine that owns the files.
Local filesystem · Git working tree
- 02 · PARSEOperational
Structural extraction
Each file is parsed into a concrete syntax tree, not scanned as text. Symbols, their spans, their decorators and their enclosing scope are resolved from the grammar, so a method keeps its class and a decorator stays part of the symbol it decorates.
AST parser · symbol resolver
- 03 · RELATEOperational
Symbol & dependency graph
Symbols are linked into a persistent graph of definitions, references and call edges. This is what turns an instruction that names one function into a bounded set of places that can legally change.
Symbol graph · project_graph.json
- 04 · REASONOperational
Semantic operation engine
A model describes an intent; the engine turns it into a typed operation — replace, insert-after, delete-range — and derives the minimum-cost plan that satisfies it. The model never emits the code itself.
Semantic operation schema · minimal-patch planner
- 05 · PROVEOperational
Verification & rollback
Before anything touches disk: refuse on an ambiguous anchor, refuse when a decorator would be dropped, re-parse after applying, and roll the transaction back if the file no longer compiles. Failure is a refusal, never a partial write.
Neuro-symbolic guard · transactional apply
- 06 · GENERALISESpecified
Knowledge representation
Extending the same graph beyond code, so that specifications, schemas and prose participate in the same resolution. The interface is specified against the existing graph; the extractors for non-code sources are not built.
Specified — not implemented
- 07 · SERVESpecified
Agent & application interface
A model-agnostic API so any agent can describe a change instead of writing one. Today the engine is driven in-process by our own tooling; the packaged interface, the installer and account linking are being built.
In development
Evidence
Two measurements. Both reproducible in about a second.
These run on real files from a real repository with a real tokenizer (tiktoken, cl100k_base). The limitations are printed next to the results, not in a footnote — including the case that argues against us.
Output tokens per edit — 25 real symbols
−95.9%
output tokens, same 25 edits
| Model rewrites the whole file(baseline we do not quote) | 112,023 |
|---|---|
| Model rewrites the whole symbol(honest baseline) | 17,553 |
| Model emits a Venkai edit call | 713 |
$ python benchmarks/see_bench.py --limit 25
Measured 2026-08-03. Output tokens only; the context read on the way in is not counted. The comparison is against a simulated rewrite, not yet against a third-party agent. We quote the symbol baseline, not the whole-file one — no serious agent rewrites an entire file, and using that baseline would flatter us.
20 edits spread across 12 real files
−91.5%
output tokens, worst realistic case
| Full regeneration of each file | 64,242 |
|---|---|
| Venkai — 20 calls | 5,492 |
| Median crossover point(on one file) | 240 edits |
$ python benchmarks/see_bench_multi.py --files 12 --edits 20
Measured 2026-08-03. This is the case that argues against us: when a file changes end to end, regenerating it costs the file once regardless of how many changes it contains. The crossover is real and we measured it — roughly 240 edits to a single file. Past that point it is not an edit, it is a rewrite.
What these numbers are not. They measure output tokens only — the context read on the way in is not counted. They compare against a simulated rewrite, not yet against a third-party agent; that protocol is being built. And they are one corpus, on one language. We would rather you knew the shape of the claim than be impressed by it.
Engineering
How the system is built, including what is not built.
There are no customer logos on this page and no testimonials, because we are at the beginning. What we have instead is a system you can watch run and a benchmark you can re-execute on your own code in about a second.
Fails safe, every time
Ambiguous edit, dropped decorator, file that won't re-parse — the engine refuses instead of guessing, and a refusal counts as a failure in our own benchmark. No partial writes, ever.
Measured, not asserted
Token cost, wall clock and success rate are logged per operation. Every figure on this page names the command that reproduces it.
Runs on your machine
No source material uploaded, no keys proxied through us. The benchmark runs with the network off — relevant whether you're a solo dev or a regulated enterprise.
API-first — in progress
Driven in-process by our own tooling today. The model-agnostic interface, installer and account linking are being built.
Not shippable today.
Where this goes
From processing data to machine-native understanding.
Code first, because a wrong edit doesn't compile — the cheapest feedback loop there is, and the one that let us build guards strict enough to refuse rather than guess. The same layer generalises anywhere structure is formal: schemas, contracts, configuration, structured records.
The long-term position is a substrate, not a feature: a layer that lets an autonomous system act on a complex environment by naming things in it, and refuses when it's wrong. We're several stages from that — the diagram above marks exactly which ones.
Access
Watch the benchmark run on your own repository.
Fifteen minutes. You grant no access and install nothing — we bring the machine, you pick the files. If the number does not hold on your code, you will have found that out in a quarter of an hour.
Replies within 24 hours · no waitlist form, no drip sequence