JavaClaw is an open-source Java port of OpenClaw built by the JobRunr team. It's a personal AI agent that runs on your own hardware, supports Telegram and a web chat UI, and uses the same SKILL.md + workspace pattern as OpenClaw — but runs on the JVM with Spring Boot 4, Spring AI, and JobRunr for background job scheduling.

Why does a Java version of OpenClaw matter?

Java is the dominant language in enterprise environments. Most enterprises already run Spring Boot services, have Java expertise on staff, and have compliance requirements around running workloads on approved JVM infrastructure. JavaClaw lets those teams adopt agent architecture without leaving the Java ecosystem.

What is Spring AI and how does it fit?

Spring AI is the official Spring Framework abstraction for LLM integration — similar in spirit to LangChain but native to the Spring ecosystem. It provides unified interfaces for OpenAI, Anthropic, and Ollama, plus built-in support for MCP (Model Context Protocol) client connections. JavaClaw uses Spring AI 2.0 as its LLM layer.

What does JobRunr add to a Java AI agent?

JobRunr is a distributed background job scheduler for Java. In JavaClaw it handles task scheduling — one-off, delayed, and recurring cron jobs — with a built-in monitoring dashboard at :8081. Unlike cron or simple thread schedulers, JobRunr persists job state to a database, retries on failure, and gives you visibility into what the agent is doing in the background.

How does JavaClaw compare to the Node.js OpenClaw?

JavaClaw mirrors OpenClaw's architecture: AGENT.md system prompt, INFO.md context, workspace/skills/ for drop-in capabilities, workspace/tasks/ for task tracking, Telegram integration, MCP client support, and web search. The key differences are the runtime (JVM vs Node.js), the job scheduling layer (JobRunr vs cron), and the frontend (htmx + Bulma vs OpenClaw's UI).

Can JavaClaw run fully locally without cloud LLMs?

Yes. JavaClaw supports Ollama as an LLM provider out of the box — configured during the onboarding UI. Combined with local embeddings and local MCP servers, the entire stack can run air-gapped on your own hardware. No data leaves the machine unless you configure an external LLM provider.

JavaClaw: OpenClaw for the Java Enterprise — Spring Boot 4, Spring AI, and JobRunr

By Prahlad Menon Published 2026-03-24 5 min read

The OpenClaw ecosystem keeps expanding — and now it’s crossed into Java.

JavaClaw is an open-source Java port of OpenClaw built by the team behind JobRunr, the popular Java background job scheduler. It runs on Spring Boot 4, Spring AI 2.0, and Java 25 — and it follows the same SKILL.md + workspace architecture that OpenClaw users already know.

The project started as a JobRunr demo. It’s become something more: an open invitation to the Java community to bring agent architecture to the JVM.

Why This Matters for Enterprise

The OpenClaw ecosystem has grown fast, but almost entirely in the Node.js world. That’s fine for individual developers and small teams — but most enterprise environments run on Java. Spring Boot services, JVM infrastructure, Java security toolchains, Java-native compliance tooling.

For those teams, adopting an AI agent has meant either running a separate Node.js process (awkward, cross-team friction), wrapping an API (limited capability), or waiting for a Java-native option.

JavaClaw is that option. Same architecture, same patterns, JVM-native.

The Stack

Layer	Technology
Language	Java 25
Framework	Spring Boot 4.0.3, Spring Modulith 2.0.3
LLM	Spring AI 2.0 (OpenAI, Anthropic, Ollama)
Agent	Spring AI Agent Utils
MCP	Spring AI MCP Client
Jobs	JobRunr 8.5.0
Database	H2 (embedded, file-backed)
Frontend	htmx 2.0.8 + Bulma 1.0.4
Telegram	TelegramBots 9.4.0

Spring AI 2.0 is the key dependency. It’s the official Spring abstraction layer for LLM integration — think of it as LangChain but native to the Spring ecosystem, with unified interfaces across providers and first-class MCP client support.

JobRunr handles what cron handles in the Node.js OpenClaw, but with significantly more capability: persistent job state, retry logic, distributed execution, and a built-in monitoring dashboard.

Getting Started

git clone https://github.com/jobrunr/JavaClaw
cd JavaClaw
./gradlew :app:bootRun

Then open http://localhost:8080/onboarding for a guided setup that walks through:

Provider — Choose Ollama (local), OpenAI, or Anthropic
Credentials — API key and model name
Agent Prompt — Customize workspace/AGENT.md with your info
MCP Servers — Optionally connect Model Context Protocol tool servers
Telegram — Optionally connect a bot (token + allowed username)

