oooscoos/benzi — Hacker News discussions

UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
Period	Start (UTC)	End (exclusive, UTC)	Mentions	Submissions	Comments
Aug 31	2026-08-31 00:00:00 UTC	2026-09-07 00:00:00 UTC	1	1	0
Sep 7	2026-09-07 00:00:00 UTC	2026-09-14 00:00:00 UTC	2	1	1
Sep 14	2026-09-14 00:00:00 UTC	2026-09-21 00:00:00 UTC	5	1	4
Sep 21	2026-09-21 00:00:00 UTC	2026-09-28 00:00:00 UTC	1	0	1
Sep 28	2026-09-28 00:00:00 UTC	2026-10-05 00:00:00 UTC	3	0	3
Oct 5	2026-10-05 00:00:00 UTC	2026-10-12 00:00:00 UTC	0	0	0
Oct 12	2026-10-12 00:00:00 UTC	2026-10-19 00:00:00 UTC	2	0	2

showhz·Oct 17, 2026

Benzi is a code intelligence system. With the agentic loop + compiler it scores 82.4% on SWE-bench Verified for $12.96 while reading 2-4x less source code than other agents/harnesses (measured separately, check 24-bug benchmark). Code intelligence itself is old, but bringing AI into the mix changes things. The AI models generate TEXT. The written text happens to be code for SWE purposes. Now, what improves with every model iteration is the cognition/comprehension of whatever text it has generated, in our case, code. Anthropic intrinsically doesn't care if its models chew through the codebase raw, their business is cognition improvement. For codebases with millions of lines of code that require a lot of thinking tokens regardless of what model is used, they rely on model cognition, not code intelligence. Benzi is compiler backed. It suppor

Read the rest

ts 10 programming + 3 frontend languages (and is model agnostic - not loyal to any frontier lab). In fact, the whole tier taxonomy of RESOLVED/CANDIDATE/OBSERVED ( + external/unresolved/unindexed) was built around resolving the repo once, and letting the agent query that, while updating incrementally on edits and automatically reverting broken ones. The runtime tracer is how an edge gets OBSERVED in the first place. The compiler is lean and compiles locally. It is currently available for free as a VS code ext. and CLI. The Benzi compiler can also be queryed by other agents - the MCP server exposes only the compiler, your agentic loop stays with your agent. github: https://github.com/oooscoos/Benzi (benzi is not OSS. repo contains swe bench results + code benzi wrote - you should check it out, the compiler changes how model designs changes). website is there too but I dont want to make this look like a promo. really what i want is for you guys to just try it out once. the demo loads any random repo within seconds - throw your own at it even. https://varianttech.net/demo

In [dead]

tweedler290·Oct 17, 2026

Benzi is a code intelligence system. With the agentic loop + compiler it scores 82.4% on SWE-bench Verified for $12.96 while reading 2-4x less source code than other agents/harnesses (measured separately, check 24-bug benchmark). Code intelligence itself is old, but bringing AI into the mix changes things. The AI models generate TEXT. The written text happens to be code for SWE purposes. Now, what improves with every model iteration is the cognition/comprehension of whatever text it has generated, in our case, code. Anthropic intrinsically doesn't care if its models chew through the codebase raw, their business is cognition improvement. For codebases with millions of lines of code that require a lot of thinking tokens regardless of what model is used, they rely on model cognition, not code intelligence. Benzi is compiler backed. It suppor

Read the rest

ts 10 programming + 3 frontend languages (and is model agnostic - not loyal to any frontier lab). In fact, the whole tier taxonomy of RESOLVED/CANDIDATE/OBSERVED ( + external/unresolved/unindexed) was built around resolving the repo once, and letting the agent query that, while updating incrementally on edits and automatically reverting broken ones. The runtime tracer is how an edge gets OBSERVED in the first place. The compiler is lean and compiles locally. It is currently available for free as a VS code ext. and CLI. The Benzi compiler can also be queryed by other agents - the MCP server exposes only the compiler, your agentic loop stays with your agent. github: https://github.com/oooscoos/Benzi (benzi is not OSS. repo contains swe bench results + code benzi wrote - you should check it out, the compiler changes how model designs changes). website is there too but I dont want to make this look like a promo. really what i want is for you guys to just try it out once. the demo loads any random repo within seconds - throw your own at it even. https://varianttech.net/demo

In [dead]

tweedler290·Oct 3, 2026

