OxCode benchmarks: 82% on two coding evaluations

I want to tell you about two numbers, and just as clearly about what they do not mean.

OxCode scored 82.0% on SWE-bench Verified and 82.0% on Terminal-Bench 2.1. Those are two of the evaluations people use to judge how well an AI agent handles real software work. I ran both myself, with a very small team, and I'm publishing the result the way I'd want to read it if I were a developer deciding what to install: method stated, caveats kept, run records public.

This post is the first-person account of how those runs were done, why you shouldn't line them up one-to-one against official leaderboard entries, and who built OxCode and why. If you only read one thing, read the caveats section. A benchmark score you can't interrogate is marketing. I'd rather you interrogate this one.

The result: 82% on SWE-bench Verified and Terminal-Bench 2.1

Here are the numbers, plainly.

On SWE-bench Verified, OxCode resolved 410 of 500 instances. On Terminal-Bench 2.1, it solved 73 of 89 tasks. Both come out to 82.0%.

Two different evaluations landing on the same percentage is a coincidence of arithmetic, not a rounding trick. 410 divided by 500 is 0.82. 73 divided by 89 is 0.8202. I mention it because people notice, and I'd rather you hear it from me.

Why these two evaluations? They test different things. SWE-bench Verified asks an agent to resolve real software issues in real repositories. Terminal-Bench 2.1 puts the agent in a terminal and gives it tasks to finish there. One is about understanding a codebase and fixing it. The other is about operating a command line. A coding agent that only does well on one of them is a narrower tool than it looks.

I believe the two scores together say something a single score can't. An agent that plans, writes, tests and debugs, and runs what it writes in a sandbox before calling a task done, should show up well on both. That's how OxCode is built to work, and these runs are the first public evidence I can point to.

One claim I won't hide from: I think this puts OxCode in the top tier of coding agents. Treat that as my opinion. The scores are the evidence. The ranking is my reading of them.

If you want the pieces behind the headline, the run records are public at oxcode.ai/benchmarks.

How the runs were done: self-run, one attempt each (410 of 500 and 73 of 89)

A benchmark number is only as good as the way it was produced, so here is exactly how these were produced.

I ran both evaluations myself. They're self-run, not submitted to and verified by a third party. That matters, and I come back to it in the next section.

Each task got one attempt. That's the part I care about most. On SWE-bench Verified that means 500 instances, one attempt each, 410 resolved. On Terminal-Bench 2.1 that means 89 tasks, one attempt each, 73 solved. I didn't pick the best of several tries per task and report only the win.

Why does single-attempt matter? Because it's the closest thing to how you actually work. When you hand a task to an agent in your editor, you don't get to quietly rerun it five times and keep the lucky output. You get one run, and either the result holds up or you're back to debugging code you didn't write. A score from one attempt per task is a fairer picture of that daily experience than a score padded by retries.

The same team that built OxCode ran the evaluations, and it's a very small team. I say that as context, not as an excuse. We had no dedicated evaluation department. We had the product, the benchmark harnesses, and the discipline to record what happened.

That last part is why the records exist. I wanted every run to leave a trail someone else could open and check, instead of a single screenshot of a final percentage.

Why these numbers are not directly comparable to official leaderboard entries

This is the section I most want you to read carefully.

These are self-run results. Official leaderboard entries follow their own submission and verification processes, with their own rules about how a run is set up and checked. Mine didn't go through that. So the 82.0% figures shouldn't be treated as a like-for-like entry sitting next to the names on an official leaderboard.

I'm not saying the numbers are soft. I'm saying the comparison isn't clean, and pretending otherwise is the fastest way to lose your trust. A self-run result and a leaderboard-verified result answer slightly different questions. One says: here's what we measured, here's how we measured it, check our work. The other says: an independent process confirmed it.

I'd rather give you the first honestly than dress it up as the second.

So how should you use these numbers? Read them as strong, openly documented evidence of how OxCode performs, not as a ranking certificate. If you're choosing a tool, weigh them alongside what you see when you run it on your own code. A benchmark tells you an agent is capable. Your own repository tells you whether it's capable for you.

It's also worth asking how SWE-bench Verified scores translate to daily work at all. A high score on resolving curated issues is a signal, not a promise that every task in your project will go smoothly. If you want to pressure-test any agent's output yourself, our guide on how to debug AI-generated code in VS Code before you ship it walks through that habit, and the habit applies to every tool, mine included.

The founder story behind OxCode

I started building OxCode because I was tired of the same loop.

