Jcode

The open-source harness for AI coding agents.
Parallel execution. Memory. Automation.

[Jcode @jcodesh]

$JCODE IS NOW LIVE

Jcode is officially live, bringing an open-source harness built for the next generation of AI coding agents — combining parallel execution, persistent memory, automation, intelligent tool use, and long-running workflows into one efficient development environment.

CA: 0x9F29c73D83c89E711f6f057E41406f2592266CF9

Built in Rust and designed around a simple idea: AI coding should go beyond generating code. Agents should be able to understand context, work across complex codebases, execute tasks, run tests, iterate on results, and continue working toward a real objective. Jcode provides the infrastructure around the model to make that workflow faster, more persistent, and more scalable.

From a single coding session to multiple agents working in parallel, Jcode is building an execution layer for AI-native software development — open, extensible, and designed for developers who want their agents to do more than just answer prompts.

https://t.co/Xbu74sCgDA

[Jcode @jcodesh]

AI coding is no longer just about how fast a model can generate code.

The real challenge is what happens after the first answer.

Can the agent remember what it was doing?
Can it run long tasks without stopping?
Can multiple agents work at the same time?
Can it recognize when something is incomplete?
Can it test, verify, and keep iterating?

Jcode is building the infrastructure around those questions.

With parallel execution, persistent memory, background tasks, auto-poke, confidence stepping, and a lightweight open-source architecture, Jcode is designed to turn AI coding from a simple prompt-and-response experience into a continuous development workflow.

The goal isn’t to make agents talk more.

It’s to make them work better.

Understand the problem.
Execute the task.
Check the result.
Learn from the feedback.
Keep going until the work is actually finished.

That’s the direction Jcode is pushing AI-native software development.

https://t.co/Xbu74sCgDA

[Jcode @jcodesh]

AI coding agents don’t fail only because they write the wrong code.

Sometimes, they fail because they stop too early.

Jcode is designed around a different approach: keep the agent moving until the work is actually complete.

With auto-poke, incomplete tasks don’t simply disappear when a turn ends. Jcode can detect unfinished todos and push the agent back into the workflow, while background execution allows long-running commands to continue without forcing the agent to wait.

The result is a development loop built around execution rather than conversation:

Understand.
Build.
Test.
Verify.
Iterate.
Finish.

That shift matters.

Because the future of AI coding isn’t just about agents that can write code.

It’s about agents that can stay focused long enough to finish the job.

Jcode is building the harness for that future.

https://t.co/Xbu74sCgDA

[Jcode @jcodesh]

“Done” doesn’t always mean done.

AI coding agents are getting better at writing code, but reliable execution requires more than generating an answer. An agent needs to know when its work is actually complete, recognize when something feels too easy, and verify the result before moving on.

That’s the idea behind Jcode’s confidence stepping.

The agent reports confidence when a task begins and again when it is marked complete. If that confidence suddenly spikes without enough evidence, Jcode sends the agent back to check its work.

In Jcode’s published Terminal-Bench 2.1 experiment with Opus 4.8, the finished-in-time pass rate moved from 88% to 92%, while trials cut off at the 15-minute limit that were already correct moved from 42% to 47%.

The philosophy is simple:

Don’t reward an agent for saying it’s finished.

Reward it for proving the work is finished.

Jcode is building the infrastructure that makes AI coding agents more persistent, measurable, and capable of actually completing the work they start.

https://t.co/Xbu74sCgDA

[Jcode @jcodesh]

Every second matters when your development environment is built around agents.

Jcode is designed with startup speed and low overhead in mind.

In measurements published by Jcode using real agent launches on the same machine, Jcode reached typed input in 48.7 ms, with a reported 14.0 ms time to first frame.

The benchmark compares startup behavior across several coding-agent tools under Jcode’s stated methodology.

For developers running agents repeatedly—or operating multiple sessions in parallel—small amounts of overhead can compound quickly.

Jcode’s approach is simple:

Start fast.
Stay lightweight.
Get to the work.

https://t.co/Xbu74sCgDA

[Jcode @jcodesh]

Models love to declare victory. Jcode makes them keep working.

One of the most frustrating behaviors in autonomous coding is an agent stopping before the actual objective is complete.

