Stop tuning the model. The harness rewrites itself.

jcode boots Claude Opus in 14 ms, runs at 27.8 MB, and edits its own Rust source mid-session. Same model inside.

I believe this is the start of a sub-genre nobody is naming yet.

Quick context: The first era of LLMs was prompt engineering. Era two was context engineering. Era three is what we've all been arguing about all year, model picking, Opus 4.7 vs Gemini 3 Pro vs Kimi K2.6. Now, someone rebuilt the wrapper around Claude in Rust, and the gap on cold start, RAM, and per-session scaling is bigger than any model gap I've seen this year.

What jcode actually is:

- Coding agent harness, 94% Rust

- Custom terminal called handterm, custom Rust mermaid renderer

- Native logins for Claude, OpenAI, Gemini, Copilot, Azure, plus aggregator providers

- MCP works out of the box. Falls back to your existing .claude/mcp.json so anything you've already wired up keeps running

- Install via brew, curl, or cargo build. Single binary

- 3.3k stars on GitHub, 57 releases, actively maintained

The numbers (jcode vs Claude Code, from the README):

- Cold start: 14 ms vs 590 ms to 3.4 seconds. 42 to 245 times faster

- Idle RAM with local embedding off: 27.8 MB

- 10 sessions in parallel: 260 MB total vs 334 MB to 3.2 GB for Claude Code

- Per added session: 9.9 MB vs 76 to 318 MB

- Custom mermaid renderer the author claims is 1800x faster than browser-based versions

That last one is the kind of detail that tells you what they're really doing. Someone is going through every layer of the Claude Code experience and rebuilding it natively, and the gains compound.

What's actually different at the harness layer:

- Self-dev mode. Agents inside jcode can edit the harness's own Rust source, run cargo build, hot-reload the binary across active sessions without dropping you. The wrapper is recursively modifiable from inside the agent loop.

- Memory as semantic vectors per turn. Recall is automatic via cosine similarity. Not "remember to update CLAUDE.md". There's an ambient mode that consolidates memory and resolves conflicts in the background while you work.

- Multi-agent swarm with server-level coordination. When Agent A edits a file Agent B has read, B gets notified. Diff-based conflict resolution. Direct messaging between agents. Broadcast channels. If you've ever run parallel Claude Code sessions in the same repo and watched them clobber each other's edits, this is what that should have looked like.

- Native browser tool (Firefox only for now): snapshot, click, type, screenshot, eval, scroll, upload.

People have been arguing about self-improving agents on Twitter for two years. jcode is one. Small, downloadable, shipping.

A few cons before I keep going:

- Those benchmarks are the author's own. No independent verification yet

- Browser tool is Firefox-only

- Cross-harness session resumption between Codex, Claude Code, OpenCode, and pi is claimed in the README, but I haven't seen anyone walk through proof

Here's where it stops being just an interesting tool and starts being an actual sub-genre. The harness alone is half the story. Folder architecture sits one layer above it.

The ICM Methodology by Jake. Five layers:

- Layer 0: workspace identity (CLAUDE.md)

- Layer 1: task routing (CONTEXT.md)

- Layer 2: per-stage contract (what to read, what to do, what to write)

- Layer 3: reference material that captures your voice, your conventions, your skills

- Layer 4: per-run working artifacts

Same agent reads different context at each stage. The model never has to figure out what to load because the folder structure already decided. Liu et al's "lost in the middle" problem solved by construction, not by compression.

ICM customizes the workflow to you. jcode customizes the harness to you. They live at different layers and they compound.

What that actually means for someone using both daily:

- jcode's memory accumulates across sessions. Embeddings get richer the longer you use it

- Self-dev mode, in theory, lets the harness adapt to how you actually work

- ICM's Layer 3 reference material accumulates too. Voice files get specific. Stage contracts get tight. Skill files get added

- A year in, both layers have shaped themselves around your patterns. Same Opus 4.7 inside the whole time

That's the sub-genre. Personalized AI development environments where the model isn't the variable anymore. The model is the engine. The wrapper and the workflow scaffolding around it are where the compounding gain lives, and right now jcode is the only serious example I've seen of someone treating the harness itself as the optimization surface.

Personally I'm not switching off Claude Code today. I haven't run jcode in production, and "looks fast in benchmarks" is not the same as "holds up across a real week of work". But the stack I'm watching:

- personalized consumer harnesses

- ICM as the workflow scaffold

- Opus 4.7 inside

If you're running ICM already, you're a layer closer to this than you realize.

1 comment