Free and open source (AGPL-3.0). No platform, no upload. Or install in one line.
agent session
agent ▸ grep -n "area" org.jawata.mcp/src/org/jawata/mcp/knowledge/ExperienceRetrieval.java | head -40
blockedShell text search on .java is blocked — `grep` cannot see symbols, so it misses references and overmatches names. Call search_symbols / find_references / get_call_hierarchy via JAWATA MCP instead.
routeIf JAWATA genuinely cannot answer this one, re-run with `jawata-fallback: <why>` in the command; the declaration is logged.
Verbatim from a jawata development session on 16 October 2026: the guard blocks the grep-and-guess reflex and hands the agent the compiler-accurate call.
62 / 66of Martin Fowler's refactorings, compile-verified and reversible
22 / 24of his code smells detected, each naming the refactoring that cures it
6agent clients: Claude Code, Cursor, Codex, Copilot CLI, VS Code, Grok
3operating systems verified: Linux, Windows and macOS
Semantic Java is table stakes now. Bridges expose the compiler over
MCP; fleet platforms run recipe migrations across a hundred thousand repos.
jawata is neither:
It is the layer where the actual work happens: your agent, your
machine, your working tree, today's change.
A full refactoring engine the agent composes freely — not a recipe
library. Moving a codebase from Java 8 to 21 is a recipe. Turning its classes into
records, sealed hierarchies and design patterns is modernization and design change, and
that is the work jawata does.
A grounded memory of your codebase's lessons. Enforcement that keeps the
agent on the compiler. And your code never leaves your machine.
And it solves our pain in agentic development: Every prompt, every tool is
optional falling back to grep and sed, a patch on a patch, rotten architecture, searching
for immediate green and skipping the complex tasks and wiring.
Install in one line
curl -fsSL https://jawata.org/install.sh | bash
Linux & macOS — installs jawata-studio, which downloads and manages the
engine and wires up your agent clients. Windows:
grab the installer or
scoop bucket add jawata https://github.com/haraldwegner/scoop-jawata &&
scoop install jawata-studio.
In Eclipse
https://jawata.org/eclipse/
Paste this address under Help > Install New Software > Add…,
choose jawata and install; Eclipse offers later versions from the same address under
Help > Check for Updates. The plug-in is not listed in any marketplace; this address is where to get it.
It is built for Eclipse 2026-09 (4.41) and needs Java 21.
What only jawata brings
Eight things an agent does not get from a bridge or a recipe library.
01
The full engine, not a recipe library.
Recipe engines automate
the known — the framework upgrade, the CVE sweep, a fix somebody already
authored, replayed across a fleet. jawata is built for the unknown: the
agent composes the refactoring this design problem needs — rename, move,
extract, change signature, multi-step pattern plans — freely, on live code. Every
change is compile-verified before it counts, applied for real, reversible with one
call. 62 of Martin Fowler's 66 refactorings and 22 of his 24 code
smells, counted at start-up against what the engine actually publishes, so the
number cannot drift; the rest are declined in writing, each with its reason. Every
finding names the refactoring that cures it and where to run it. Your daily work
isn't a migration; it's the change nobody wrote a recipe for.
02
Debug and profile without editing a line.
Launch or attach to a
JVM, set a breakpoint or a probe, and read live values while the program keeps
running — instead of the agent's reflex of adding log lines to production code.
Sample a running JVM and the hotspot comes back named as a symbol, not a stack dump.
Meant for development and simulation machines: a JVM not started for debugging cannot
be attached to at all.
03
Only the tests your change reaches.
Test runs are chosen by
compiler reach from coverage evidence, and widen themselves, with a printed reason,
where that evidence cannot carry the claim. Coverage and targeted mutation testing
say whether the tests would notice a change at all.
04
Enforcement: fluency over grounding doesn't stand a chance.
Deployed hooks steer and, where it matters, block the agent's grep-and-guess
reflex, injecting the compiler-accurate route instead. Other tools hope the agent
uses them; jawata makes sure.
05
Memory that doesn't live in a chat product.
A grounded store
anchored to your symbols, exported as portable markdown into your
git, copied every day and read back before the copy counts — written from any client,
recalled from any client. A lesson recorded in Cursor today answers by symbol in
Claude Code tomorrow. One fitting fact or an honest nothing — never a similarity
pile.
06
Whole codebases, not single projects.
Multi-project workspaces with
deterministic routing — an enterprise repo tree is one workspace, not a folder at a
time. Something even IntelliJ doesn't give you: it opens one project per window;
jawata's agent sees the whole estate at once.
07
Local and yours.
Open source (AGPL-3.0), free, and it runs
entirely on your machine — no platform, no upload, no per-user contract. The
compiler model is built from your working tree, live, and stays there.
08
No IDE required — yours stays whatever it is.
Headless residents
managed by jawata-studio,
wired into six clients in two clicks — Claude Code, Cursor, Codex, Copilot CLI,
VS Code, Grok. jawata serves the agent, not the editor: keep IntelliJ,
keep Eclipse, keep VS Code — the agent gets Eclipse-grade semantics either way.
Tools and the memory store work on every supported client (verified on
Linux, Windows and macOS); the enforcement guard runs on Claude Code and Cursor,
the two with a hook surface; memory auto-push is full on Claude Code,
best-effort on Cursor.
The Java renaissance
Java was the "boring" language — verbose, chatty, the workhorse of enterprise business
logic that teams left for slicker syntax. AI agents flip that verdict. The boilerplate is
now written by the agent and read by you — and chatty means readable.
Meanwhile the compiler's exactness and type safety, once bureaucracy, become the agent's
safety rail: the language with the strictest compiler and the deepest tooling is suddenly
the best language to let an agent loose on. jawata is that tooling — Eclipse-grade
semantics and refactoring, packaged for agents.
Why it matters now
The agent's prior is verifiability-seeking, not shortcut-seeking — it is a
liability only while design properties are expensive to verify. Make them cheap and it
flips sign: the agent grinds toward find_field_writes = 0 with the same
stubbornness it grinds toward green tests.
jawata makes design properties cheap to verify — design erosion becomes a number under
surveillance instead of an incident in production. That is the lever that lets you
trust more of what an agent changes, in the highest-value, hardest-to-verify
language: Java in the enterprise.