Jcode approaches this with auto-poke.

When a turn ends while incomplete todos remain, Jcode can automatically prompt the agent to continue instead of accepting an early exit as success.

Transient failures can be retried, non-retryable errors can stop the loop, and jcode run can continue iterating until the work is finished.

The goal isn’t simply to make an agent answer faster.

It is to make the agent finish what it started.

Less “I’m done.”
More actual completion.

[Jcode @jcodesh]

A better agent doesn’t always need a bigger prompt.

Jcode’s normal-session system prompt has been reduced to 671 tokens, representing a 73% reduction from v0.1 according to its published measurements.

The idea is straightforward: as frontier models improve, the harness can get out of their way.

Instead of constantly adding more instructions, Jcode focuses on giving the model the right environment, tools, context, memory, and feedback while keeping the core prompt focused.

Less overhead.
Less unnecessary context.
More room for the model to actually solve the problem.

The prompt gets out of the model’s way.

[Jcode @jcodesh]

Your agent shouldn’t stop working just because a command takes time.

Jcode treats long-running development tasks as part of the workflow rather than an interruption.

Commands can run in the background while the agent continues thinking and working. Progress, checkpoints, status, inspection, cancellation, and completion can all be managed without forcing the entire session to wait.

That means a long test suite, build process, or other time-consuming command can keep running while the agent moves forward with the rest of the work.

Long-running work keeps going while the agent keeps thinking.

[Jcode @jcodesh]

“Done. 100% confident.” — Check anyway.

Confidence is useful, but confidence alone should never be the finish line.

Jcode introduces a confidence-stepping approach where the agent evaluates its confidence when a task begins and again when it marks the work complete. When confidence jumps too sharply, Jcode sends the agent back to verify the result instead of simply accepting the declaration of success.

In Jcode’s published Terminal-Bench 2.1 experiment with Opus 4.8, the finished-in-time pass rate increased from 88% to 92%, while trials that were cut off at the 15-minute limit but were already correct increased from 42% to 47%.

The principle is simple:

Don’t trust “done.” Verify it.

[Jcode @jcodesh]

AI coding is entering a different era.

The next breakthrough may not come from another model alone, but from the infrastructure that surrounds it.

Jcode is building an open-source harness designed to turn AI coding agents into persistent, efficient development systems — with parallel agents, memory, automation, tool execution, context management, testing, and long-running workflows working together.

Instead of simply asking an AI to write code, imagine giving it an objective and an environment where it can understand, execute, test, iterate, and keep moving.

That is the direction Jcode is pushing toward:

From AI that generates code → to AI that actually works on software.

https://t.co/Xbu74sCgDA

[Jcode @jcodesh]

You should never wait while coding.

Every moment an agent is working is a moment you could hand out the next task. Spin up another session instead of watching this one finish.

jcode is built so running dozens of agents is actually possible: about 10.4 MB per extra session, first frame in 14 ms, ready for input in 48.7 ms.

https://t.co/nA2gYsstro

[Jcode @jcodesh]

Ten jcode sessions ≈ 100 MB.

That’s less than half of one Claude Code session.

Extra memory each additional session adds, as measured by jcode on the same machine:
jcode ~10.4 MB · Codex CLI ~21.6 MB · Cursor Agent ~157.5 MB · Claude Code ~212.7 MB · OpenCode ~318.4 MB

The bottleneck to massive parallelism is resource efficiency.

https://t.co/nA2gYsstro

[Jcode @jcodesh]

https://t.co/3HVLyk2BW5

[Jcode @jcodesh]

jcode: an open source terminal coding agent, written in Rust.

Durable memory, background tasks, and agent swarms, installed with one command:

curl -fsSL https://t.co/eDvRjGR03h | bash

macOS, Linux, Windows (beta). MIT licensed.

https://t.co/AcxrT9yVNt

[Jcode @jcodesh]

A quick walk through https://t.co/AcxrT9yVNt.

Screenshots of real sessions. The mission. Resource efficiency. The intelligence work: jcode bench, confidence stepping, hill-climbable goals. Durable memory. And everything open source.

https://t.co/AcxrT9yVNt