jcode · inside the Agent OS

jcode — a full coding agent in 28 megabytes.

● RUST · 15K GITHUB STARS · RUNS CLAUDE-OPUS-5 ON YOUR SUBSCRIPTION

Claude Code idles at ~387MB of RAM and takes 3.4 seconds to boot. jcode does the same job in ~28MB and 14 milliseconds — with a semantic memory that recalls past sessions on its own, and a swarm mode where agents coordinate in the same repo. I wired it into the Agent OS on the Claude login I already pay for, then made it build the three showpieces below. Full tour.

A tiny glowing amber machine core on a pedestal outshining four huge dark iron machines behind it, weaving finished app windows out of light

~28MB per session (Claude Code: ~387)

14ms to first frame (245x faster)

+9.9MB per extra session — run ten

$0extra — your Claude login powers it

One of these bars is not like the others. Same job — a full agentic coding harness — at a fourteenth of the weight.

My story · why this matters

My Mac was full of elephants.

Before.

Every coding agent on my machine was a heavyweight.

One Claude Code session: ~387MB. Ten sessions: 2.3GB — my fans knew before Activity Monitor did.

Boot times measured in seconds. Multiply that across the fleet of agents the Agent OS runs, and RAM was the real limit on how much I could parallelise.

And every harness forgot everything between sessions unless I wired the memory myself.

Then a Rust harness with 15,000 GitHub stars showed up claiming 28MB.

After.

jcode is now a tab in my Agent OS, running claude-opus-5 on the subscription I already pay for.

It boots faster than my monitor refreshes. Ten sessions cost less RAM than one Claude Code.

Its memory graph recalls past work on its own — and every conversation lands in a History tab, named like fox, rhino, octopus, readable forever.

First day in, it shipped a luxury landing page, an award-style studio site, and a playable 3D racing game. Receipts below.

I · The Problem

The heavyweight tax on every agent you run.

Here's the ceiling nobody talks about.

AI coding agents are brilliant — and obese. Hundreds of megabytes each, seconds to boot, an Electron-sized footprint for what is, underneath, a loop that calls a model and edits files.

Run one, fine. But the whole point of an Agent OS is running many — a researcher here, a builder there, three more in the background.

At ~200-400MB a session, your RAM budget runs out long before your ambition does. Ten Claude Code sessions is 2.3GB. Ten OpenCode sessions is 3.2GB.

So you ration your agents the way you once rationed browser tabs.

jcode deletes that ceiling: ten sessions in 117MB — less than half of ONE Claude Code.

The fleet math: ten jcode agents cost less RAM than half of one Claude Code session. This is why swarms are its native mode.

THINKING IT? "RAM is cheap. Who cares about megabytes in 2026?"

One agent? Nobody. A fleet? Everything. Multi-session workflows scale by the marginal cost of the next agent — jcode's is ~9.9MB; Claude Code's is ~213MB. That's the difference between running three agents and running thirty on the same Mac.

And the same engineering shows up where you feel it every time: 14ms to a usable screen instead of 3.4 seconds.

II · What jcode is

A harness built like a race car, not a browser.

jcode is an open-source (MIT) coding agent written in Rust by one obsessive builder — 15,000 GitHub stars and counting.

Same shape as Claude Code: a terminal agent that reads your repo, writes files, runs commands, loops until done.

Completely different construction. No Electron, no Node runtime, no browser dependency — down to writing its own mermaid diagram renderer (1800x faster than the standard one) and its own terminal.

The result is a spec sheet that reads like a typo:

14 milliseconds versus 3.4 seconds. You press enter; it's already there — 245x faster to a usable screen.

And because every session costs ~10MB more, not ~213MB more, the multi-agent workflows the Agent OS is built around stop being a RAM negotiation.

III · The two killer features

A memory that recalls on its own — and a swarm that talks.

Light weight gets you in the door. Two features make jcode genuinely different.

The memory graph. jcode embeds every turn as a semantic vector into a graph of memories. Each new turn quietly queries that graph — cosine similarity — and injects what's relevant into the conversation. No memory tools to call, no token-burning recap: it just remembers, like a colleague would. A background sideagent extracts new memories on semantic drift and consolidates old ones — reorganising, catching staleness and conflicts. Traditional session search (RAG over past sessions) is there too.