thats crazy. i made this https://github.com/oooscoos/Benzi which does the same thing but is language agnostic (supports 9 other languages). urs probs goes in deeper into c++ than mine tho

In C++ Insights – See your source code with the eyes of a Compiler

tweedler290·Sep 30, 2026

GitHub: https://github.com/oooscoos/Benzi Demo: https://varianttech.net/demo Benchmarks: https://varianttech.net/benchmark Roughly speaking, the way current AI coding agents/harnesses work is by either: a) Pulling in appropriate text snippets of code across multiple files and handing them to the agent, or b) Parsing code to make high dimenional embeddings to approximate a symptom map, and hand that to the agent. Both of these approaches skyrocket the token count, add to wall clock time, contribute to context drifting, add to the model's thinking tokens to discover the structure of the program, and then FORGET most of it when Claude Code compacts, or ALL of it if it's a multifile refactoring because all line numbers shift and need re-grepping. Benzi is built from the ground up to AVOID reading source code in the first place. It supplies th

Read the rest

e artificial intelligence model deterministic intelligence via tool calls. For example, when a model is about to make a code change, it could query "what functions feed this one?" -- half the time it isn't even necessary because the Benzi compiler already informs it of the blast radius before and after making edits, along with a complete static analysis check. Benzi Sonnet reads far less source code (9,125 lines) than Claude Code Sonnet (20,704), DeepSeek's harness (43,598), and OpenCode (65K+ LOC -- disqualified due to repeated failure) to accomplish the same tasks faster and cheaper. (benchmark link in comments) Benzi has truth tiers clearly seperating what can be analyzed with static analysis from what can't -- and then adding a runtime tracer on top to bridge the gap between the two (details in FAQ on github). It also has several bonus features such as a runtime tracer, syntax & semantic verified writes, context aware model written repro, mid task model upgrade if task is too difficult, and SEVERAL more. It currently supports Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby, and can handle HTML, CSS and JS -- deterministically. Claude Code clicks photos, Benzi resolves winners of CSS rules. The CodeIndex and the MarkupIndex are fairly well tested, and if something isn't working, the model is made aware of it first. On the benchmarks side, 78.2% SWE-bench Verified for <10¢ a fix (using V4flash). This score is noteable because while the rest of the industry is leaning plugin-heavy and pouring millions of dollars into increasing context window sizes, Benzi's approach might prove to be economically more valuable while improving the model's code writing/comprehenion abilities. Thanks for reading! please let me know what you think. I am aware the AI fatigue is real, but I hope you can see why indexing a repo > reading raw source code. Please go over the github readme before snap judgements..

In [dead]

showhz·Sep 30, 2026

GitHub: https://github.com/oooscoos/Benzi Demo: https://varianttech.net/demo Benchmarks: https://varianttech.net/benchmark Roughly speaking, the way current AI coding agents/harnesses work is by either: a) Pulling in appropriate text snippets of code across multiple files and handing them to the agent, or b) Parsing code to make high dimenional embeddings to approximate a symptom map, and hand that to the agent. Both of these approaches skyrocket the token count, add to wall clock time, contribute to context drifting, add to the model's thinking tokens to discover the structure of the program, and then FORGET most of it when Claude Code compacts, or ALL of it if it's a multifile refactoring because all line numbers shift and need re-grepping. Benzi is built from the ground up to AVOID reading source code in the first place. It supplies th

Read the rest

e artificial intelligence model deterministic intelligence via tool calls. For example, when a model is about to make a code change, it could query "what functions feed this one?" -- half the time it isn't even necessary because the Benzi compiler already informs it of the blast radius before and after making edits, along with a complete static analysis check. Benzi Sonnet reads far less source code (9,125 lines) than Claude Code Sonnet (20,704), DeepSeek's harness (43,598), and OpenCode (65K+ LOC -- disqualified due to repeated failure) to accomplish the same tasks faster and cheaper. (benchmark link in comments) Benzi has truth tiers clearly seperating what can be analyzed with static analysis from what can't -- and then adding a runtime tracer on top to bridge the gap between the two (details in FAQ on github). It also has several bonus features such as a runtime tracer, syntax & semantic verified edits, context aware model written repro, mid task model upgrade if task is too difficult, and SEVERAL more. It currently supports Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby, and can handle HTML, CSS and JS -- deterministically. Claude Code clicks photos, Benzi resolves winners of CSS rules. The CodeIndex and the MarkupIndex are fairly well tested, and if something isn't working, the model is made aware of it first. On the benchmarks side, 78.2% SWE-bench Verified for <10¢ a fix (using V4flash). This score is noteable because while the rest of the industry is leaning plugin-heavy and pouring millions of dollars into increasing context window sizes, Benzi's approach might prove to be economically more valuable while improving the model's code writing/comprehenion abilities. Thanks for reading! please let me know what you think.

