- Rust 94.7%
- JSON-with-Comments 2.9%
- Inno Setup 0.5%
- Python 0.4%
- Tree-sitter Query 0.4%
- Other 0.9%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
cfe83c48a5
joule-bench's `real` suite drew the cache's boundary exactly: every single-file L4 close came back free on the repeat, and neither multi-file close ever did — both paid the cloud in full again. Multi-file changes are 53-66% of real commits, so the cascade's economics stopped at the larger share of real work. The open standard was never the obstacle. `Edit` has always carried its own `path`, and SPEC §2 defines an op's `prior` as "the tree state this op builds on". The single-file limit was ours, in three places: - `ClaudeL4` snapshotted only `target`. For a fix with no single target it read an empty string before and after, concluded nothing changed, and returned `None` — so nothing was recorded even though the agent had fixed the files. That is why the benchmark graded those tasks as passed while the cascade cached nothing. It now snapshots the tree and records every changed file as one op. - A target-less request was keyed on an empty path, giving every such request the same "prior". It is now keyed on the tree state. - Replay ignored `edit.path` and spliced every edit into the one document in hand. A multi-file op reaching L0 would have written one file's bytes into another at the wrong offsets. It never happened only because no multi-file op had ever been recorded. Replay onto the tree is refused unless the tree is the one the op was recorded against, and every new file body is computed before any file is written. A refusal costs one cloud call; a replay at the wrong offsets would corrupt several files silently. The tree state excludes `.joule`, the cascade's own ledger. It grows on every close, so including it would have given each pass a different tree and nothing could ever have hit the cache — the change would have looked correct and never fired. Toolchain caches are excluded for the same reason. Proved end to end through the engine: a fix spanning two files goes to L4 once; with the tree reset, the identical request closes at L0, replays both files, and the agent is not called again. Plus the two failure modes that matter — a moved tree is refused with nothing written, and a multi-file op is never spliced into a single document. Also: the hardware energy test is now ignored by default. It read 124.9 J and 150.4 J on an idle host and 0 J three times out of three, alone, at a load average of 120 from unrelated builds. The doc comment previously blamed parallel test load; the measurement says any heavy load. Co-Authored-By: Claude Opus 5 <[email protected]> |
||
| .agents/skills | ||
| .cargo | ||
| .cloudflare | ||
| .config | ||
| .factory | ||
| .github | ||
| .zed | ||
| assets | ||
| ci | ||
| crates | ||
| dev-docs | ||
| docs | ||
| extensions | ||
| legal | ||
| nix | ||
| script | ||
| tooling | ||
| .git-blame-ignore-revs | ||
| .gitattributes | ||
| .gitignore | ||
| .mailmap | ||
| .prettierrc | ||
| .rules | ||
| AGENTS.md | ||
| Cargo.lock | ||
| Cargo.toml | ||
| CLAUDE.md | ||
| clippy.toml | ||
| CODE_OF_CONDUCT.md | ||
| compose.yml | ||
| CONTRIBUTING.md | ||
| debug.plist | ||
| default.nix | ||
| Dockerfile-collab | ||
| Dockerfile-collab.dockerignore | ||
| Dockerfile-cross.dockerignore | ||
| Dockerfile-distros | ||
| Dockerfile-distros.dockerignore | ||
| flake.lock | ||
| flake.nix | ||
| GEMINI.md | ||
| JOULE_CODE.md | ||
| LICENSE-APACHE | ||
| LICENSE-GPL | ||
| livekit.yaml | ||
| lychee.toml | ||
| PRIVACY_HARDENING.md | ||
| Procfile | ||
| Procfile.all | ||
| Procfile.web | ||
| README.md | ||
| renovate.json | ||
| REVIEWERS.conl | ||
| rust-toolchain.toml | ||
| rustfmt.toml | ||
| shell.nix | ||
| SIGNING.md | ||
| typos.toml | ||
agent-joule — Joule Code reference consumer
agent-joule is the reference editor for Joule Code, the Transaction Science open standard for energy-attributed, federated, no-phone-home agentic coding. It is a hard fork of the Zed editor, stripped of its cloud ties and rebuilt around the Joule Code commitments: drive vendors' own logged-in coding agents over ACP, meter every turn in joules, and never phone home.
It is not a paid coding tool with a token markup. The protocol is owned by no one; agent-joule is one (SOTA) implementation of it.
What it does
- Federates frontier coding agents. Connect Claude Code, Gemini, or Codex from one panel. agent-joule launches the vendor's own logged-in CLI over the Agent Client Protocol (ACP) — the vendor's client owns its credential; agent-joule never sees or transports a token. These agents are the Joule Code cascade's L4 (Wire) tier.
- Meters energy. Every session surfaces a real
joule-code-receipt::Receipt:⚡ N J this session (est.) · L4. The number is computed from the agent's actual reported token usage; theest.is honest — it is anEstimatorreading because no hardware energy interface is in the path yet (Joule Code SPEC §6). When a metered backend is present, the same surface shows ameasuredfigure. - Does not phone home. Sign-in, telemetry, crash upload, and auto-update are removed; a build-level egress backstop makes Joule-host URLs unreachable; the ACP-registry auto-fetch is off. Startup is network-silent — verified by packet capture. See
PRIVACY_HARDENING.md.
Joule Code conformance
agent-joule implements the Joule Code v0.1 commitments it is positioned to carry — the no-capture posture (verified) and a live receipt surface — and binds the federation legs as the cascade's L4 tier. The full clause-by-clause map (what is implemented, partial, and pending) is in JOULE_CODE.md. The standard's lean reference library (joule-code-rs) and conformance suite live in the open-standards repository; agent-joule consumes it as a dependency rather than vendoring a copy.
Build and run
cargo build --bin agent-joule
./target/debug/agent-joule
Open the federation panel with ctrl-cmd-a. Connecting an agent requires that vendor's CLI to be installed and logged in (e.g. claude, gemini); registry agents are fetched via npx on first connect. A local OpenAI-compatible model (e.g. vLLM at localhost:8000) is registered as a direct provider — the cascade's L3 (local model) tier.
For building on each platform, the upstream Joule development guides still apply: macOS, Linux, Windows.
Licence
agent-joule inherits Joule's GPL-3.0-or-later licence (LICENSE-GPL; portions Apache-2.0, LICENSE-APACHE). The Joule Code standard it consumes is separately and permissively licensed (Apache-2.0 reference code, CC-BY-4.0 spec text); a GPL reference editor consuming a permissive standard is intentional.
License information for third-party dependencies must be correctly provided for CI to pass; agent-joule retains Joule's cargo-about setup under script/licenses/.
Upstream
agent-joule is a hard fork of zed-industries/zed, a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter, developed by Zed Industries, Inc. All credit for the editor foundation is theirs. agent-joule diverges in one direction: removing the cloud dependencies and building the Joule Code substrate in their place. Upstream documentation, contribution guidance, and community links live at zed.dev and the upstream repository.