Skip to main content
BenchmarksAI agentsTransparency

How We Benchmark Our AI Agent — And Publish the Real Numbers

Mayank Rajput··5 min read

TL;DR

  • We publish our agent’s real, correctness-gated results — including failures — which black-box builders don’t.
  • Method: a deterministic acceptance gate (runs tsc, checks files/dev server) + an independent LLM judge + a holdout set. “Pass” means the task was provably done.
  • Honest results: strong at targeted bug-fixing (~85–90%) and simple full-stack builds; weaker on complex full-stack scaffolding. We once reported 87.5%, found it was process-based, retracted it, and re-measured.
On this page

Every AI app builder claims its agent is good. Almost none publish a number you can check. We do — including the runs where our agent fails. Here is how NoCoder measures its own agent, the real (unflattering) results, and why we think publishing them is the honest thing to do.

How we measure

Every evaluation runs the full production agent — the same orchestrator, tools, prompts, and memory that serve real users — against a fixture task inside a disposable workspace pod. Then we score it two independent ways:

  • A deterministic acceptance gate (pass/fail). Not “the agent looked busy” — it actually runs tsc --noEmit, checks the files exist and contain the required change, starts the dev server, and inspects the trajectory. Pass means the task was provably accomplished.
  • An independent LLM judge that assesses the outcome separately and is cross-checked against the gate.

We also keep a holdout set the improvement loop never sees (to catch overfitting), and infrastructure failures are recorded as failures — never quietly passed.

The time we caught ourselves overstating — and fixed it

Why you can trust these numbers

We once reported an 87.5% pass rate. Then we found the scoring was process-based: a run could look busy without accomplishing the task, and some “passes” hadn't actually fixed the bug. We retracted that number, rebuilt scoring around a deterministic gate, and re-measured. The real numbers below are lower and messier than the retracted one — and they're trustworthy. We'd rather publish the honest figure than the flattering one.

What the agent is actually good (and bad) at

Correctness-gated results on our internal fixture bank:

  • Targeted bug-fixing: ~85–90% pass. Given real broken code, the agent reliably produces a fix that compiles clean and makes the specific change.
  • Simple full-stack app builds: reliable. It scaffolds working SPAs and can go prompt → full-stack app → live deploy with a real database (validated end-to-end).
  • Complex full-stack scaffolding & consistency: weaker. Heavy multi-part builds and run-to-run consistency are where it still misses — and we say so publicly instead of hiding it.
  • Code retrieval (RAG): recall@10 0.94, MRR 0.91 on our file-retrieval fixtures.

The part no competitor publishes: a closed self-improvement loop

A failed run feeds a reflection step that proposes a prompt change; the candidate is validated against the correctness gate (with the holdout set guarding against regressions) before anything reaches production. The platform measures itself continuously and improves from its own failures — and we publish the trajectory, methodology, and misses.

Honest framing

These are our internal fixtures — rigorous, but not directly comparable across companies (nobody's fixtures are). We haven't run other builders through them, so we make no head-to-head claims here. An apples-to-apples SWE-bench number is on our roadmap; until then, the defensible claim is simple: we measure our agent with a deterministic gate and publish the real results, failures included — which is more than the black-box builders do.

Try the agent we publish real numbers for

Try NoCoder Free

Want the control that these numbers are built around? Every change the agent makes is a per-file diff you review before it applies. See the AI app builder comparison or try NoCoder free.

Review every AI change before it ships

NoCoder proposes per-file diffs you accept, edit, or reject — in a real workspace. Start free with Gemini and Ollama models.