In [dead]

tweedler290·Sep 23, 2026

GitHub: https://github.com/oooscoos/Benzi Demo: https://varianttech.net/demo Benchmarks: https://varianttech.net/benchmark Roughly speaking, the way current AI coding agents/harnesses work is by either: a) Pulling in appropriate text snippets of code across multiple files and handing them to the agent, or b) Parsing code to make high dimenional embeddings to approximate a symptom map, and hand that to the agent. Both of these approaches skyrocket the token count, add to wall clock time, contribute to context drifting, add to the model's thinking tokens to discover the structure of the program, and then FORGET most of it when Claude Code compacts, or ALL of it if it's a multifile refactoring because all line numbers shift and need re-grepping. Benzi is built from the ground up to AVOID reading source code in the first place. It supplies th

Read the rest

e artificial intelligence model deterministic intelligence via tool calls. For example, when a model is about to make a code change, it could query "what functions feed this one?" -- half the time it isn't even necessary because the Benzi compiler already informs it of the blast radius before and after making edits, along with a complete static analysis check. Benzi Sonnet reads far less source code (9,125 lines) than Claude Code Sonnet (20,704), DeepSeek's harness (43,598), and OpenCode (65K+ LOC -- disqualified due to repeated failure) to accomplish the same tasks faster and cheaper. (benchmark link in comments) Benzi has truth tiers clearly seperating what can be analyzed with static analysis from what can't -- and then adding a runtime tracer on top to bridge the gap between the two (details in FAQ on github). It also has several bonus features such as a runtime tracer, self-aware model upgrade mid task if it thinks the job is over its pay grade, context aware model written repro, and SEVERAL more. It currently supports Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby, and can handle HTML, CSS and JS -- deterministically. Claude Code clicks photos, Benzi resolves winners of CSS rules. The CodeIndex and the MarkupIndex are fairly well tested, and if something isn't working, the model is made aware of it first. On the benchmarks side, 78.2% SWE-bench Verified for <10¢ a fix (using V4flash). This score is noteable because while the rest of the industry is leaning plugin-heavy and pouring millions of dollars into increasing context window sizes, Benzi's approach might prove to be economically more valuable while improving the model's code writing/comprehenion abilities. Thanks for reading! please let me know what you think. I am aware the AI fatigue is real, but I hope you can see why indexing a repo > reading raw source code. Please go over the github readme before snap judgements.. Try feeding the live demo any random ahh repo you want. And ask it questions only real code intelligence could answer.

In Benzi – Code Intelligence MCP/Harness beating Claude Code and CodeGraph

showhz·Sep 18, 2026

Roughly speaking, the way current AI coding agents/harnesses work is by either: a) Pulling in appropriate text snippets of code across multiple files and handing them to the agent, or b) Parsing code to make high dimensional embeddings to approximate a symptom map, and hand that to the agent. Both of these approaches skyrocket the token count, add to wall clock time, contribute to context drifting, add to the model's thinking tokens to discover the structure of the program, and then FORGET most of it when Claude Code compacts, or ALL of it if it's a multifile refactoring because all line numbers shift and need re-grepping. Benzi is built from the ground up to AVOID reading source code in the first place. It supplies the artificial intelligence model deterministic intelligence via tool calls. For example, when a model is about to make a co

Read the rest

