jcode

Quick Verdict

jcode is best for developers who already live in a terminal coding agent and routinely run several sessions at once. It does not try to be another chat box that writes code; it treats the harness itself as an engineering problem — rewritten in Rust, resident memory pushed down to tens of megabytes per session, multiple agents in one repository coordinated by a server, and conversation history embedded so it can be recalled automatically. If you run one session at a time on small features, Claude Code or Codex already cover you and switching buys little. If you regularly fan five agents out across one repo and have been burned by RAM limits or lost context, it is worth a real trial.

Three caveats first. It is very young: the repository was created in early 2026 and the site still labels itself “under construction,” with docs and SDK pages incomplete. Every RAM comparison and every DeepSWE / Terminal-Bench number on the site and README is self-reported by the author with no third-party reproduction, so treat them as directional only. And it is a local MIT-licensed binary — all model capability comes from providers you connect yourself, with no bundled quota.

Best For

• Terminal-first developers: Prefer CLI/TUI workflows over clicking around an IDE
• Multi-agent users: Run parallel refactors, test backfills, or migrations in one repo and have hit file conflicts
• Local and self-hosted model users: Want Ollama, LM Studio, or a private OpenAI-compatible endpoint instead of vendor lock-in
• Resource-constrained setups: Running agents on a laptop or small server where RAM is the hard limit
• Not ideal for: people who need a GUI and visual project management; teams that require a mature, commercially supported tool; or newcomers who want one subscription and zero setup — provider config and memory tuning are hands-on here

Key Features

• Low-RAM multi-session: The author measures roughly 27.8 MB resident per session with local embedding off (167.1 MB with it on) against about 386.6 MB for Claude Code in the same test; the gap widens as sessions multiply, which is what makes “dozens of agents at once” plausible
• Swarm collaboration: Multiple sessions in one repository are managed by a server. When agent A edits a file agent B has read, B is notified and can ignore it or inspect the diff. Agents can DM each other or broadcast within the repo, and a lead agent can spawn its own workers
• Semantic memory instead of memory tools: Each turn is embedded as a vector and related entries are recalled from a memory graph by cosine similarity and injected automatically. A background side agent extracts, consolidates, and checks for staleness and conflicts, while explicit memory tools and prior-session search remain available
• On-demand Skills: Skills are not all loaded at startup — they are injected when the conversation embedding matches, or activated manually via tool or slash command, so the opening context stays lean
• Cross-harness session resume: Pick up sessions from Codex, Claude Code, OpenCode, or pi without re-explaining the task
• Self-dev mode: The agent can edit, build, and test jcode’s own source, then hot-reload its binary. The project recommends restricting this to frontier models
• Terminal craft: A side panel for live files, diffs, and inline mermaid rendering (the author wrote a dedicated mermaid-rs-renderer for it); info widgets that only occupy negative space; MCP support with tools advertised at startup to avoid prompt-cache misses

Use Cases

• Parallel refactors: A lead agent splits work and spawns workers per module, with conflicts surfaced by the server
• Long-running projects: Semantic memory keeps decisions and gotchas from days ago without re-briefing
• Handing work over: When a Claude Code session dies or hits limits, resume it inside jcode
• Context-cheap exploration: Its agent grep returns function lists and offsets alongside matches, so full files often need not be read
• Customizing the harness: Dislike an interaction? Have it enter self-dev mode and change the source instead of waiting on a plugin API

Pricing

jcode itself is MIT-licensed and free, with prebuilt binaries for macOS, Linux, and Windows 11 (curl -fsSL https://jcode.sh/install | bash, plus Homebrew and source builds). The cost sits on the model side. It supports subscription-backed OAuth for Claude, OpenAI/ChatGPT/Codex, Google Gemini, GitHub Copilot, Azure OpenAI, Alibaba Cloud Coding Plan, Fireworks, and MiniMax, direct API keys for OpenRouter, DeepSeek, Moonshot, 302.AI, Groq, xAI, and Cerebras among others, and local Ollama or LM Studio for zero marginal cost. Multi-account switching lets you move to a second subscription with /account when the first runs out. The site links a pricing page but publishes no tiers, and the planned paid surface (an iOS client) has not shipped — so do not plan around “it will always be free.”

Pros

• Rust implementation keeps memory and startup overhead clearly below peers, with the biggest edge in multi-session work
• Swarm addresses a real problem — several agents fighting over one repo — at the server level rather than by convention
• Memory is recalled passively instead of relying on the agent to call a tool, which saves tokens and behaves more predictably
• Broad provider coverage including China-reachable services and local models, with no vendor lock-in
• Sessions can be resumed from Codex, Claude Code, OpenCode, and pi, so migration is cheap
• MIT license allows free modification and internal distribution

Cons

• The project is young; the site calls itself under construction and docs, SDK, and iOS client are unfinished
• All performance and benchmark figures are author-reported with no independent verification
• Development is largely driven by one person, leaving maintenance and response times uncertain
• Self-dev and Swarm are powerful enough that misconfiguration does more damage than a typical agent
• Terminal only, with no GUI and no enterprise audit, SSO, or team management

Alternatives

FAQ

Is jcode free?

The tool is MIT-licensed and free, and no paid tiers are published. You supply model capability yourself, so cost depends on your subscription or API usage; local Ollama or LM Studio makes it effectively free.

Are the RAM and benchmark numbers trustworthy?

Treat them as directional. The RAM comparison, DeepSWE v1.1, and Terminal-Bench 2.1 figures are all self-reported by the author without third-party reproduction, and test conditions such as whether local embedding is enabled change results substantially.

Can users in China run it directly?

Yes. It is a local binary with built-in support for Alibaba Cloud Coding Plan, DeepSeek, MiniMax, Moonshot, and 302.AI, plus self-hosted OpenAI-compatible endpoints. Only Claude or OpenAI official subscriptions depend on overseas service reachability.

Can Swarm agents break each other’s code?

It reduces the risk without eliminating it. The server notifies agent B when agent A edits a file B has read, but whether to inspect the diff is the agent’s decision. You still need to review changes and run tests, ideally on a clean branch.

Is self-dev mode safe?

It genuinely edits, builds, and hot-reloads jcode’s own source, and weaker models can introduce subtle breaking changes. Use frontier models only, in a working copy you can roll back — not on the install you rely on daily.

jcode or Claude Code?

Choose Claude Code for stability, documentation, and vendor support. Try jcode for parallel sessions, tight memory budgets, provider freedom, or the ability to modify the harness. Sessions resume across both, so running them side by side for a week is the cheapest way to decide.

Bottom Line

jcode’s value is treating the agent harness as a performance and collaboration problem: memory that scales, agents that coordinate, memory that recalls itself, and providers that stay swappable. Those differences are concrete for anyone running several sessions a day and nearly invisible for occasional users. Test it the direct way — take one real multi-file refactor, run three agents on it, and judge whether the conflict notices help, whether memory actually removes repeated briefing, and whether RAM holds. If yes, keep it in rotation. If complete docs and long-term stability matter more, stay on a mature option and watch a few more releases.