English · 中文

Jupiter

An LLM-maintained personal knowledge OS that converges and self-corrects as it grows.

Jupiter is named for the planet: a gravitational center that keeps a swarm of moons (your source material) in orbit, and the most organizing body in the system. The main axis is research, thinking, output. The LLM writes and maintains everything; you select material, steer the analysis, and keep the final judgment.

demo GIF placeholder: docs/assets to be added

What it is

Most LLM second brains only do addition: read things in, write pages, pile up forever. Jupiter is not another note template. It is a knowledge loop that converges.

        Input ──▶ Compile ──▶ Calibrate ──▶ Retrieve ──▶ Share ──┐
     (you pick)   (converge)   (human      (Q&A)       (long      │
          ▲       ADD/UPDATE/   judgment)               images)   │
          │       SUPERSEDE/                                       │
          └──────────── Feedback ◀───────────────────────────────┘
                    (unanswered questions drive the next input)

Every operation serves one link in the loop. The lesson Jupiter is built on: a schema with only addition and no subtraction, only machine writes and no human calibration, breaks all six links. Jupiter's mechanisms exist to give the loop its subtraction and its calibration back.

Why Jupiter

The difference is not more features. It is convergence machinery that other approaches leave out.

Mechanism	Plain second-brain	Karpathy LLM Wiki	Jupiter
Four-Verdict Adjudication (ADD / UPDATE / SUPERSEDE / NOOP)	append only	ingest + dedup	every unit is adjudicated on write, NOOP is a valid exit
Two-Source Threshold	no gate	no gate	a new concept page needs two independent sources
Tension (with adjudication conditions)	not modeled	not modeled	opposing claims recorded both ways, with the condition that decides which wins
Consolidate slow channel	none	none	a separate channel every two weeks that only merges and retires
Selective Compilation / triage	compile everything	compile everything	Interest Profile picks what to compile from long transcripts
bidirectional accounting (additions + subtractions)	growth only	growth only	the dashboard shows merges, removals, and NOOP next to new pages

Convergence cannot come from the same fast path that writes: incremental writes always diverge. So Jupiter separates fast from slow. Ingest stays light. Convergence is a separate slow channel.

How it works

The eight operations (the operation layer):

Operation	Role
patrol	scan the input pipeline, triage new material into four choices
ingest	compile material, Four-Verdict Adjudication, the convergence link
query	ask the knowledge base, waterfall retrieval, evidence before answer
annotate	calibration, capture the human's judgment onto pages
share	turn a converged concept into a shareable image
consolidate	slow-channel convergence, merge and retire only
skillify	promote a repeated workflow into a registered skill
lint	quality checks, from fix-in-place down to delete

Three layers over an immutable base:

reflection layer   thinking-mode entry points
operation layer    patrol / ingest / query / annotate / share / consolidate / skillify / lint
knowledge layer    wiki/{concepts, domains, entities, _sources} + Interest Profile + miss-log
                             ▲
                             │
                          raw/   material you selected (immutable, LLM read-only)

The knowledge layer is the LLM's to write. The raw layer is yours: immutable, LLM read-only. The human keeps judgment; the system is responsible for asking.

Quick Start

Three ways in. Full steps live in docs/SETUP.md.

1. Clone and use it as an empty knowledge base. Copy scaffold/ into a new vault, open it in Claude Code, and start clipping and compiling.
2. Add it to an existing Obsidian vault. Drop in CLAUDE.md, the commands/, and the config/ you want, then let patrol register what is already there.
3. Install it as Claude Code commands. Point Claude Code at the commands/ directory and drive the operations by name.

Jupiter treats Obsidian as the IDE, the LLM as the programmer, and the OS as the codebase. Retrieval is agentic search (grep plus wikilink traversal), no vector DB. Classification is link-based, not folders.

What you get

Jupiter/
├── README.md / README.zh-CN.md      bilingual front door
├── LICENSE                          MIT, examples/ separately CC0
├── CLAUDE.md                        the constitution (loaded by Claude Code on clone)
├── docs/                            bilingual docs: ARCHITECTURE, SETUP, PHILOSOPHY, OPERATIONS, input-pipeline
├── commands/                        10 slash commands
├── templates/                       empty page templates
├── config/                          patrol config, graph config, Base view, skills registry, scheduled tasks
├── scaffold/                        empty knowledge-base skeleton
└── examples/                        a self-authored, fictional CC0 example chain

The 10 commands:

Command	One line
compile-kb	ingest: compile only new material, Four-Verdict Adjudication
query-kb	ask the base, waterfall retrieval, archive valuable answers
kb-patrol	scan Chrome bookmarks and raw/ diff, triage into four choices
consolidate-kb	slow-channel convergence, merge and retire, no new pages
annotate-kb	calibration, write the human's judgment onto a page
share-insight	turn a converged concept into a shareable long image
clip-media	YouTube or podcast URL into structured markdown in raw/
clip-bili	Bilibili URL into a timestamped transcript
clip-xhs	Xiaohongshu URL into structured markdown
clip-wx	WeChat article URL into markdown with localized images

Try it

Walk the examples/ chain to watch the machinery actually fire. Run an ingest over the example material and you can see the Four-Verdict Adjudication table (which units become ADD, UPDATE, SUPERSEDE, NOOP), then run a query that lands on a tension and returns the adjudication condition that decides which side wins. The example chain is self-authored and fictional (CC0), built only to show the format and mechanisms.

Configuration

CLAUDE.md is the constitution: cloning the repo loads it into Claude Code automatically, and it defines every operation and file format. It is meant to be trimmed. Cut the operations, input channels, or word budgets you do not want, and the system follows the version you keep. config/ holds the patrol config, the Obsidian graph coloring, the Base view for link-based classification, the skills registry, and the scheduled tasks (patrol daily, consolidate every two weeks).

Based on / Acknowledgments

Jupiter's direct ancestor is Andrej Karpathy's LLM Wiki pattern: the three-layer split of raw/ plus wiki/ plus a schema in CLAUDE.md, with operations like ingest, query, and lint. Jupiter adds the convergence and calibration machinery on top. The slow-channel idea (convergence must come from a separate channel, not the fast write path) draws on Letta and cognee.

Philosophy

Full version in docs/PHILOSOPHY.md.

• Less is more. NOOP is a valid exit, merging beats creating, files touched is not a KPI.
• Write is verdict. There is no unconditional new page; every field has an intent.
• The human keeps judgment, but the system is responsible for asking. A zero percent fill rate on judgment is the system's failure, not the human's.
• Tension is worth more than agreement. A harmonious base reinforces itself instead of correcting itself; every tension carries the condition that makes it actionable.

Contributing

Issues and pull requests welcome, especially on the docs, the templates, and the example chain. Keep the house style: no italics, no dashes (use commas, colons, or parentheses).

License

MIT for the system. The examples/ directory is released separately into the public domain under CC0 1.0. See LICENSE and examples/LICENSE.

Privacy

This repository contains none of the author's personal knowledge content. It ships the system only, never the notes. Every example is fictional and CC0, authored solely to illustrate the format and mechanisms, and represents no real source or personal judgment.