Configuration writes to application.yaml and takes effect immediately. The background job dashboard is at http://localhost:8081.

The Workspace Structure

JavaClaw mirrors the OpenClaw workspace pattern exactly:

workspace/
├── AGENT.md              # System prompt — your agent's identity
├── INFO.md               # Environment context injected into every prompt
├── context/              # Agent memory and long-term context files
├── skills/               # Drop a SKILL.md here to add capabilities
├── tasks/                # Task files, date-bucketed
│   └── recurring/        # Cron-scheduled recurring task templates

If you’ve used OpenClaw skills, the pattern is identical — drop a SKILL.md into workspace/skills/ and the agent picks it up at runtime. No restart required.

Task lifecycle follows: todo → in_progress → completed / awaiting_human_input — tracked as Markdown files, date-bucketed by creation time.

Where JobRunr Changes the Game

The most distinctive architectural addition is JobRunr as the scheduling layer.

Standard OpenClaw uses cron (or GitHub Actions, in our StockScout setup). JobRunr gives you:

Persistent job state — jobs survive restarts, tracked in H2
Retry logic — failed jobs retry automatically with backoff
Delayed execution — schedule a job for “5 minutes from now” or “next Tuesday at 9am”
Recurring cron jobs — same as cron, but with visibility
Dashboard — see every job, its status, execution history, and logs at :8081

For an AI agent that runs autonomous tasks, this is a meaningful upgrade over fire-and-forget cron. If the agent’s task fails halfway through, JobRunr retries it. If you want to know what your agent did at 3am, the dashboard shows you.

Spring AI and MCP

Spring AI 2.0 provides the MCP client — so JavaClaw can connect to any MCP tool server the same way Node.js OpenClaw does. Your existing MCP servers (database tools, web search, file systems, custom APIs) work without modification.

// Spring AI MCP client configuration (simplified)
@Bean
public McpClient mcpClient() {
    return McpClient.builder()
        .transport(new StdioClientTransport(...))
        .build();
}

The LLM provider is swappable at configuration time. Ollama integration means the entire stack — agent, LLM inference, job scheduling — can run on a single machine with no external dependencies.

The Multi-Channel Architecture

JavaClaw ships with two channels:

Telegram — Long-poll bot, same setup as OpenClaw. Bot token + allowed username in onboarding.

Web Chat — WebSocket-based chat UI at http://localhost:8080/chat. No external dependencies.

The channel architecture is extensible — add a new class implementing the channel interface and wire it in. WhatsApp, Slack, or custom internal messaging systems could be added following the same pattern.

Who This Is For

Enterprise Java teams who want to add agent capabilities to their existing JVM infrastructure without introducing Node.js. Spring Boot 4 means JavaClaw can be deployed alongside existing Spring services with shared infrastructure (databases, monitoring, service mesh).

JobRunr users who want their background job scheduler to grow into a full agent — tasks become scheduled jobs, the agent becomes the task planner.

Teams with strict data residency requirements — Ollama support means fully local operation, no data leaves the machine, and the whole stack runs in your existing Java security perimeter.

Developers who want to contribute — the project is explicitly framed as an invitation to the Java community to build agent capabilities on the JVM. The codebase is clean Spring Modulith architecture, well-separated, approachable.

Compared to Node.js OpenClaw

If you’re already running OpenClaw, here’s the honest comparison:

	OpenClaw (Node.js)	JavaClaw
Runtime	Node.js	JVM (Java 25)
Scheduling	cron / GitHub Actions	JobRunr (persistent, retriable)
LLM layer	OpenClaw native	Spring AI 2.0
MCP	Native	Spring AI MCP Client
Skills	SKILL.md	SKILL.md (identical)
Workspace	workspace/	workspace/ (identical)
Frontend	OpenClaw UI	htmx + Bulma
Job dashboard	None built-in	JobRunr dashboard (:8081)

JavaClaw isn’t a replacement — it’s the same idea for a different runtime and a different team profile. For the broader OpenClaw ecosystem, having a JVM-native implementation closes a major gap.

We’ve covered the MetaClaw skill injection system and SkyClaw’s Rust implementation in previous posts. JavaClaw rounds out the picture: OpenClaw isn’t just a Node.js tool anymore. It’s becoming a cross-runtime agent standard.

JavaClaw is open-source at github.com/jobrunr/JavaClaw. Built by the JobRunr team as a Java-native OpenClaw implementation. MIT license.