You ask an AI to write code. It looks right. You run it, and it breaks. You spend the next hour fixing what the AI just wrote. At some point the tool that was supposed to save you time has quietly become a second job.

I wanted an AI that did the part nobody likes. One that plans the work, writes the code, tests it, debugs it, and runs what it writes in a sandbox, then catches and fixes its own bugs before it tells you it's done. An agent that reads your codebase before it touches it, and that knows when to act, when to ask, and what never to touch.

OxCode is made in India, for Indian developers, and the pricing is designed for Indians. That's deliberate. There's a Free plan at 15 runs a day, Starter at ₹899 a month, and Pro at ₹3,999 a month, with the first two months discounted to ₹99 and ₹999. I wanted a serious coding agent to be something a freelancer or a student in India could actually afford, not a tool priced in someone else's currency for someone else's budget. If rupee pricing is what you're weighing, our guide to AI coding assistant pricing in rupees lays out the options.

We built it with a very small team. The benchmark results came from that same small team. That's the most honest summary of where OxCode is: early, focused, and willing to show its work.

It works in VS Code, Cursor, Antigravity and other VS Code-based IDEs, and thousands of developers have downloaded it.

Public evidence: the oxcode-evals repository and run records

A claim you can't check is just an opinion with a percentage attached. So the evidence is public.

The run records live at oxcode.ai/benchmarks, and the evaluation material is published in the oxcode-evals repository. The point of putting them out is simple: anyone who follows my updates, or anyone who's just skeptical, can open the records and see what was run instead of taking my word for it.

This is also why I keep stressing the one-attempt-per-task setup. With public run records, that isn't a slogan. You can look for it in the data. If you're the kind of person who checks the run records before believing the headline, good. That's the right instinct, and I built the publication around people like you.

What should you look for? Start with the counts: 410 of 500 on SWE-bench Verified, 73 of 89 on Terminal-Bench 2.1. Confirm they match the 82.0% figures. Then look at how each task was attempted and recorded. If something in the records doesn't match what I've written here, I want to hear about it.

I believe this is where AI tooling is heading. Evaluation claims will have to come with records attached, because developers have been burned too often by numbers they couldn't inspect. If you want to see how a related claim holds up against evidence, our post on checking the evidence for an AI coding agent that runs tests applies the same standard.

The repository and the records are the part of this story you don't have to trust me on.

What comes next and the fundraising close

Two scores don't finish the job. They're a starting line.

What comes next is more of the same discipline: keep improving the agent, keep running the evaluations, and keep publishing the records. A small team can get a long way on focus, but there's a ceiling on what a very small team can do alone.

That's why I'm open about fundraising. OxCode reached these results with a very small team, and I believe that with more resources the product and the evaluation work can both go further. I won't dress that up. If you're an investor who reads benchmark records and cares about developer tooling built in India for Indian developers, I'd like to talk.

For developers, the ask is simpler and more immediate. Install OxCode, point it at a real task in your own project, and judge it on what it does with your code. A benchmark can tell you an agent is worth trying. It can't replace the afternoon you spend finding out.

I'll keep posting updates as the work moves. If you follow along, you'll see the next set of results with the same caveats attached, because I don't intend to stop stating them.

Source: originally published on Medium

This post is a faithful republish of my original article on Medium, titled "OxCode Scores 82% on Two Major AI Coding Benchmarks, Closing In on the Industry's Best." It keeps the first-person voice, the structure, and the methodology caveats from that original piece.

I'm republishing it here so the full account sits alongside the product. If you arrived from Medium, you've already seen the argument. If you arrived from search, this is the same argument in the same words: the results, the way the runs were done, why they aren't directly comparable to official leaderboard entries, and the story of why OxCode exists.

The numbers haven't changed between the two versions. 410 of 500 on SWE-bench Verified. 73 of 89 on Terminal-Bench 2.1. One attempt each. Self-run.

If you spot a difference between this version and the Medium original, trust the run records at oxcode.ai/benchmarks over either article. The records are the primary source. Everything I've written about them is commentary.

Conclusion

The next time anyone, me included, hands you a benchmark score, ask for the attempt count and the run records before you ask for the percentage. That one habit filters out most of the noise in AI tooling.

If these OxCode benchmarks made you curious, test them against your own code instead of taking my word for it. Install OxCode in VS Code or a VS Code-based IDE like Cursor, start on the Free plan at 15 runs a day, and give it a task that has been annoying you in a real project. Then open the run records at oxcode.ai/benchmarks and compare what you saw to what we published.

If the agent holds up on your repository the way it did on 500 SWE-bench instances, you'll know. If it doesn't, tell me. I'd rather hear it.