JAWATA

Agents write. jawata verifies. Java wins.

Compiler-accurate Java analysis & refactoring for AI agents — JDT-backed, over MCP.

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. A grounded memory of your codebase's lessons. Enforcement that keeps the agent on the compiler instead of drifting back to grep. And your code never leaves your machine.

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 Claude Code and Cursor. Windows: grab the installer.

What only jawata brings

• 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. Design smells (Fowler, SOLID, Kerievsky) detected and cured. Your daily work isn't a migration; it's the change nobody wrote a recipe for.
• 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.
• Memory that doesn't live in a chat product. Portable files in your git plus a grounded store anchored to your symbols — 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.
• 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.
• Local and yours. Open source (AGPL-3.0), free, and it runs entirely on your machine — no platform, no upload, no per-seat contract. The compiler model is built from your working tree, live, and stays there.
• No IDE required — yours stays whatever it is. Headless residents managed by jawata-studio, wired into Claude Code and Cursor in two clicks. jawata serves the agent, not the editor: keep IntelliJ, keep Eclipse, keep VS Code — the agent gets Eclipse-grade semantics either way. Tools and guard are identical on every client; 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 lifts the trust-ceiling for autonomous work on the highest-value, hardest-to-verify language: Java in the enterprise.