JCode: The Rust Coding Agent That Uses 20× Less Memory Than Claude Code

Links & Resources

• JCode GitHub
• Discord
• Handterm (Custom Terminal)
• Install Script

A solo developer just rebuilt the entire layer between you and your AI model - from scratch, in Rust. The result is JCode, an open-source coding agent harness that uses 20× less memory than Claude Code and spawns 63× faster than Codex CLI.

7.1K stars · 794 forks · 4,626 commits · 94 releases · MIT License

What Is a Harness and Why Does It Matter

Tools like Claude Code, Codex CLI, and Cursor all have a layer between you and the AI model. That layer handles your prompts, your tools, your memory, your file access, and your sessions. It's called a harness.

The AI model is the brain. The harness is everything else - and it determines how fast you can work, how much RAM gets eaten, and how many sessions you can run simultaneously.

JCode rebuilt that entire layer in Rust. Not a wrapper. Not a fork. A ground-up rewrite of the harness architecture. The performance numbers speak for themselves.

The Benchmarks

Tested on Linux across 10 interactive PTY launches. Versions: jcode v0.9.1888-dev, Claude Code 2.1.86, Codex CLI 0.120.0, Pi 0.62.0, and 5 other agents.

RAM Usage - 1 Active Session

RAM Usage - 10 Active Sessions

This is where JCode's Rust architecture really shines:

At 10 sessions, Claude Code eats 2.3 GB. JCode uses 117 MB. That's a 20× difference.

Startup Speed

JCode renders its first frame in 14 milliseconds. Claude Code takes 3.4 seconds. That's not a rounding error - it's a 245× difference.

Extra RAM Per Additional Session

Every new Claude Code session costs 213 MB of RAM. Every new JCode session costs 10 MB. You could run 20 JCode sessions for the RAM cost of one Claude Code session.

The Killer Feature: Swarm

JCode doesn't just run one agent. It runs teams of agents that collaborate on the same codebase.

Here's how it works: you spawn 2+ agents in the same repo. The JCode server automatically manages them. When agent A edits a file that agent B has read, agent B gets notified of the code shift. It can check the diff and adjust, or ignore if irrelevant.

Agents can message each other - DM one agent, broadcast to all, or broadcast to agents in the same repo.

But the real power move: agents can spawn their own teammates. One agent becomes the coordinator, the spawned agents become workers, and they all collaborate autonomously. Groups, messaging channels, and completion statuses are all managed automatically.

Run them headlessly for background work, or headed to watch the swarm in action.

Built-In Memory System

JCode has a native memory system with zero extra setup:

How it works: Every turn and response gets embedded as a semantic vector. On each new turn, JCode queries a graph of memories using cosine similarity to find related entries and injects them into the conversation context.

Memory extraction happens automatically - triggered by semantic drift, a set number of turns, or session end. A memory sideagent extracts entries and stores them in the graph.

Active memory tools let the agent explicitly search or store memories, not just rely on the passive background process.

Session search provides traditional RAG across all previous sessions.

Automatic consolidation runs in ambient mode - reorganizing, checking for staleness, resolving conflicts.

Skills are also loaded dynamically via the same semantic vector matching system.

Every Provider You Can Think Of

JCode has built-in OAuth login flows for the major providers and supports dozens more through OpenAI-compatible endpoints:

First-party integrations: Claude, OpenAI/ChatGPT, Google Gemini, GitHub Copilot, Azure OpenAI, Alibaba Cloud, Fireworks, MiniMax, LM Studio, Ollama

OpenAI-compatible profiles: OpenRouter, DeepSeek, Kimi, Moonshot AI, HuggingFace, Nebius, Scaleway, Groq, Mistral, Perplexity, Together AI, Deep Infra, xAI, Cerebras, Chutes, and more

Also supports: NVIDIA NIM (including DeepSeek-V4 reasoning models), Cursor, Antigravity CLI, any custom OpenAI-compatible endpoint

Multi-account switching is built in. You can have Claude, GPT, and Gemini accounts all connected simultaneously.

More Features

Browser Automation - Built-in browser tool using Firefox via Firefox Agent Bridge. Full suite: open pages, take screenshots, click elements, fill forms, evaluate JavaScript, scroll, upload files.

Session Resume - Resume sessions from other harnesses. Migrating from Claude Code, Codex, OpenCode, or Pi? JCode can pick up where they left off.

Self-Development - Agents can modify their own source code. The infrastructure handles edit → build → test → reload binary → continue work across sessions automatically. (Recommended with frontier models.)

Mermaid Diagrams - Inline rendering using a custom Rust library that's 1,800× faster than the JavaScript implementation. No browser dependency.

Side Panels & Widgets - File viewer, diff viewer, real-time updates, all rendering at 1,000+ fps using a custom terminal implementation.

Voice Input - jcode dictate for voice-to-code via configured STT.

Install

macOS & Linux (One Line)

curl -fsSL https://raw.githubusercontent.com/1jehuang/jcode/master/scripts/install.sh | bash

macOS via Homebrew

brew tap 1jehuang/jcode
brew install jcode

Windows (PowerShell)

irm https://raw.githubusercontent.com/1jehuang/jcode/master/scripts/install.ps1 | iex

From Source

git clone https://github.com/1jehuang/jcode.git
cd jcode
cargo build --release

Quick Start

jcode                          # Launch TUI
jcode run "say hello"          # Non-interactive
jcode --resume fox             # Resume a session
jcode serve                    # Persistent server
jcode connect                  # Connect to server
jcode dictate                  # Voice input

Platform Support

Why Rust Matters Here

Every other major coding agent harness is built in JavaScript/TypeScript (Claude Code, Codex CLI, Copilot CLI, OpenCode) or uses Electron-style runtimes. JavaScript carries a V8 overhead per process. When you run 10 sessions, you're running 10 V8 instances.

Rust compiles to a native binary. One process, minimal overhead, shared memory where possible. That's why the gap between JCode and everything else gets wider with every additional session.

At 1 session, JCode uses 14× less RAM than Claude Code. At 10 sessions, it uses 20×. At 20 sessions, the math only gets more brutal for the JS-based harnesses.

Follow AI Adventure YT for more AI breakdowns and guides.