de change, it could query "what functions feed this one?" -- half the time it isn't even necessary because the Benzi compiler already informs it of the blast radius before and after making edits, along with a complete static analysis check. Benzi Sonnet reads far less source code (9,125 lines) than Claude Code Sonnet (20,704), DeepSeek's harness (43,598), and OpenCode (65K+ LOC -- disqualified due to repeated failure) to accomplish the same tasks faster and cheaper. (Benchmark details: https://benzi.fly.dev/benchmark) Truth tiers are maintained with clear and transparent boundaries. Explained in the github readme's FAQ. (https://github.com/oooscoos/Benzi) It also has several bonus features such as a runtime tracer, self-aware model upgrade mid task if it thinks the job is over its pay grade, context aware model written repro, and SEVERAL more. It currently supports Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby, and can handle HTML, CSS and JS -- deterministically. Claude Code clicks photos, Benzi resolves winners of CSS rules. The CodeIndex and the MarkupIndex are fairly well tested, and if something isn't working, the model is made aware of it first. On the benchmarks side, 78.2% SWE-bench Verified for <10¢ a fix (using V4flash). This score is notable because while the rest of the industry is leaning plugin-heavy and pouring millions of dollars into increasing context window sizes, Benzi's approach might prove to be economically more valuable while improving the model's code writing/comprehenion abilities. If you're curious to learn more, click https://benzi.fly.dev/about

In [dead]

showhz·Sep 15, 2026

Roughly speaking, the way current AI coding agents/harnesses work is by either: a) Pulling in appropriate text snippets of code across multiple files and handing them to the agent, or b) Parsing code to make high dimensional embeddings to approximate a symptom map, and hand that to the agent. Both of these approaches skyrocket the token count, add to wall clock time, contribute to context drifting, add to the model's thinking tokens to discover the structure of the program, and then FORGET most of it when Claude Code compacts, or ALL of it if it's a multifile refactoring because all line numbers shift and need re-grepping. Benzi is built from the ground up to AVOID reading source code in the first place. It supplies the artificial intelligence model deterministic intelligence via tool calls. For example, when a model is about to make a co

Read the rest

de change, it could query "what functions feed this one?" -- half the time it isn't even necessary because the Benzi compiler already informs it of the blast radius before and after making edits, along with a complete static analysis check. Benzi Sonnet reads far less source code (9,125 lines) than Claude Code Sonnet (20,704), DeepSeek's harness (43,598), and OpenCode (65K+ LOC -- disqualified due to repeated failure) to accomplish the same tasks faster and cheaper. (Benchmark details: https://benzi.fly.dev/benchmark) Truth tiers are maintained with clear and transparent boundaries. Explained in the github readme's FAQ. (https://github.com/oooscoos/Benzi) It also has several bonus features such as a runtime tracer, self-aware model upgrade mid task if it thinks the job is over its pay grade, context aware model written repro, and SEVERAL more. It currently supports Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby, and can handle HTML, CSS and JS -- deterministically. Claude Code clicks photos, Benzi resolves winners of CSS rules. The CodeIndex and the MarkupIndex are fairly well tested, and if something isn't working, the model is made aware of it first. On the benchmarks side, 78.2% SWE-bench Verified for <10¢ a fix (using V4flash). This score is notable because while the rest of the industry is leaning plugin-heavy and pouring millions of dollars into increasing context window sizes, Benzi's approach might prove to be economically more valuable while improving the model's code writing/comprehenion abilities. If you're curious to learn more, click https://benzi.fly.dev/about

In [dead]

tweedler290·Sep 15, 2026

Roughly speaking, the way current AI coding agents/harnesses work is by either: a) Pulling in appropriate text snippets of code across multiple files and handing them to the agent, or b) Parsing code to make high dimensional embeddings to approximate a symptom map, and hand that to the agent. Both of these approaches skyrocket the token count, add to wall clock time, contribute to context drifting, add to the model's thinking tokens to discover the structure of the program, and then FORGET most of it when Claude Code compacts, or ALL of it if it's a multifile refactoring because all line numbers shift and need re-grepping. Benzi is built from the ground up to AVOID reading source code in the first place. It supplies the artificial intelligence model deterministic intelligence via tool calls. For example, when a model is about to make a co

Read the rest

