Open-source terminal harness — any model, even local
A Rust-built terminal coding agent designed as a 'harness' — its job is squeezing the most useful output out of whatever model you connect, whether that's your own key, an existing subscription, or a fully local model.
jcode is an open-source terminal coding agent — a Rust "harness" by Solo Systems (MIT-licensed, 8,600+ GitHub stars since its January 2026 launch) built to extract the most useful work from whatever model you point it at. Bring your own API key, reuse a Claude or OpenAI subscription via OAuth, or run fully local models through Ollama or LM Studio — so your code and your costs stay on your own machine. It adds persistent memory, side panels, background tasks, and swarm coordination (many agents in parallel), speaks MCP, and installs with one command on macOS, Linux, or Windows. → Brand-new and terminal-only: expect a smaller ecosystem and more churn than Aider or Claude Code.
Keeping code and cost local: run local models via Ollama or LM Studio, bring your own key, or reuse an existing Claude / OpenAI subscription via OAuth — plus memory, background tasks, and agent swarms for harder jobs.
It packs a lot of moving parts for something this new — persistent memory, background tasks, swarm coordination — feature depth an early, small-ecosystem tool hasn't had much time to prove out yet.
The software is free and MIT-licensed with no feature gates. Optional hosted-token plans (Plus $10 → Flagship $1000/mo) only pre-pay hosted model usage — not needed if you use your own key or local models.
Install JCode and make it executable from every command line session
jcode can route requests to any compatible AI provider, including locally hosted models via Ollama.
You will have jcode connected to an Ollama‑served model and ready to generate code locally.
ollama pull llama2) so it is available locally.jcode.toml in your home directory.
[providers.ollama]
endpoint = "http://127.0.0.1:11434"
model = "llama2"
``jcode status to confirm the Ollama provider is recognized.jcode status output lists the Ollama provider with a green check, indicating successful connection.Produce a Rust factorial function without opening the UI
jcode includes a file operation tool that can read, write, and patch files from the terminal.
You will modify an existing Rust file through a jcode command without opening an editor.
hello.rs containing fn main() { println!("Hello"); }.jcode tool file edit hello.rs "replace 'Hello' with 'World'".cat hello.rs.rustc hello.rs && ./hello.hello.rs now contains println!("World"); and executing it prints World to the console.Start three JCode agents that edit the same project without manual merges
31 outcomes in all — one per recipe below.
First, ensure the Rust toolchain (rustup) is installed, then clone the jcode repository and build it in release mode with `cargo build --release`. Copy the resulting binary (`target/release/jcode`) to a folder that’s in your PATH. Finally, run `jcode serve` to launch the local server and interact via the CLI or an HTTP client.
Semantic memory stores each AI response as a vector embedding and indexes them using cosine similarity, allowing instant retrieval of related past interactions. Start jcode with the `--memory-dir` flag pointing to an empty folder (e.g., `jcode serve --memory-dir ./jmem`). The agent will automatically embed responses, save them, and query this store on later prompts.
Yes; each jcode session uses less than 10 MB of RAM, so you can launch several agents that communicate via the built‑in server. Start one agent on a port (e.g., `jcode serve --port 8000`) and another on a different port pointing to the first with `--peer`. Configure webhooks or messages so edits from one agent trigger conflict‑resolution checks in the other.
After logging into an LLM provider and selecting a model, type a natural‑language request like “build a full‑stack React PDF editor in browser, create the necessary files” at the jcode prompt. The agent will scaffold the project, generate backend and frontend code, install dependencies, and run the appropriate start command. When it reports completion, you can open the folder in your editor and launch the development server to see the app running.
Need a tiny, instant offline AI code helper
jcode is an open‑source AI coding assistant written in Rust that runs with a tiny memory footprint (≈28 MB) and starts up in ~14 ms. Installing it gives you a fast, offline‑capable code generation tool.
Need code suggestions that remember earlier edits
jcode stores each AI response as a vector embedding and indexes them with cosine similarity, allowing instant retrieval of related past interactions without consuming token quotas.
Multiple bots editing the same file cause clashes
Because each jcode instance uses <10 MB per session, you can run several agents that communicate via the built‑in server; one agent edits code while another watches file changes and resolves conflicts in real time.
jcode starts in ~14 ms and uses ~27.8 MB RAM per session, far lower than alternatives; measuring these metrics confirms the efficiency claims.
Want dozens of coding helpers on your laptop
JCode is a lightweight coding harness that uses only ~27 MB of RAM per agent, allowing you to launch dozens of agents simultaneously on typical consumer hardware. It avoids cloud rate limits by running local models and manages resources efficiently.
API rate limits slow my coding assistant
Because JCode abstracts model loading, you can change which LLM powers your agents without restarting the whole system. This lets you bypass API rate limits or cost spikes by swapping to a locally hosted open‑source model instantly.
Need a quick one‑line installer for a command‑line agent
JCode provides a one‑line installer for macOS/Linux via curl and a PowerShell command for Windows, plus Homebrew support. This makes setup fast and avoids manual compilation.
Need help editing code from the terminal
After launching `jcode`, the tool opens a custom terminal UI that shows file diffs, side panels and even renders mermaid diagrams inline, letting you converse with the agent as if it were an IDE assistant.
JCode stores vector embeddings of conversation snippets and performs passive semantic search, so relevant memories are pulled into new chats without extra tool calls. This reduces re‑explaining context.
Swarm mode launches several JCode instances that coordinate via built‑in conflict detection; when one agent edits a file another is reading, it notifies the second agent and they can message each other to avoid race conditions.
JCode includes a headless Firefox backend that can take page snapshots, click elements, fill forms, run JavaScript and capture screenshots, all without extra extensions or MCP servers.
In self‑dev mode the agent can edit its Rust source files, invoke `cargo build`, and reload the binary on the fly, enabling it to evolve without stopping your session.
Using `jcode run "<prompt>"` you can feed a single instruction to the agent and get back generated code or edits, which is handy for automation scripts or CI pipelines.
The `--resume <session_name>` flag reloads prior memory, file context and chat history so you can pick up exactly where you left off, useful for long‑running projects.
Running `jcode serve` starts a local server that accepts API calls, allowing you to trigger agent actions from other tools or mobile devices while the main process stays running.
Want a command‑line tool ready instantly
On macOS and Linux, J Code provides a one‑line curl script that downloads the binary, makes it executable, and places it in your PATH. This works because the script bundles the appropriate prebuilt release for your platform.
J Code embeds each term of a dialogue as a high‑dimensional vector and stores it in a similarity‑based index. Retrieval works by finding the nearest vectors, letting the agent recall relevant prior statements without explicit prompts.
Ambient mode periodically re‑indexes stored vectors and prunes low‑relevance entries, preventing stale or noisy memories from dominating retrieval. This continuous maintenance improves response relevance over long sessions.
J Code detects fenced Mermaid code blocks in its output and passes them to an embedded renderer, which converts the text description into SVG and injects it directly into the UI side panel. This gives instant visual feedback without leaving the editor.
The swarm feature launches several independent J Code instances that share a common task queue and use conflict‑resolution logic to edit files without stepping on each other’s changes. It enables parallel problem solving while maintaining consistency.
Want an AI coding assistant ready instantly
J Code provides a single-line installation script that clones the repository, installs dependencies, and sets up the CLI. Because it bundles everything needed, you avoid manual setup steps and can start using the tool immediately.
Want several bots to work together in one project
Swarm mode lets several J Code agents share a repository, automatically notifying each other of file changes and allowing direct messaging. This coordination mimics a team of developers, enabling faster parallel work without conflicts.
I need to reference earlier code in a chat
Each turn of interaction is embedded as a vector and stored in a graph database. On every new request, J Code queries this graph to retrieve relevant context, eliminating the need for external memory tools and reducing token usage.
Chat history gets too long and costly
JCode embeds each conversational turn as a semantic vector and uses cosine similarity to retrieve only the most relevant past memories, avoiding dumping the entire history into the prompt. This reduces token usage and cost while keeping recall sharp.
Memory store gets cluttered and slow
Ambient mode runs as a low‑priority background task that reorganizes stored memory vectors, removes outdated entries, and resolves conflicts, mimicking human sleep‑based consolidation.
Terminal UI diagram rendering is slow
JCode replaces browser‑based rendering with a zero‑dependency Rust library that parses Mermaid syntax and draws directly to the terminal, achieving up to 1 800× speed gains.
Multiple AI agents editing one codebase
JCode’s server acts as an air‑traffic controller: it notifies agents of code changes, auto‑resolves edit collisions, and lets a primary agent spawn subordinate workers to divide tasks.
Want the AI to update its own code while running
In self‑dev mode JCode edits its Rust source, compiles the changes, runs tests, and hot‑reloads the binary, enabling on‑the‑fly optimization of its core engine.
Want to run AI code generation from your command line
The JCode binary can be downloaded as an EXE (or appropriate package for Mac/Linux) and placed in any project folder. Running the executable launches a CLI that interacts with LLM providers, enabling code generation directly from the terminal.
Can't access OpenRouter models
JCode supports multiple LLM providers; configuring OpenRouter gives free access to many models. After issuing `/login`, you paste the generated API key, and JCode stores it for subsequent calls.
Describe your web app in plain English
After configuring a model, you can ask JCode to scaffold an entire application by describing it in plain English. The agent creates project files, writes code for backend and frontend, installs dependencies, and starts the dev server automatically.
The same set on /recipes, filtered by tool and role.
Shows how to use JCode’s built‑in browser automation, memory system, and swarm mode features
Demonstrates setting up and using J Code, including its memory vector system, swarm agent coordination, and one‑click installation
Demonstrates how to build a high‑performance coding agent with a custom Rust renderer, token‑efficient memory, and self‑improving capabilities
Installs and runs the free Rust-based jcode coding agent while demonstrating its semantic memory feature and performance benchmarks
First, ensure the Rust toolchain (rustup) is installed, then clone the jcode repository and build it in release mode with `cargo build --release`. Copy the resulting binary (`target/release/jcode`) to a folder that’s in your PATH. Finally, run `jcode serve` to launch the local server and interact via the CLI or an HTTP client.
Semantic memory stores each AI response as a vector embedding and indexes them using cosine similarity, allowing instant retrieval of related past interactions. Start jcode with the `--memory-dir` flag pointing to an empty folder (e.g., `jcode serve --memory-dir ./jmem`). The agent will automatically embed responses, save them, and query this store on later prompts.
Yes; each jcode session uses less than 10 MB of RAM, so you can launch several agents that communicate via the built‑in server. Start one agent on a port (e.g., `jcode serve --port 8000`) and another on a different port pointing to the first with `--peer`. Configure webhooks or messages so edits from one agent trigger conflict‑resolution checks in the other.
After logging into an LLM provider and selecting a model, type a natural‑language request like “build a full‑stack React PDF editor in browser, create the necessary files” at the jcode prompt. The agent will scaffold the project, generate backend and frontend code, install dependencies, and run the appropriate start command. When it reports completion, you can open the folder in your editor and launch the development server to see the app running.
rustupcargo build --releasePATHvector embeddingcosine similaritywebhookdiffdry-runEXEAPI keycurlambient modeAsk, share, or report — over on the Heidelberg AI community forum.