OpenJellyfish

OpenJellyfish

Readable intelligence.

Quick Start

Three ways, pick what fits you

Deconstructing the Agent

Portable, reproducible, interpretable intelligence.

Instead of piling more onto an ever-heavier Agent, we split it into four layers: the LLM drives the intelligence, the Harness gives it a body to run in, Documents keep it unique at the core, and the Environment projects how it shows up.

Legacy FrameworkRuntime + Prompt + Memory + Workflow = Agent
OpenJellyfishLLM + Harness + Documents + Environment = Agent
Drive

LLM

The Drive

Can it think?

Provides reasoning power. Reasoning, language and world knowledge all come from here — swappable at any time: GPT, Claude, local models, plug-and-play via OpenAI compatibility.

OpenAIClaudeLocalSwappable
Body

Harness

The Body

How it thinks

Decides the runtime mechanics. It only runs the Observe · Think · Decide · Act loop, with no idea who it is or what to do. It stays simple forever.

ObserveThinkDecideAct
Soul

Documents

The Core

What it thinks, and why

Defines the intelligence itself. Prompt, Memory, Skills, Workflow, Permissions, Knowledge — all documents: readable, editable, copyable, version-controllable.

PromptMemorySkillsWorkflowPermissionsKnowledge
Stage

Environment

The Stage

How it reaches the world

Decides how the intelligence interacts with the outside world. Filesystem, Tools, MCP, Scheduler, External Services — the intelligence reaches the world and shows its results through it.

FilesystemToolsMCPScheduler
OpenJellyfish's most original idea

The biggest difference from traditional Agent frameworks:Documents are not a config file for the Harness — they are the intelligence itself.

Portable Intelligence

Because the Agent is documents, copying a directory copies the whole Agent. Its entire lifecycle is managed with mature software-engineering tools:

The Harness can upgrade, the LLM can swap, the runtime can be rebuilt — but the soul lives on in the documents.

git clonecopy the whole Intelligence
git diffsee how the Agent grew
git mergefuse two Agents

Document is all you need

Every capability comes down to one thing — coworking on documents with the agent.

01

Paths Are Boundaries

Isolate how agents are built and shared by document path. Permissions and power boundaries come for free — a different boundary is a different agent.

02

Memory Palace

Memory at every level lives as documents — browse, search and edit it like walking through a memory palace.

03

Docs as Ops

The agent schedules cron jobs and runs system operations by writing documents — ops is just editing files.

04

Self-Rewriting

Documents are editable, and documents are the agent — so the agent can rewrite its own prompts, scripts and logic.

05

Experience → Agent

Turn human experience into a publishable agent fast — all you need is to cowork on documents with the agent itself.

06

Copy & Import

A directory is a whole agent. Copy, import and share it with a plain cp or git clone.

… and ?

Documents can do far more. The next use case is yours to define.

One step back. A little simpler.

In an ever-more-complex agent ecosystem, the jellyfish chooses to step back — but back into a closed loop.

OpenClawDesktop · Single user

OpenClaw

Hyper-private by design — high risk of agent overreach, no real multi-user story, and distribution is out of the question.

HermesToolset · Open-ended

Hermes

Full automation sounds great, but you can only guide it through conversation — config, memory, and distribution silos are still yours to stitch.

OpenJellyfishLight · Closed-loop

OpenJellyfish

Built for tight, high-quality ops (≤50 people). Like Cursor's co-pilot, your agent sits beside you helping you build the next agent.

FlowiseDrag-drop · Prototype

Flowise

Node-based prototyping. Maintenance gets hard once logic grows.

n8nFlow · Automation

n8n

A workflow automation giant — AI is just one of its later-added nodes.

DifyFull-stack · Enterprise

Dify

Building workflows / chatflows is painful. The graph structure is complex, and the best use case is still unclear.

more primitive · lighterheavier · more complex
Same mouth in & out
Users, config, data — all in and out of one file system. No admin panel.
Self-iterating
Chat to change itself; runtime results feed back into config. No redeploy.
Closed-loop ops
One process + a file system. No databases / queues / microservices that 'open and won't close'.

Light, yet closed-loop. The jellyfish answer to 'simpler.'