de change, it could query "what functions feed this one?" -- half the time it isn't even necessary because the Benzi compiler already informs it of the blast radius before and after making edits, along with a complete static analysis check. Benzi Sonnet reads far less source code (9,125 lines) than Claude Code Sonnet (20,704), DeepSeek's harness (43,598), and OpenCode (65K+ LOC -- disqualified due to repeated failure) to accomplish the same tasks faster and cheaper. (Benchmark details: https://benzi.fly.dev/benchmark) Truth tiers are maintained with clear and transparent boundaries. Explained in the github readme's FAQ. (https://github.com/oooscoos/Benzi) It also has several bonus features such as a runtime tracer, self-aware model upgrade mid task if it thinks the job is over its pay grade, context aware model written repro, and SEVERAL more. It currently supports Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby, and can handle HTML, CSS and JS -- deterministically. Claude Code clicks photos, Benzi resolves winners of CSS rules. The CodeIndex and the MarkupIndex are fairly well tested, and if something isn't working, the model is made aware of it first. On the benchmarks side, 78.2% SWE-bench Verified for <10¢ a fix (using V4flash). This score is notable because while the rest of the industry is leaning plugin-heavy and pouring millions of dollars into increasing context window sizes, Benzi's approach might prove to be economically more valuable while improving the model's code writing/comprehenion abilities. If you're curious to learn more, click https://benzi.fly.dev/about

In [dead]

tweedler290·Sep 14, 2026Submission

A fresh take on Code Intelligence for AI agents – publically benchmarked

2 points · Open discussion

tweedler290·Sep 14, 2026

I made a code intelligence system from scratch! language agnostic and model agnostic. runs locally. Benzi is a compiler+harness+runtime tracer/debugger built from ground up to write code as neatly as it understands it. 78.2% on SWE-bench verified for < 10 cents a fix + benchmarked against Claude Code, Open Code, and Deepseek Harness. Benzi is far cheaper AND faster. sounds like marketing fluff but just check it out please. github landing page: https://github.com/oooscoos/Benzi Instant callflow/dataflow/controlflow lookups on any codebase for any AI model - you can see how huge this can be rite?

In Ask HN: What are you working on? (September 2026)

tweedler290·Sep 11, 2026

harness is only available as a VS extention for now (no headless. MCP release soon as well), you can get it here: https://marketplace.visualstudio.com/items?itemName=variantt... here is the about page: https://benzi.fly.dev/about and github landing page: https://github.com/oooscoos/Benzi

In Show HN: Benzi – A Code Intillegence/Harness Beating Claude Code and CodeGraph

tweedler290·Sep 7, 2026Submission

Show HN: Benzi – Code Intelligence Infrastructure for Frontier AI Models

Roughly speaking, the way current AI coding agents/harnesses work is by either: a) Pulling in appropriate text snippets of code across multiple files and handing them to the agent, or b) Parsing code to make high dimensional embeddings to approximate a symptom map, and hand that to the agent. Both of these approaches skyrocket the token count, add to wall clock time, contribute to context drifting, add to the model's thinking tokens to discover the structure of the program, and then FORGET most of it when Claude Code compacts, or ALL of it if it's a multifile refactoring because all line numbers shift and need re-grepping. Benzi is built from the ground up to AVOID reading source code in the first place. It supplies the artificial intelligence model deterministic intelligence via tool calls. For example, when a model is about to make a co

Read the rest

de change, it could query "what functions feed this one?" -- half the time it isn't even necessary because the Benzi compiler already informs it of the blast radius before and after making edits, along with a complete static analysis check. Benzi Sonnet reads far less source code (9,125 lines) than Claude Code Sonnet (20,704), DeepSeek's harness (43,598), and OpenCode (65K+ LOC -- disqualified due to repeated failure) to accomplish the same tasks faster and cheaper. (Benchmark details: https://benzi.fly.dev/benchmark) "But what if the compiler isn't doing its job right! Wouldn't you mislead the AI model?" - Absolutely. Benzi meticulously takes care of this by having 3 truth tiers. RESOLVED has definite evidence, CANDIDATE is what couldn't be resolved by the static analysis, and OBSERVED is what actually happened during an execution. The artificial intelligence and the determinstic intelligence layers coordinate to reduce source hits where possible, without producing incorrect results for the sake of efficiency. It also has several bonus features such as a runtime tracer, self-aware model upgrade mid task if it thinks the job is over its pay grade, context aware model written repro, and SEVERAL more. It currently supports Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby, and can handle HTML, CSS and JS -- deterministically. Claude Code clicks photos, Benzi resolves winners of CSS rules. The CodeIndex and the MarkupIndex are fairly well tested, and if something isn't working, the model is made aware of it first. On the benchmarks side, 78.2% SWE-bench Verified for <10¢ a fix (using V4flash). This score is notable because while the rest of the industry is leaning plugin-heavy and pouring millions of dollars into increasing context window sizes, Benzi's approach might prove to be economically more valuable while improving the model's code writing/comprehenion abilities. If you're curious to learn more, click https://benzi.fly.dev/about and check out StallionSwipe. probably the best thing i ever made. It's a Fireship inspired horse tinder app greenfielded entirely in Benzi Opus 4-8 and a little bit v4 flash. and lastly, please star on github if you like where this is headed!

3 points · Open discussion

kamarovmakarov·Sep 5, 2026Submission

Benzi – A harness reading LESS source code to write better quality code

2 points · Open discussion