68 of 100 real programming problems from SWE-bench Verified, solved without the internet on one DGX Spark, at about 48 tokens a second. (A token is a small piece of a word; the machine writes about 48 of them each second.) Ragon is a coding helper, a chat assistant and a desktop app, and all of it runs on your own GB10. Nothing is sent to a cloud. There is no account, no bill for each use, and no tracking. How we measured it
Ragonragon, the helper in your terminal
🪟 Desktop app preview
💬 Ask, in a browser
🧩 JetBrains & VS Code (MCP)
📱 Signal, Telegram & Matrix
ragon-code def validate_signup → src/auth/signup.py:42pytest tests/test_signup.py -q → 1 failed, 14 passedapply_patch src/auth/signup.py +12 -2 · tests/test_signup.py +8pytest tests/test_signup.py -q → 15 passed in 0.41ssrc/auth/signup.py, and added a test so it stays fixed.The optional ragon-serve runs Qwen3.8-27B on the GB10 with a 262K-token memory. Every node gets its own private Forgejo (a place to keep git repositories), and the Telegram Mini App works directly on your repositories.
Inside the command sandbox, the Docker, containerd, D-Bus and systemd sockets are closed (a socket is a door a program can use to give orders to the system). ragon-docs now reads scanned pages and office documents too, and the server can serve signed LoRA adapters (small add-ons that change what a model is good at).
Ask and Work share one desktop window, with a review pane, worktrees and terminal tabs. /night add --best-of N runs a task N times and keeps the best try.
Also in 1.7.0: Night Shift can try one task several times and keep the best try (/night add --best-of N). One machine can run several Signal bridges. And a computer that sees two GB10s on one network can choose between them without forgetting the one it already knows. Release notes and downloads.
$ curl -fsSL https://github.com/dreamference/ragon/releases/latest/download/install.sh | bash$ ragon-admin server start # downloads the model once (~20 GB), then starts it $ cd ~/your-project && ragon # that's all
This works on the NVIDIA DGX Spark and on every other GB10 machine. The script checks each download against the release's checksums, and shows you each sudo command before it runs it. You can read the script first.
Your other computers borrow the GB10's model over your home or office network. On a Mac or another Linux machine, the same command installs ragon, the part you type into. It finds the GB10 by itself.
From 1.7.2 it also puts the desktop app in Applications on a Mac, ready to open. Add --no-app if you don't want it.
> irm https://github.com/dreamference/ragon/releases/latest/download/install.ps1 | iexType this in PowerShell. It needs no administrator rights (from 1.7.2 that holds for the desktop app too). Windows then asks you once to set up a walled-off place where the helper runs commands. The installer is not signed yet, so Smart App Control must be off. Read the script.
The release page also has the Mac disk image (Ragon-<version>-arm64-preview.dmg, or x64 for Intel) and the Windows installer (Ragon-Setup-<version>-x64.exe, or arm64). They are unsigned previews, so when you download them in a browser, your system stops them the first time. Before you open one, check it against the release's signed SHA256SUMS file.
All of them have the same chip, the same 128 GB of memory shared by the processor and the graphics, and DGX OS 7, so one installer covers them. We develop and test Ragon every day on the ASUS Ascent GX10. The others are covered by our automated tests, but we don't run them by hand.
Or leave work for tonight with /night add <task>. Ragon goes through the list while you sleep, each task on its own git branch, and you look over the branches in the morning.
$ ragon "explain this repository to me like I'm new on the team" # reads the code index (ragon-code outline, def, refs, callers) instead of grepping, # then walks you through the layout, the entry points and how they connect
$ ragon "the tests are failing: find out why and fix them" # runs the tests, reads the failure, edits the code and runs the tests again, # asking before anything risky
> /night add --best-of 3 add input validation to the signup form, with tests # tonight: three attempts, each in its own git worktree; the one the chooser picks # is committed on its own branch, and nothing is merged or pushed $ ragon-admin night status # the timer, the window and the queue > /night apply <id> # in the morning: bring the branch back as uncommitted changes
A list of where things are defined and who uses them across your project, so the helper can look code up and not search for it by guessing.
Search goes through a private SearXNG on your own machine, so there is no search account and no key to get. The questions still go out to the web to be answered.
Type /night add <task> before bed. By morning each task is done on its own git branch. Nothing is merged or pushed unless you do it.
The desktop app in 1.7.0 puts both ways of using Ragon in one window: Ask, where you put questions, and Work, where the helper edits your code. Work has a box to type tasks in (you can attach files, skills and commands), a pane to look over changes before you keep or undo them, separate working copies of your code (worktrees), terminal tabs, and a file tree beside the conversation. On your other computers the app talks to your GB10, which it finds on your network.
ragon · ragon-code · ragon-docsragon, the helper in your terminalIt reads your project, runs commands and tests, edits code, and asks you first before anything risky.
$ ragon worktree on # new sessions start in their own worktree $ cd ~/your-project && ragon > /airgapped on # no network for any command it runs > /worktree apply # bring the changes back to your checkout
Skills you wrote for Claude Code, Gemini CLI, OpenClaw or Hermes work here as they are.
ragon app · ragon webAsk and Work in one window, on the GB10, a Mac, Linux or Windows. The helper's sessions ask your approval, and there is a pane for reviewing changes, separate working copies, and undo. New in 1.7.
Questions with web search, image search and speaking instead of typing, and your helper sessions too, from this machine or from a phone you have paired with it. It all uses the same model on your machine.
From 1.7.2, the install command puts Ragon in Applications next to ragon, and you open it like any other app. It runs on Apple silicon and Intel, with macOS 12 or later. ragon update updates it.
On the GB10, the file ragon_1.7.0_arm64.deb installs the app, its menu entry and the ragon-app command, along with the sandbox profile it needs. (A sandbox is a closed room for running commands, so they can't touch the rest of the machine.)
$ sudo apt install ./ragon_1.7.0_arm64.debThen open it from the application menu, or type ragon app. More.
From 1.7.2, the PowerShell line installs the app too, for you alone and without administrator rights, with an entry in the Start menu. Settings → Apps removes it, and ragon update updates it. Smart App Control must be off.
ragon-admin mcp · ragon signal · ragon chatYou can connect JetBrains or VS Code through stdio MCP (ragon-admin mcp). You can also send messages to your GB10 from Signal (to yourself, in Note to Self), from Telegram (with the Mini App for working on repositories), and from Matrix over Tailscale. Every phone link is off until you turn it on. Signal is end-to-end encrypted, and Matrix runs on a server of your own. Telegram messages pass through Telegram's servers unencrypted, so use it only for things you would not mind sharing that way.
$ ragon-admin mcp # stdio MCP for JetBrains and VS Code $ ragon signal setup # Note to Self only, off until linked $ ragon chat telegram setup # topics and the Mini App
Read-only, through a sign-in that stays on your machine. It is switched off completely with /airgapped on.
A cloud coding helper sends your source code to computers that belong to someone else. Ragon sends it nowhere. The model runs on your GB10, and nothing in Ragon calls home: no usage counts, no measurements, no sign-in, not even "anonymous" crash reports. So you can use it on code you are not allowed to upload, such as a client's work, protected data or a product not yet released.
One command runs a real Ragon session under strace, a tool that watches every call a program makes, and then lists each network connection the session opened:
$ ragon-admin audit egress ✔ Egress audit: pass Network destinations: 127.0.0.1:8000 29x model server 127.0.0.1:8767 1x Gmail search service DNS queries: none Networked git commands: none
All of it stayed on 127.0.0.1, which is the machine talking to itself. There was not one DNS lookup (a DNS lookup is asking the internet for the address of a name).
Type /airgapped on. Every command the helper runs then gets an empty network from the Linux kernel. That is not a polite request to the model. There is simply no network to reach. At the same time, Full Access, which would get around the sandbox, is refused.
Only what you or the helper ask for: a web search (through a private SearXNG that runs on your own machine, though the search itself still goes out to the web), a fetch of a web page, a read-only request to a Google account you have connected, or a check for updates. With /airgapped on, none of these happens.
The model, your code, your questions and its answers stay on the machine where they are.
/airgapped on, enforced by the kernel| Working on code | ~48 tok/s |
| Writing code | 69 tok/s |
| JSON | 84 tok/s |
| Prose | 32 tok/s |
| Reading code | ~1,800 tok/s |
| Memory of the conversation | 262K |
These are speeds for one task at a time on a GB10. The model uses a trick called speculative decoding: a small helper guesses several words ahead and the big model checks all the guesses in one go. "Working on code" is measured over real helper sessions. Writing code, JSON and prose are each measured on that kind of output. The last line is how much text it can hold in mind at once, 262K tokens, which is a few hundred pages. Run four helpers at once if you like. There is no quota and no "please wait".
ragon update.| Cloud coding helpers | Ragon | |
|---|---|---|
| Where your code goes | Their computers | Nowhere |
| Account needed | Yes | No |
| Price for each token | You pay for each one | Nothing |
| Limits on how much you can use | Yes | No |
| Works with the network cable pulled (after the first download) | No | Yes |
| You can check for yourself what leaves | Not from your side | ragon-admin audit egress |
SWE-bench Verified is a set of 500 real problems taken from open-source programs. For each one, the helper has to change the code so that the tests pass. On 2026-10-08 we gave 100 of them to Ragon 1.5.1, using the Qwen3.8-27B model, on one DGX Spark with no internet. It had one try at each, in its default mode, and it solved 68 of the 100. If we scale that up to all 500, we estimate about 69%, give or take a few points (the 95% range is 63.9 to 73.4%). We measured this ourselves, on our own machine, on a sample of the problems. It is not an entry on the official leaderboard.
| System | Same 100 tasks | All 500 tasks |
|---|---|---|
| Ragon 1.5.1 + Qwen3.8-27B (NVFP4), one DGX Spark, offline1 | 68/100 | ≈69% estimated |
| Ragon 1.5.1 + Qwen3.8-27B (NVFP4), refine mode, one DGX Spark, offline1 | 69/100 | ≈70% estimated |
| Qwen3-Coder-480B-A35B (OpenHands)2 | 68/100 | 69.6% |
| GLM-4.6 (Z.ai's agent)3 | 68/100 | 68.2% |
| Kimi K2.5, high (mini-SWE-agent)4 | 70/100 | 70.8% |
| DeepSeek V3.2, high (mini-SWE-agent)5 | 70/100 | 70.0% |
| Claude Opus 4.5, four agents6 | 77–80/100 | 76.8–79.2% |
| Gemini 3 Pro (live-SWE-agent)7 | 79/100 | 77.4% |
| Smaller open models (20–40B parameters) | ||
| Qwen3-Coder-30B-A3B (EntroPO + R2E), test-time scaling8 | 60/100 | 60.4% |
| Qwen3-Coder-30B-A3B (EntroPO + R2E), single attempt8 | 56/100 | 52.2% |
| Devstral Small 2512 (mini-SWE-agent)9 | 57/100 | 56.4% |
| Coding-agent products, as their vendors publish them | ||
| GitHub Copilot agent mode (VS Code), with Claude 3.7 Sonnet10 | not published | 56.0% |
| Claude Code11 | not published | not published |
| Cursor12 | not published | not published |
Read this table as a way to see who is nearby, not as a ranking. On the same 100 problems, Ragon solved as many as Qwen3-Coder-480B and GLM-4.6, models many times its size. But every row uses a different helper program and different hardware, and the leaderboard rows used the official test images for x86 computers, while ours ran on community images for arm64. There is also a second mode, called refine. A first session studies the problem and changes nothing, then a fresh session does the work. It solved one more problem than the default (69 against 68, and each mode solved some problems the other missed), and it took about 2.2 times as long for each problem. So it is off unless you ask for it with ragon --refine.
100 problems are a fifth of Verified, so the figure for all 500 is an estimate. Here is how we made it. Take the results of all 175 public Verified submissions, problem by problem. Give every problem a difficulty and every system an ability, with a one-parameter item-response (Rasch) model. Ragon's ability is the one that would solve 68 on these 100 problems, and about 69% is what that ability would score on all 500. A plain regression on the published scores agrees to within a point. We also checked the method on others: for every public submission we used only its score on these 100 problems to predict its score on all 500. The error was 2.4 points (RMSE), and the range above is 1.96 times that on each side. Every number in the table can be reproduced by scripts/swe_bench_compare.py, from the public per-problem data in SWE-bench/experiments.
We spread the 100 problems over the programs in Verified in the same proportions as the full set. We drew them from the problems whose test setup works and checks out on arm64 (the correct fix passes, and doing nothing fails). Published systems score 1.0 to 1.5 points lower on these 100 than on all 500, so the sample is not an easy one. It is still not a leaderboard entry, because the SWE-bench team grades those on their own machines.
All leaderboard numbers: swebench.com and the SWE-bench/experiments repository; "same 100 tasks" is each submission's published per-task results restricted to the tasks Ragon ran.
dgxcoder · October 2026
We describe the design of Ragon Desktop, a desktop program that is open source. We give a formal list of what it can and cannot do, and we measure it. It speaks the same app-server protocol as the desktop client from the upstream vendor, keeps the same defaults as Codex, runs the model on the user's own hardware, and keeps every command in the sandbox on the workstation when the user types /airgapped on.
How to make a GB10 safe to load, how to start the model server, how to pair Mac, Linux and Windows computers with it, and how to run the egress audit.
Fit the Rasch item-response model yourself and reproduce every per-problem number in the benchmark table from the public SWE-bench experiments data.
Yes, to run the model. Your other computers are clients that borrow it: Linux (Arm or x86) and macOS with the same install command, and Windows (Arm or x86, preview) with the PowerShell line.
Yes. Puffin was renamed Ragon in 1.5. Run puffin update once, then run puffin one last time. It moves your sessions, settings and links across, and after that the command is ragon.
Nothing for the program or for the model. Ragon is open source under the AGPL, and the model's weights are free to use. You pay for the machine and the electricity it uses.
The operating system it comes with (DGX OS 7, or Ubuntu 24.04 where NVIDIA offers it), Docker with the NVIDIA Container Toolkit, Python 3 and Git. On plain Ubuntu, ragon-admin host check tells you what is missing.
Only what you or the helper ask for, such as a web search (through a SearXNG that runs on your own machine) and the downloads on first use. With /airgapped on, all of it is off.
Qwen3.8-27B, in NVIDIA's 4-bit format called NVFP4, served by our own engine, ragon-serve, with a small guessing helper called a DFlash2 drafter; SGLang stays as the fallback through 1.9.x. We chose and tuned all of it for the GB10. The weights take about 20 GB, and while it runs, about 38 GB of the machine's memory stays free.
If you think code should stay on the desk where it was written, star the repository on GitHub. That is how other GB10 owners find Ragon.
$ curl -fsSL https://github.com/dreamference/ragon/releases/latest/download/install.sh | bash