jcode

jcode is a high-performance coder agent harness written in Rust, positioned to provide a more resource-efficient and scalable runtime environment for multi-agent development workflows. Website and documentation entry points can be found in the repository links such as Website, Docs, SDK, Benchmarks, Screenshots, Install, and Contributing, and an interactive showcase can be browsed at jcode.sh, with Windows installation instructions provided in a separate document.

Purpose and performance positioning jcode takes performance and resource efficiency as its core goals, optimizing various metrics around multi-session scaling scenarios. The comparisons given in the repository focus on sampled data in two areas: memory usage and startup speed.

Headless session (swarm worker) memory Swarm workers run in headless mode, which is a key metric when scaling the number of agents horizontally. In the test, each session completes 5 real model turns (list files, read files, search the repository, summarize, reply) with tool calls, and then the total PSS of all processes is measured. jcode sessions share one daemon; Claude Code runs one claude -p --input-format stream-json process per session. Both use claude-sonnet-4-6. Measurement time and environment: 2026-09-29, Linux, jcode v0.89.19-dev (default build, local embeddings not compiled), Claude Code 2.1.267; the reproduction script is python3 scripts/bench_headless_memory.py.

Startup speed The repository provides two metrics: "Time to first frame" and "Time to first input" (the time it takes for the probe text entered to appear on the rendered screen), both measured across 10 interactive PTY launches on the same Linux machine. Antigravity uses its internal input-ready log marker because the login screen suppresses probe echo; in that Antigravity CLI run, it was unauthenticated, the login screen rendered normally and emitted the internal "ready for user input" marker, but did not echo the entered probe text.

Multi-client memory extension The repository lists the clients and their versions used for comparison: jcode v0.9.1888-dev (be386f2), codex-cli 0.120.0, opencode 1.0.203, GitHub Copilot CLI (1.0.24 for the 1-session rerun, 1.0.27 for the 10-session rerun), Cursor Agent 2026.04.08-a41fba1, Claude Code 2.1.86, Antigravity CLI 1.0.0, along with a jcode performance demo.

Main capabilities

1. Multi-agent collaboration in the same repository: when two or more agents are started in the same repository, they are automatically managed by the server to enable native collaboration. When agent A edits a file that agent B has already read (the file changes under its feet), the server notifies B; B can judge it as irrelevant and ignore it, or view the diff to confirm there is no conflict. Each agent has messaging capabilities and can send a targeted private message to a specific agent, broadcast to all other agents hosted by that server, or send messages only to agents working in that repository. This makes it possible to start multiple sessions in the same repository and automatically resolve conflicts.
2. Autonomous swarm: agents have a swarm tool and can autonomously spawn their own teammates to complete tasks in parallel, with the main agent becoming the coordinator and the spawned agents becoming workers. Grouping, message channels, completion status, and so on are all managed automatically by the system, and it can run headless or headed.
3. Swarm mode and reasoning effort: root reasoning and worker execution effort can be configured separately, with settings for each mode in ~/.jcode/config.toml. Both default to max, and the accepted levels are none, minimal, low, medium, high, xhigh, max, mapped to the ranges supported by the provider. The effort switcher shows the configured root level, and these settings do not change the worker's swarm_effort. The environment variable overrides are JCODE_SWARM_ROOT_EFFORT and JCODE_SWARM_DEEP_ROOT_EFFORT.
4. OAuth and providers: supports a wide range of providers, including Claude OAuth and OpenAI Codex OAuth.
5. Self-development and extensibilityCustomization: jcode introduces a new form of customizability, not limited to what plugins or extensions can do. Put the jcode agent into self dev mode, and it will begin modifying its own source code. jcode is optimized for self-iteration, with extensive infrastructure built around self-development, able to edit, build, and test its own source code, then reload its own binary and continue working across your (possibly many) sessions, all automatically. The official recommendation is to use frontier models for this scenario: the jcode codebase is not simple, and weaker models may make subtle and destructive changes; GPT 5.5 or the latest frontier models work better.

Other detailed features

• Anthropic's Claude cache goes cold after 5 minutes; if you make a Claude request after 5 minutes, a cache miss will occur, which may consume a large number of tokens. The UI will remind you when the cache goes cold and notify you when an unexpected cache miss occurs.
• jcode comes with setup instructions for the Firefox Agent Bridge. After having the agent complete the setup, you can use browser automation in jcode.
• Agent grep is a grep tool developed for the jcode agent. It adds file structure information (such as a function list and their offsets) to grep results, allowing the agent to infer a file's purpose without actually reading the file; it also implements harness-layer integration, adaptively truncating results based on what the agent has already seen, thereby greatly saving context.
• Input is by default sent interleaved with the working agent: input is sent as quickly as possible without breaking the KV cache; if you instead submit with shift enter, it will be queued and sent after the agent fully finishes the current turn.
• Cross-framework session resumption: when Claude Code has problems, you can resume the session from jcode and continue. Session resumption supports codex, claude code, opencode, and pi.
• Not all skills are loaded at startup: sessions are embedded as semantic vectors, and when a similar embedding is hit, the skill is automatically injected (similar to a memory mechanism); the agent also has a skill tool to manually activate skills at any time, and skills can also be activated via slash commands.

Browser automation The built-in browser tools let the agent navigate pages, fill out forms, upload files, and take screenshots via the Firefox Agent Bridge. After having the agent complete the setup, it can directly handle browser tasks; see Browser Provider Protocol for details.

Use cases and limitations jcode is suitable for multi-session development workflows that need to run multiple coding agents in parallel and care about memory and startup overhead, as well as scenarios where you want to automatically coordinate conflicts among multiple agents within the same repository, or have agents autonomously form a swarm with divided labor. Self-development mode is suitable for iterating on itself using frontier models. Note that: for self-development scenarios, the official recommendation is explicitly to use frontier models, as weaker models may introduce destructive changes; session resumption only lists codex, claude code, opencode, and pi; browser automation depends on manual setup of the Firefox Agent Bridge; some performance data is qualified by specific versions, environments, and measurement times, and actual performance may differ. Information such as pricing, cost, and the specific list of supported platforms has not yet been provided.