The swarm. Spawn two or more jcode agents in the same repo and the server manages them natively: if agent A edits a file agent B has read, B gets notified and can check the diff. Agents can DM each other, broadcast to the repo, or spawn their own teammates — the lead becomes a coordinator, the spawned agents become workers, channels and completion states managed automatically.

Plus the long tail. Side panels that render live files and mermaid diagrams inline; info widgets that only occupy negative space; 1000fps rendering (no flicker, ever); voice dictation; an iOS client; and session resume that can pick up Claude Code's own sessions — Claude Code broke mid-task? /resume it from jcode and keep going.

The loop that makes it feel like a colleague: turns feed the graph, the graph feeds the next turn, a sideagent keeps it tidy.

THINKING IT? "Another CLI, another subscription. What does this one cost?"

Nothing. jcode is MIT-licensed open source, and it logs in with the accounts you already have — Claude, ChatGPT/Codex, Gemini, Copilot and more, OAuth included. Mine found my existing Claude Code login on disk and asked one consent question.

It's the same Opus-5-class brain you already pay for, in a body that weighs 14x less.

V · Inside the Agent OS

The new jcode tab — Terminal, Workspace, History.

Reading about a harness is not running one. jcode is now a first-class surface in my Agent OS, next to Claude, Codex and the rest of the fleet.

The jcode tab in the Agent OS, Workspace view: live previews of five builds — the Neon Drift racing game, Studio Ferox site, Aurum landing page and two animations

What you're looking at: the jcode tab's Workspace — every build as a live, running preview. Left to right: the NEON DRIFT racing game's controls screen, STUDIO FEROX's editorial hero, AURUM's gold landing page. All built by jcode, all playable in place.

Three views:

Terminal. Type what you want; the Agent OS spawns jcode run on the Claude provider and streams every event live — the model, the session name, the answer, the token counts. Same line-protocol terminal as the other Code tabs.

Workspace. Every project jcode builds lands here as a live iframe preview — not a file list. Games run, pages scroll, animations play, right in the grid.

History — the conversation archive. jcode names every session like a field agent — fox, rhino, octopus, tiger — and stores the full transcript. The History tab lists every session on the Mac with its model, age and working directory; click one and read the whole conversation. Nothing you do with jcode is ever lost.

The jcode History tab: ten sessions with animal names — monkey, puppy, scorpion, cat, seedling, ox, tiger — each showing model claude-opus-5, message count and working directory

The History tab — the conversation-history workspace. Ten sessions from today alone: monkey built the racer, puppy built Ferox, cat built Aurum. Every row is a full, readable transcript on claude-opus-5.

The wiring in one picture: one tab in, builds and conversations out — everything kept.

VI · The proof

Day one, jcode shipped these.

Spec sheets are marketing. Builds are receipts. Three one-prompt builds from the tab, all on claude-opus-5 through jcode:

AURUM — a luxury dark-and-gold SaaS landing page with serif headline Every dollar your agency earns and a floating analytics dashboard mock

AURUMluxury SaaS landing — serif editorial type, floating dashboard, count-up stats, pricing

STUDIO FEROX — brutalist editorial site with massive stacked headline WE MAKE BRANDS IMPOSSIBLE TO IGNORE and a vermilion accent bar

STUDIO FEROXaward-style studio site — giant type, live clock, marquee, custom cursor

NEON DRIFT — a three.js racing game mid-race: chase camera behind a car with glowing rear lights, neon city, HUD showing 4th place lap 2 of 3, minimap

NEON DRIFTplayable three.js racer — AI rivals, laps, minimap, drift trails, boost pads

The racer has the best story. Its first version crashed the moment you pressed START — a classic undefined error every frame.

So I did what the Agent OS does on GoldieBench: fed the console error back to jcode in the same project. It read its own file, diagnosed the root cause (an uninitialised speed turning a waypoint index into NaN), made nine surgical edits, and explained the fix.

Second playtest: START works, the car drives, drift trails burn into the tarmac, the HUD says 4th · LAP 2/3. The harness debugged its own game.

THINKING IT? "So the builds are really Claude's work — what did jcode add?"

