Official GitHub repository

Install QiJu from jasonshrepo/qiju.

QiJu is a source-first developer preview. The repository contains the CLI, agent skills, install script, tests, and documentation for local-first AI coding session records.

Repository: github.com/jasonshrepo/qiju License: Apache-2.0 · Runtime: Python 3.11+ · Platforms: macOS and Linux Core idea: record what happened, who did it, where the evidence is, and what should happen next.

# clone the QiJu GitHub repository $ git clone https://github.com/jasonshrepo/qiju.git $ cd qiju && bash install.sh # wire QiJu into one project $ cd /path/to/your/project $ qiju init --host claude ✓ local record layer ready

The problem

Hard-won context dies with the thread.

You explain the architecture, the decisions, the dead ends, what's half-finished. Then the session ends — and all of that understanding evaporates. Next time, you start over.

It dies with the thread

Close the chat or hit the context limit, and the shared understanding is simply gone.

It doesn't move between tools

Switch from Claude Code to Cursor — or hand off to a teammate — and the new agent knows nothing.

It's locked to a vendor

Platform "memory" lives on someone else's servers. You can't read it, edit it, or take it with you.

It gets summarized away

Long sessions are compacted into lossy recaps — and the detail you needed is the first thing dropped.

The idea

QiJu is not memory. It is a record layer.

Ordinary "memory" answers what the model remembers. QiJu answers why we know it, where the proof is, who produced it, whether it was verified, and who continues next.

CAPTURE

You ask, it writes it down

Record a whole session, or point at the specific things worth keeping. Nothing is logged silently; you decide what gets saved.

PRESERVE

Stored exactly, never re-summarized

QiJu keeps the record as-is, including evidence, next steps, agent identity, and useful search terms.

RETRIEVE

Pull only what's relevant

Deterministic keyword and regex search across every record — no embeddings, no fuzzy guessing.

HAND OFF

The next agent reads it first

Claude, Codex, Kiro, Cursor — or whatever comes next — starts from the same written record of what happened.

REASON

Work from notes you can trust

The model reasons from real records you can open, diff, and audit — not memory it invented.

Cross-agent continuity

One project history. Every agent reads it.

QiJu doesn't try to become the agent. It gives each host the same durable handoff record through explicit `qiju-log` and `qiju-search` skills, stored in your repo and your home directory.

→ Claude Code → Codex → Cursor → Kiro → whatever comes next

What QiJu is not

Intentionally small. Honestly scoped.

Memory

It doesn't make the model "remember more." It records what was done and where the proof is, so the next agent can verify and continue.

A database

It doesn't hold your bulk data. It records where that data lives — paths, counts, hashes, and evidence pointers.

Vector memory / RAG

No embeddings, no fuzzy similarity guessing. It finds records by exact filters and keywords.

A search engine

It surfaces likely-relevant records; the model decides what actually matters. There's no ranking score.

Chat history

Not a transcript dump. Intentional, structured records of decisions, evidence, and next steps.

An agent framework

It doesn't run or steer agents. It records sessions and hands context to whatever agent you use.

Platform memory

Your records are local files you own — not memory held on a vendor's servers.

Try it in five minutes

From clone to first handoff.

Install from the QiJu GitHub repository, wire it into your agent, log a decision — then open a different agent in the same repo and watch it recover the thread.

Source-first only for now. There's no npm install -g qiju, brew install qiju, or pip install qiju yet — package-manager releases come after the preview.

zsh — install & init

# 1 · install from source $ git clone https://github.com/jasonshrepo/qiju.git $ cd qiju && bash install.sh # 2 · wire it into a real repo $ cd ~/path/to/project $ qiju init --host claude ✓ agent skills installed, records preserved locally # 3 · in the agent: save, then hand off › /qiju-log what we decided and what's next › /qiju-search the last decision

Local ownership

Records live under your project and ~/.qiju. Read, diff, edit, back up, redact.

Lossless after capture

Once saved, a record is preserved — not repeatedly summarized down into a lossy recap.

Redaction & clean uninstall

Scrub secrets at write-time or after the fact. Uninstall never deletes your records.

QiJu is a record layer for AI coding agents.