How Heavy Is the Harness? We Put 10 AI Coding Tools' Installers on the Scale

Put a harness on a horse and it can pull a cart; put a harness on a large model and it can actually get work done on your machine — reading and writing files, running commands, triaging samples. The wave of AI coding tools that has appeared over the past two years is, at heart, exactly this kind of "harness."

Harnesses come light and heavy. We spend all day talking about how strong the model is and how long its context runs, yet almost nobody weighs the harness itself: to bring one onto your machine, how big a package do you have to download first? It looks like a small thing, but it decides very real ones — how long the download takes, how you distribute it on an intranet, whether an aging machine can carry it, and how much every daily update hurts.

So we did the plodding thing: on the same day, we took the latest installers of the 10 AI coding tools we could find and put them on the scale, one by one.

The Weigh-In Rules

• Every vendor's latest distribution was downloaded on the same day; same tier per platform: Apple Silicon (arm64) on macOS, x64 on Windows.
• Measured in bytes and converted to decimal MB (1 MB = 1,000,000 bytes — the same convention Finder uses).
• What we weighed is "the package you actually download": some are .dmg / .exe / .msix installers, some are zips or single-file binaries — the formats differ slightly, but they all answer the same question: to put on this harness, how big a box do you haul through the door first?
• Note that atomcode and mimocode are CLI/TUI tools that run inside a terminal, with no standalone graphical window; they're listed as reference points only. The real head-to-head is among GUI clients with a full desktop interface.

Full disclosure: we're not measuring installed footprint on disk, and we're not reviewing how good these tools are — only the weight of step one.

One Chart: Who's Traveling Light

Lay the macOS packages out by size and the picture is blunt: the two CLI/TUI tools (atomcode, mimocode) and AVL Code huddle together at the far left around 30 MB, then comes a cliff — no other name appears until 144 MB. Between 33 MB and 144 MB, there is nothing.

The meaning is plain: atomcode and mimocode run in a terminal with no graphical window of their own — being small is simply their duty. AVL Code, though, is a GUI client with a full desktop interface, yet it sits in the same weight class as those two CLI/TUI tools. Among all desktop GUI clients it is the lightest — the second lightest, OpenCode (143.9 MB), is already 4.4× its size, and the heaviest, Codex (529.7 MB), is 16×. Windows tells the same story: at 29.8 MB, AVL Code is still the lightest GUI client, the next one up (OpenCode) is again more than 4× away, and WorkBuddy (512.1 MB) is 17×.

Why do GUI clients span a full order of magnitude? One sentence: most of them pack an entire browser engine and runtime into the box; AVL Code doesn't. What the big package buys is a highly consistent cross-platform experience — that's its cost, and its confidence. But if you care about the box-hauling step, the difference is very real.

The Numbers, Both Platforms

Units: decimal MB. Package formats: AVL Code / mimocode ship as zip, atomcode as a single-file executable, the rest as platform installers (.dmg / .exe / .msix). On Windows, Claude was measured as .msix.

Why AVL Code Is Light

Next to CLI/TUI tools living in a terminal, being small is no great feat. What makes AVL Code different is this: it's a desktop client with a full graphical interface, yet its installer is squeezed down to CLI/TUI scale.

That wasn't brute-forced out; it was chosen. AVL Code's desktop app is built on Wails v2 + Go and reuses the system's native WebView, instead of carrying a whole extra browser through the door. The tens or hundreds of megabytes saved turn into a few concrete good things:

• Fast downloads: sign in with a phone number, zero-config, ready to go — step one doesn't begin with waiting for a half-gigabyte package to land;
• Light distribution: plenty of teams run it on intranets and in air-gapped environments; a 30 MB package copies, stages and rolls back briskly;
• Painless updates: we hold ourselves to at least one release a day (six on our busiest day); the thinner the base, the lighter each incremental update — daily updates won't drain your bandwidth or your patience;
• Old machines can carry it: the security crowd digs up plenty of "antique laptops" and potato-grade rigs — only light gear runs there.

A harness exists to get work done, not to crush the animal wearing it. When you harness a donkey, there's no need to dress it in a full suit of armor.

Restraint, Chosen Through Engineering Practice

The "light" installer is only the most visible layer of this restraint. The same engineering habit hides in plenty of places you never see — saving whatever can be saved, again and again, and handing the spared tokens, compute, memory and bandwidth back to the task itself. This restraint isn't a posture; it's a habit. Open the changelog and you'll find it in one concrete trade-off after another:

• Tokens saved in transit: we built the AVL Delta efficient transfer protocol — each turn sends only that turn's new content, never re-sending stable history; we reworked timestamp injection in the system prompt for optimal prefix-cache hits; and we keep "improving KV-cache effectiveness so long conversations run faster and cheaper." Every scrap of context budget saved goes back to the thing you actually came to do.
• Memory saved at runtime: ultra-long sessions moved to paged, on-demand loading, backed by underlying indexing and deduplication — opening and scrolling stay responsive, instead of dumping thousands of messages into memory in one go.
• Even the front-end got slimmed: in one release we cut the first-screen main chunk from 1041 KB to 445 KB — a number no user will ever see, and we still earnestly trimmed away more than half of it.
• The main stage stays with the task: long-running work is handed to background sub-agents, paired with a dedicated TaskWait tool that waits for "all done" or "any done" — intermediate output never floods back into the main conversation, so neither your attention nor the model's context gets drowned in progress logs.

Each of these is small on its own; together they add up to one sentence: restraint isn't doing less — it's spending every resource where it counts. What a good harness should do is let the animal spend its strength pulling the cart, not hauling its own tack.

Travel Light, Run Long

The contest of models is still at full boil, but the client — this harness — doesn't get better by getting heavier. A little lighter: downloads a little faster, distribution a little cheaper, updates a little more frequent, running a little longer — that's the restraint we set for ourselves.

Want to try a harness that weighs just 30 MB? Download the desktop app and sign in with your phone number; during the beta, the Zero starter plan is free for a limited time — zero configuration to finish your first hands-on session.

We're waiting for you at avlcode.cn — riding a donkey, in a harness that weighs next to nothing.

AVL Code — the AVL security engine, with intelligence at your side. From the Antiy Landi team. Sizes measured from each vendor's public distributions on June 26, 2026; figures may change as versions update.