Correct — the brain is claude-opus-5. That's the point: jcode is the harness, and the harness is what you feel. It booted instantly, streamed the whole build at ~28MB, saved every session transcript automatically, and fixed its own build when handed an error.

Same brain you already pay for. Dramatically better body — and one that lets you run ten of them at once.

VII · Old way vs new way

What changes on your machine.

OLD WAY heavyweight harnesses

~200-400MB of RAM per agent session
Seconds of boot before you can type
Three parallel agents and the fans spin up
Sessions forgotten unless you build memory yourself
Agents in one repo trample each other's edits
A crashed harness means a lost session

NEW WAY with jcode in the Agent OS

~28MB a session; +9.9MB per extra one
14ms to first frame — instant, every time
Ten sessions cost less than one Claude Code
A memory graph that recalls past work on its own
Swarm mode: agents that notify, DM and coordinate
Every conversation archived in the History tab — and it can even resume Claude Code's own broken sessions

VIII · Three beliefs to drop

What's actually holding you back.

Wrong: "The harness doesn't matter — only the model does."

Right: The model sets the ceiling; the harness sets how many ceilings you can run at once. Same Opus-5 brain, 14x less weight = a fleet instead of a session.

Wrong: "Switching harnesses means abandoning my setup."

Right: jcode logged in with my existing Claude credentials, imported MCP servers from Claude Code's config, and can literally resume Claude Code's sessions. It joins your stack; it doesn't replace it.

Wrong: "One-developer projects are toys."

Right: This "toy" ships its own mermaid renderer, its own terminal, an iOS client and a 15K-star repo — and its benches are published with methodology, versions and ranges. Judge the receipts, not the headcount.

Don't take my word for it

Members post their wins every day — agency owners, ecom founders, course creators, solo operators across 38 countries. Real businesses, real numbers, in their own words.

Read the 158-page wins doc →

IX · Build it yourself

jcode on your Mac — ten minutes.

Install. curl -fsSL https://jcode.sh/install | bash — one line, macOS or Linux (Windows has a PowerShell one-liner). You even get a global hotkey: Cmd+; launches jcode from anywhere.

Log in with what you already have. Run jcode login --provider claude. If you use Claude Code, jcode finds those credentials and asks one consent question — approve it and you're running claude-opus-5 on your existing subscription. ChatGPT/Codex, Gemini and Copilot logins work the same way.

First run. jcode opens the TUI; jcode run "say hello" is the one-shot mode. Boot is instant — that's not your machine being fast, that's the harness being 28MB.

Learn the resume trick. Every session gets a memorable name. jcode --resume fox picks one back up — and it can resume sessions from Claude Code, Codex, OpenCode and pi too. A crashed harness no longer costs you the conversation.

Try the swarm. Open two jcode sessions in the same repo. Edit a file one of them has read — watch the other get notified. That's the collaboration layer every multi-agent setup wishes it had.

Or skip it all. The Agent OS ships the tab pre-wired: type in the Terminal, watch builds land in the Workspace, read every conversation in History.

THINKING IT? "Is letting it read my Claude credentials safe?"

It's an explicit, one-time consent — jcode found the credential file and refused to touch it until approved. The code is MIT-licensed and public; you can read exactly what it does with the token. It refreshes and validates the login with a smoke test before ever running a task.

That's more transparency than most closed tools give you about your own account.

X · Should you bother?

If you run more than one agent — yes.

jcode doesn't replace your brain. It replaces the 387MB wrapper around it.

Same models, same logins, same repos — in a body that boots in 14ms, remembers what you did last week, and scales to a ten-agent swarm on a laptop.

The heavyweight era of coding agents is going to look very silly in about a year. This is what the lightweight one looks like.

XI · What you walk away with

The recap.

You dropped 14x the weight.

~28MB a session vs ~387MB — ten sessions for half of one.

You got instant boot.

14ms to first frame. 245x faster than the heavyweight.

You got real memory.

A semantic graph that recalls past sessions without being asked.

You got a swarm.

Agents that notify, DM and coordinate in the same repo.

You kept your logins.

Claude, Codex, Gemini, Copilot — OAuth you already have. $0 extra.

You got the archive.

Every conversation named and kept — the History tab in the Agent OS.

4,000+ founders inside AIPB
400K YouTube subscribers
38 countries · live members
163K X followers