jcode Coding Agent
The most RAM-efficient terminal coding agent with multi-agent swarm, memory, and self-improvement.
Evidence shows permission request mechanism (autoApprove in SDK tests), but no default least-privilege policy or detailed user confirmation. Data flow transparency limited, sensitive data handling not specified. Dependency security has cargo-audit in CI but no specific vulnerability reports. External effects (e.g., file modifications) not explicitly restricted. Rollback mechanism not mentioned. Source attribution only via MIT license and author name, unverified.
Self-consistency good, README and Cargo.toml descriptions align, but version inconsistency (README mentions v0.9.1888-dev, Cargo.toml 0.71.1). Dependency availability ensured via Cargo.lock and CI, but no offline install option. Failure messages handled in SDK tests but not comprehensive.
Target audience clear (developers), scenarios include multi-session, swarm. Capability boundaries via tool list and config, but not explicit limits. Trigger precision via commands and config, but not detailed. Environment fit supports Linux/macOS/Windows, but no detailed system requirements.
Information architecture clear, README and docs links. Install notes detailed, multiple methods. Naming stable but version inconsistency. Examples and FAQ partial, missing FAQ. Known limitations not explicitly listed. License MIT, but no changelog. Maintenance responsibility unclear.
Output usability via SDK and CLI, but no actual output examples. Marginal value high, emphasizes RAM efficiency. Cost-benefit not quantified, but performance data supports.
Claim traceability limited, performance data not raw. Cross-source corroboration insufficient, only README. Fact-inference separation unclear, performance claims may be based on internal tests.
- Version inconsistency: README claims v0.9.1888-dev, but Cargo.toml is 0.71.1, may cause confusion.
- Performance data lacks raw measurement details, cannot be independently verified.
- No explicit least-privilege policy or detailed user confirmation process documented.
- Dependency security only via cargo-audit in CI, no specific vulnerability reports.
What does this agent do, and when should you use it?
jcode is a Rust-based terminal coding agent framework that prioritizes extreme memory efficiency and fast startup while offering a full-featured agent experience. It includes a built-in memory system using semantic vector retrieval, multi-agent swarm collaboration, MCP support, OAuth logins (Claude, OpenAI, Google, etc.), browser automation via Firefox Agent Bridge, and self-modification capabilities. Its performance advantages are demonstrated with benchmarks: only 27.8 MB PSS for a single session and 14 ms time to first frame. Being fully open-source under MIT, it allows deep customization, even enabling the agent to modify its own source code.
jcode runs as a terminal TUI or in non-interactive mode with commands like jcode run, jcode serve, jcode connect. It embeds each turn into a semantic vector, builds a memory graph, and automatically retrieves relevant memories via cosine similarity. It supports swarm mode where multiple agents collaborate in the same repo with conflict resolution. It provides OAuth login via jcode login --provider ..., MCP config at ~/.jcode/mcp.json, and a browser tool set up with jcode browser setup. It can resume sessions from other agents like Claude Code and Codex, and offers scriptable login flows with --print-auth-url.
- Developers running multiple agent sessions on resource-constrained machines.
- Long-term projects where the agent must remember context without repeated explanations.
- Teams needing parallel agent edits on the same repository with automatic conflict detection.
- Developers who want the agent to modify its own source for autonomous iteration.
- Users needing browser automation within the coding agent, such as testing web apps.
- Headless or SSH environments where OAuth login must be scripted.
What are this agent's strengths and limitations?
- Extreme memory efficiency: 27.8 MB PSS per session, far less than alternatives.
- Built-in memory with automatic semantic retrieval, no need for explicit tool calls.
- Swarm collaboration with automatic conflict resolution across multiple agents.
- Supports OAuth with many providers, including self-hosted OpenAI-compatible endpoints.
- Capable of self-modification, enabling autonomous development iterations.
- Complex Rust codebase; self-modification requires a frontier model.
- Windows install needs PowerShell 5.1+ and may trigger Defender/SmartScreen warnings.
- Browser automation currently only supports Firefox Agent Bridge; other backends pending.
- MCP only supports stdio servers; HTTP/SSE entries are skipped.
- Some benchmark methodology may need independent verification.
How do you install or deploy this agent?
macOS/Linux: curl -fsSL https://jcode.sh/install | bash. Windows (PowerShell): irm https://jcode.sh/install.ps1 | iex. macOS Homebrew: brew tap 1jehuang/jcode && brew install jcode. From source: git clone https://github.com/1jehuang/jcode.git && cd jcode && cargo build --release. Requires Rust toolchain.
How do you use this agent?
Launch TUI: jcode. Run a single command: jcode run "say hello". Resume a session: jcode --resume fox. Server mode: jcode serve then jcode connect. Dictation: jcode dictate. Log in with provider: jcode login --provider claude etc. Configure MCP: edit ~/.jcode/mcp.json. The agent can automate most setup; see README for a detailed bootstrap prompt.
How does this agent compare with similar options?
Compared with pi, Codex CLI, OpenCode, GitHub Copilot CLI, Cursor Agent, Claude Code, and Antigravity CLI, jcode shows significantly lower RAM usage and faster startup times.
FAQ
What model providers does jcode support?
jcode login --provider.How does jcode's memory system work?
How does jcode handle multi-agent conflicts?
Can I use it on a headless server?
--no-browser and scriptable login flows.