Open source · MIT · One binary · macOS, Linux, Windows

The SME your team never had.

Kluris turns your AI agents into a subject matter expert that never sleeps and never quits — built collaboratively with you, one approved entry at a time.

Customizable brains · Human-curated · Git-backed · Free forever

Agents forget

Every new session starts from zero. Your codebase is re-learned every morning.

Docs are for humans

Wikis, Notion, Confluence — agents can't search them, link them, or write back.

Senior devs leave

The "why" behind every decision walks out with them. A year later nobody remembers.

Scroll

Kluris vs generated graphs

Discovery tools find the map. Kluris keeps the memory.

Graphify and Understand Anything are useful for understanding what exists in a repo or corpus. Kluris is where your team preserves the reviewed decisions, conventions, and cross-project context future agents should trust.

Swipe the comparison table horizontally.

Dimension Graphify Understand Anything Kluris
Core job Turn a folder of code, docs, papers, images, or video into a queryable knowledge graph. Analyze a codebase into an interactive dashboard of files, functions, classes, dependencies, and tours. Turn agents into team SMEs with shared, durable knowledge they can search, cite, and update.
Knowledge source Automatic extraction from artifacts using parsers, local processing, and LLM-assisted semantic passes. Automatic multi-agent scan of the current project, with structural parsing plus semantic summaries. Human-curated neurons: the agent proposes, but the team reviews and approves what becomes durable truth.
Best at Fast corpus discovery: structure, relationships, clusters, reports, and graph visualization. Repo onboarding: visual exploration, guided tours, semantic search, and change-impact understanding. Team memory: architecture decisions, conventions, lessons learned, deprecations, and context across many projects.
Output graphify-out/ with graph.html, GRAPH_REPORT.md, and graph.json. .understand-anything/knowledge-graph.json plus a dashboard and related generated artifacts. brain.md, map.md, glossary, neurons, synapses, git history, and MRI visualization.
Trust model Generated graph with confidence labels like extracted, inferred, or ambiguous. Generated summaries and relationships from a pipeline that can be re-run incrementally. Reviewed by default: knowledge is explicit markdown, versioned in git, and corrected by humans.
Team workflow Great first pass: map raw material, then decide what is worth keeping. Great onboarding layer: teach a repo quickly and expose impact before changing code. The durable layer: store only the decisions and lessons that should survive sessions, tools, and employees.
Use together

Run Graphify or Understand Anything to discover structure fast.

Review

Ask the agent which findings are durable decisions, risks, or conventions.

Remember

Save the approved takeaways into Kluris so every future agent starts smarter.

Beat 1 · Set up

Install kluris. Create a brain.

A brain is a git repo of curated markdown that every AI agent on your team can read as a subject matter expert. One command to install. One wizard to create your first one.

macOS · Linux Terminal
$ curl -fsSL https://kluris.ngvoicu.dev/install.sh | sh
# open a new terminal, then:
$ kluris doctor
Windows · PowerShell Terminal
> irm https://kluris.ngvoicu.dev/install.ps1 | iex
# from cmd.exe instead:
> powershell -ExecutionPolicy ByPass -c "irm https://kluris.ngvoicu.dev/install.ps1 | iex"
# open a new terminal, then:
> kluris doctor
Update · uninstall Terminal
$ kluris self-update          # newest release, then kluris doctor
$ kluris self-update --check  # only show the versions
$ kluris self-uninstall       # your brains stay
Install one particular release Terminal
$ curl -fsSL https://kluris.ngvoicu.dev/install.sh | KLURIS_VERSION=3.2.3 sh
> $env:KLURIS_VERSION = '3.2.3'; irm https://kluris.ngvoicu.dev/install.ps1 | iex

No admin rights. Kluris is one binary in ~/.kluris/bin, and the installer adds that folder to your PATH: open a new terminal so it takes effect. macOS (Apple Silicon and Intel), Linux x86_64 and arm64, Windows x86_64 and arm64. git is the only other tool it uses.

kluris create — interactive wizard Terminal
$ kluris create

Create a new brain

  Brain name (lowercase, hyphens ok): acme
  What does this brain cover? (one sentence): Shared brain for ACME projects
  Location [~]: ~/Projects
  Brain type (product-group, personal, product, research, blank) [product-group]:
  Git setup (1=local, 2=with remote, 3=no git) [1]: 1
  Default branch [main]:

  Install specmint companions for this brain?
    [1] specmint-core      (spec-driven-development companion)
    [2] specmint-tdd       (spec-driven-development with test-driven-development focus)
    [3] core + tdd
    [4] skip
    [5] specmint-core-html (spec-driven-development with canonical SPEC.html)
    [6] specmint-tdd-html  (TDD-focused specs with canonical SPEC.html)
    [7] all
  Choice [4]: 3
Brain created: acme (product-group)
  Path: ~/Projects/acme
  Lobes: 3

Agent skill installed: kluris-acme
  Claude/Codex/Antigravity/etc: /kluris-acme
  Hermes: /skill kluris-acme  (or start with `hermes -s kluris-acme`)
  Created a new Hermes profile later? Run `kluris doctor` to refresh Kluris skills.
The folder kluris just created · product-group defaults
acme/
├── kluris.yml              # gitignored — your local config
├── brain.md                # root directory, auto-generated
├── glossary.md             # domain terms, hand-edited
├── README.md               # usage guide
├── .gitignore
├── projects/
│   ├── map.md              # lobe index, auto-generated
│   └── (your neurons go here)
├── infrastructure/
│   ├── map.md
│   └── (your neurons go here)
└── knowledge/
    ├── map.md
    └── (your neurons go here)

Scaffolded defaults for the product-group brain type. You add, rename, or remove lobes as your team grows.

Every brain is a git repo. Your knowledge is markdown. Nothing is magic.

Beat 2 · Teach

Teach the brain what your team knows.

Open your AI agent in a project. Two steps make every future session smoother — first wire kluris in so every coding agent that lands in this repo finds the brain, then have the agent learn the project end-to-end. Lobes are folders you create to group related ideas — one per concern. Neurons are the markdown files inside them. You approve every neuron before it lands.

Step 1 · /kluris-acme setup

Wire kluris into the project.

Drop a small pointer into the project's CLAUDE.md and AGENTS.md. The agent surveys both, creates them if missing, or reformulates a stale pointer it finds. Same ## Knowledge base block in both files.

  • →Every coding agent in the repo finds the brain on the way in
  • →Same block in both files — no shim, no indirection
  • →Idempotent — re-run any time
In your AI agent, opened on a project (Claude Code, Cursor, Codex, …) Agent
> /kluris-acme setup this project

Surveying CLAUDE.md and AGENTS.md...

CLAUDE.md: missing — propose creating
AGENTS.md: missing — propose creating

Proposed ## Knowledge base section
(same in both files):
──────────────────────────────────────
  ## Knowledge base

  Read and write to the **acme** brain through kluris
  (never edit brain files by hand). Use the
  /kluris-acme skill — search, learn, remember, create.
──────────────────────────────────────

[a]pprove  [e]dit  [s]kip: a

✓ CLAUDE.md created
✓ AGENTS.md created (same block)
In your AI agent, opened on a project (Claude Code, Cursor, Codex, …) Agent
> /kluris-acme learn everything
                      about this project

Reading: src/, package.json, README,
schema/, .github/, docs/...

Proposing 12 neurons across 4 lobes:
  › projects/btb-core/auth-flow.md
  › projects/btb-core/data-model.md
  › projects/btb-core/api-shape.md
  › infrastructure/docker-builds.md
  › knowledge/raw-sql-no-jpa.md
  ... 7 more

Walking through, one at a time:

Neuron 1 / 12
Proposing: projects/btb-core/auth-flow.md
──────────────────────────────────────
# Auth flow

Keycloak OIDC. Frontend obtains JWT,
passes it to backend as Bearer token.
Backend validates via JWKS. Refresh
at 80% TTL.

Related: [clerk-vs-keycloak.md]
──────────────────────────────────────

[a]pprove  [e]dit  [s]kip: 
Step 2 · /kluris-acme learn

Learn everything about this project.

Point the agent at the whole project and let it propose neurons across every lobe — one at a time, with a preview of every piece before it is written.

  • →Approve, edit, skip, or change the target lobe
  • →Nothing is written without your sign-off
  • →The agent infers related neurons automatically

Agent = inside your AI coding agent, opened on a project. Terminal = in your shell.

Beat 3 · See

See the whole brain.

One command. A local, interactive map you can share.

kluris mri — one self-contained HTML file Terminal
$ kluris mri

MRI complete — /home/user/ngvoicu-sme/brain-mri.html
  Open: file:///home/user/ngvoicu-sme/brain-mri.html
  42 nodes, 242 edges

Open the link in any browser. Commit it, email it, drop it
in Slack — it runs anywhere, with no server.
kluris mri root view of a brain — its lobes and the glossary as C4-style boxes with synapse counts on the lines between them, the file tree on the left, and the Find and Recent panels on the right
The root view — each lobe as a box, synapse counts on the lines between them.

The header counts the brain (29 neurons · 242 synapses here), the file tree on the left collapses, and Find on the right searches neurons, paths, lobes, tags, and YAML, with the most recently updated neurons listed beneath. Click a folder to drill in; click a neuron to open it.

kluris mri neuron detail — one neuron open in a modal: back and forward buttons and its title at the top, its path and tags, buttons for the connected neurons, the rendered markdown, and the file tree on the left for jumping around
The neuron view — rendered markdown on the right, connected neurons as buttons along the top, the file tree on the left.

One click on any neuron box opens it in a modal, fully rendered, with its path, tags and connected-neuron buttons above the text and back and forward buttons to retrace your steps, so you can walk a topic in seconds. This is what agents see — now visible to you.

The MRI is a single self-contained HTML file — no server, no account, no external calls. Run kluris mri, open the link it prints in any browser, and you've got the whole brain to explore. It opens on the brain's lobes as C4-style boxes with the synapse counts between them. Click a folder to drill into its sublobes, click a neuron to read it rendered, and use the breadcrumb or back and forward buttons to walk out again.

It's a tool for three audiences at once: you (spot isolated neurons that should be cross-linked), your team (shared mental model of what we know), and new hires (five-minute onboarding instead of five days of spelunking). Since it's just HTML, you can commit it, email it, or drop it in Slack.

Lines between neurons are synapses — cross-links agents follow to load related context. Because the brain is a pre-digested snapshot, agents spend far fewer tokens orienting to a codebase than without one.

Beat 4 · Use

Ask the brain. Get grounded answers.

Every agent on your team can search and query across the brain. The agent shows you exactly which neurons it read — no hallucinations, no vibe.

SEARCH ranked search, in your own words In your AI agent · in a project
> /kluris-acme how does the app refresh its token?

→ kluris search "token refresh" --brain acme

3 result(s) for 'token refresh' in acme

  233  Auth flow
        projects/btb-core/auth-flow.md
        The web app refreshes the access token at
        80% of its lifetime...
  115  Keycloak setup
        infrastructure/keycloak-setup.md
   31  JWT signing key rotation
        knowledge/jwt-rotation.md

→ reading the top hit, section "Token refresh"
WHAT DO WE KNOW natural language Q&A across the brain In your AI agent · in a project
> /kluris-acme what do we know about Docker?

Reading:
  infrastructure/docker-builds.md
  infrastructure/environments.md

You build multi-stage Dockerfiles with
BuildKit. Images go to ghcr.io/zeespire/.
Prod uses Coolify on Hetzner with Cloudflare
Tunnel (zero public ports).

Ask in your own words; the agent turns the question into a kluris search. Results are ranked, not filtered: a match in a title or heading weighs more than one in the body, and each ## section is scored on its own, so a hit points at the heading and line where the answer is. Word forms and accents don’t matter (refreshing tokens finds “refreshes the access token”), in English and Romanian. Deprecated neurons stay in the results, ranked lower and labelled.

+ Pair · Specmint

Plan with context you didn't have to re-derive.

Kluris is the brain. Specmint turns a feature request into a persistent spec built from deep research and iterative interviews. Use them together and the research phase starts half-done — grounded in your code and the knowledge your team already agreed to.

1 · Shorter research

Forge reads your repo and consults the brain. Decisions the team already made don't get re-discovered from the code.

2 · Sharper interviews

Not "what's your auth?" — but "your brain says Keycloak for cost — should GitHub OAuth live behind it as an IdP, or beside it?"

3 · Traceable decisions

Every entry in the resulting SPEC.md cites the neuron that backs it. A week later you can still tell why.

/kluris-acme — write a spec, grounded in code + brain In your AI agent · in a project
> /kluris-acme write a spec to add OAuth sign-in with GitHub

Phase 1a · Codebase research
  ● Reading src/auth/ (14 files)
  ● Reading config/GlobalExceptionHandler.kt

Phase 1b · Brain research   ← the Kluris bit
  ● /kluris-acme what do we know about auth
    → knowledge/auth-decisions.md
    → projects/btb-core/auth-flow.md
    → knowledge/jwt-rotation.md

Phase 2 · Interview
  Q1. Brain says you chose Keycloak for cost.
       Should GitHub OAuth live behind Keycloak
       as an IdP, or alongside it?
  Q2. Auth-flow neuron says refresh-at-80% TTL.
       Same cadence for the GitHub session?

Phase 3 · Spec written
  ✓ .specs/github-oauth-signin/SPEC.md
  ✓ 3 phases · 14 tasks · 4 decisions logged
  ✓ Every decision references a neuron

Enable Specmint Companions

specmint-core

Markdown spec

Research · Interview · SPEC.md · Implement. The lightweight workflow shown above.

kluris companion add specmint-core bundled with kluris

specmint-tdd

Markdown + TDD

Same markdown forge flow, with strict TDD — a failing test before implementation.

kluris companion add specmint-tdd bundled with kluris

specmint-core-html

Canonical HTML

Spec-first workflow where .specs/<id>/SPEC.html is the source of truth.

kluris companion add specmint-core-html bundled with kluris

specmint-tdd-html

HTML + RGR

Canonical SPEC.html with TEST/IMPL pairs, red-green-refactor state, and TDD log.

kluris companion add specmint-tdd-html bundled with kluris

Enable companions per brain. Each one is a folder bundled with Kluris: a SKILL.md plus the references/ it points at, and assets/ for the two HTML flavors. Enabling one copies it into ~/.kluris/companions/<name>/ and adds a short reference to the brain’s generated kluris-<name> skill. Companions are read from there, never installed as skills of their own, and kluris doctor refreshes them.

Beat 5 · Grow

Your brain grows with your team.

Add lobes, add neurons, keep going — all through the agent.

/kluris-acme · add a new lobe In your AI agent · in a project
> /kluris-acme add a compliance lobe for SOC2
         and GDPR notes

Proposing new lobe: compliance/
  ✓ will create compliance/map.md
  ✓ will link into brain.md

[a]pprove  [c]ancel: 
/kluris-acme · add a neuron in the new lobe In your AI agent · in a project
> /kluris-acme remember that SOC2 audit evidence lives in
         the compliance-evidence/ bucket, rotated yearly

Proposing: compliance/soc2-evidence.md
──────────────────────────────────────
# SOC2 audit evidence

Evidence artifacts live in the `compliance-evidence/`
S3 bucket. Rotation is annual. Access is restricted
to the security team.
──────────────────────────────────────

[a]pprove  [e]dit  [s]kip: 

Lobes are folders, neurons are markdown files inside them — but you don't create them by hand. Ask the agent. It proposes the structure, shows you the diff, and writes it only after you approve. Nesting works the same way: "add a sublobe for the endpoints of acme-api" and the agent puts it in the right place.

The loop closes. After every shipped feature — bug fix, deploy, env-var change — ask /kluris-acme remember what we worked on and the agent drafts new neurons from the session. Approve, edit, reject. The brain that taught you today gets a little smarter for tomorrow's teammate.

Run kluris dream to regenerate maps and validate links after structural changes. The agent commits what you approved with kluris commit, which brings your teammates’ changes in and pushes yours — see working together. Have more than one brain? Each installs as /kluris-<name> and everything above works the same — see the appendix.

Beat 6 · Self-improve

Let the brain review itself.

Ask the agent to audit the brain. It reads across every neuron, spots connections you never wrote, and proposes new synapses — you approve each one before anything changes.

the brain reviewing itself In your AI agent · in a project
> /kluris-acme review this brain and create more synapses

Reading 34 neurons across 3 lobes...

Found 14 connections you haven't written yet:
  › projects/btb/auth-flow.md       ↔ knowledge/jwt-rotation.md
  › infrastructure/docker-builds.md ↔ infrastructure/environments.md
  › knowledge/use-raw-sql.md        ↔ projects/btb/reporting.md
  › projects/btb/import.md          ↔ infrastructure/keycloak-setup.md
  ... 10 more

Proposed update · projects/btb/auth-flow.md
──────────────────────────────────────
  ---
  title: Auth flow
  related:
    - ./clerk-vs-keycloak.md
    - ../knowledge/jwt-rotation.md   (new)
  ---
──────────────────────────────────────

[a]pprove all  [o]ne-by-one  [s]kip: o

Stepping through 14 proposed synapses...

✓ 12 applied · 2 skipped
✓ bidirectional links written
✓ maps regenerated

Grounded

The agent only proposes synapses between neurons that already exist — no hallucinated references.

Reviewed

You approve every change — one-shot, one-by-one, or skip — before anything is written to disk.

Compounding

Re-run it monthly. As the brain grows, the agent finds new patterns and your knowledge graph gets denser.

Beat 7 · Capture session

Close the loop on every pairing session.

At the end of a long pairing session — research, debugging, decisions, gotchas — sweep the conversation into the brain in one step. The agent replays the chat, pulls every brain-worthy fact, and walks you through proposed neurons one at a time.

/kluris-acme remember from this session · the sweep In your AI agent · in a project
> /kluris-acme remember everything from this session

Replaying the conversation...
Identifying brain-worthy items:

  › Decision: use TIMESTAMPTZ for every timestamp column
  › Convention: API errors must include error_code alongside message
  › Gotcha: Cloudflare Tunnel blocks port 587 — use 465 SMTPS
  › Stakeholder: legal flagged session-token storage for review
  ... 3 more candidates

Routing each to the right lobe...

Item 1 / 7
Proposing: knowledge/timestamps-tz.md
──────────────────────────────────────
# Use TIMESTAMPTZ for every timestamp column

Decided 2026-05-12. Standardized on
TIMESTAMPTZ over TIMESTAMP in every
schema change. Reason: avoids the
silent UTC drift gotcha when servers
or clients sit in different timezones.

Related: [../projects/btb-core/data-model.md]
──────────────────────────────────────

[a]pprove  [e]dit  [s]kip: a

✓ 5 of 7 captured, 2 skipped, 0 edited
→ kluris commit · kluris: acme: pushed

No retyping

You don't repeat decisions to the agent — it already heard them. The sweep extracts what's worth keeping and skips ephemeral debugging.

Same approval

Each candidate goes through the standard approve · edit · skip flow. Nothing lands without your sign-off.

Compounds

Tomorrow's agents start their session with what last week's agents learned. Pairing sessions become permanent team knowledge.

Or capture a single decision in one line: /kluris-acme remember we chose raw SQL over JPA. Same flow, just narrower.

Together · One brain, many people

Edit one brain as a team.

Every teammate’s agent reads and writes the same brain. Clone it and register it once: from then on every command that opens it keeps it in step, and nobody pulls, pushes or untangles a merge by hand.

Alice and Bob each work at a laptop that holds their own copy of the team's brain, with the shared brain glowing above them. 1: a purple arrow brings a teammate's note down to Bob's copy. 2: a pink arrow carries Alice's approved note up to the shared brain. 3: two notes with different lines changed join into one. 4: two versions of the same line side by side; Bob picks one and it goes up. 5: a dotted line with a moon carries Alice's housekeeping up in the background.
  1. Reads bring the team in.

    Before your agent reads, Kluris pulls your teammates’ commits: at most once a minute, within 3 seconds. A file you’re still editing is never overwritten.

    kluris wake-up · search · status

  2. You approve, it’s shared.

    The agent commits exactly the files you approved and the maps they change, pulling first and pushing after.

    kluris commit --paths knowledge/auth.md

  3. Different parts merge on their own.

    Two edits that don’t touch the same lines become one, and nobody is asked.

    pulled 1 commit; auto-merged knowledge/auth.md; pushed

  4. The same line goes to a person.

    The agent shows both versions, asks which to keep, writes it and finishes the merge. Until then the merge waits: your file stays as you wrote it, and nothing is pushed.

    kluris commit --merge <id> --paths <file>

  5. Housekeeping goes out on its own.

    dream and mri commit the brain’s own tidying, and commits left waiting go out in one background push.

    kluris dream · mri

join the team’s brain, once Terminal
$ git clone git@github.com:acme/acme-brain.git ~/brains/acme
$ kluris register ~/brains/acme
Brain registered: acme
  Path: /Users/bob/brains/acme

Agent skill installed: kluris-acme
  Claude/Codex/Antigravity/etc: /kluris-acme
the agent writes, the team gets it In your AI agent · in a project
> /kluris-acme remember access tokens are signed
             with RS256

→ kluris search "access tokens" --brain acme
1 result(s) for 'access tokens' in acme
  353  Auth flow
        knowledge/auth.md
        Access tokens live 15 minutes.

kluris: acme: pulled 1 commit

Proposing update: knowledge/auth.md
- Access tokens live 15 minutes.
+ Access tokens live 15 minutes, signed with RS256.
[a]pprove  [e]dit  [s]kip: a

→ kluris commit --brain acme --paths knowledge/auth.md
Committed 94380f6 in acme: kluris: update knowledge/auth.md
  knowledge/auth.md
kluris: acme: pushed
two people changed the same line: you pick one In your AI agent · in a project
> /kluris-acme remember access tokens live 30 minutes
  ...
→ kluris commit --brain acme --paths knowledge/auth.md
Committed 0eefccb in acme: kluris: update knowledge/auth.md
  knowledge/auth.md
kluris: acme: 1 conflict (knowledge/auth.md) in merge e46c333aabf0; 1 commit to push

A teammate changed the same line first. Your file is as you wrote it, and nothing is pushed.
  yours     Access tokens live 30 minutes, signed with RS256.
  teammate  Access tokens live 20 minutes, signed with RS256.
Which one do we keep? [y]ours  [t]eammate’s: t

→ writes the teammate’s version to knowledge/auth.md
→ kluris commit --brain acme --merge e46c333aabf0 --paths knowledge/auth.md
Committed c981616 in acme: kluris: sync (resolved)
  knowledge/auth.md
kluris: acme: pushed

Merged on their own

  • →Changes to different files, or to different parts of one neuron
  • →tags and related: both lists joined
  • →created and updated: the earlier and the later date
  • →The generated map.md and brain.md, rebuilt

Left for a person

  • →Edits to the same lines
  • →A file deleted on one side and edited on the other
  • →parent, or another frontmatter field, changed differently on both sides
  • →A file on one side and a folder on the other, a binary file, or a path under a file of your brain: settled with kluris resolve

There is nothing to turn on. Kluris never asks for credentials, runs your repository’s git hooks as git does, and needs git 2.38 or newer. kluris sync does it all by hand.

Reference

Two surfaces, one brain.

Kluris lives in two places. You run the CLI in your terminal to set up and maintain your brains. Your AI agents load one named skill per brain — kluris-<name> — inside Claude Code, Cursor, Codex, Copilot, Devin, OpenCode, Kilo Code, Junie, Hermes Agent or Antigravity CLI (or any other agent that loads SKILL.md skills and can run a shell), followed by whatever you want to say. Keep the agent open on a project so it has code to read.

Terminal where you type

$ kluris <cmd>

Run in your shell — bash, zsh, fish, PowerShell. The purple $ prompt. Use it for install, setup, snapshots, and housekeeping.

Agent where the agent types

> /kluris-acme <pattern>

Run inside your AI coding agent — Claude Code, Cursor, Codex, Copilot, Devin, OpenCode, Kilo Code, Junie, Hermes Agent, Antigravity CLI — with a project open. Most agents invoke /kluris-acme; Hermes uses /skill kluris-acme or hermes -s kluris-acme. Use it while coding to teach and query the brain.

In your terminal  ·  $ kluris *

Terminal

Run these in bash, zsh, fish, or PowerShell.

createCreate a new brain (a wizard, or --type, --remote, --no-git)
register <path>Register an existing brain directory on disk
listList registered brains
statusShow brain tree, recent changes, and neuron counts
search <query>Ranked search across neurons, glossary, and brain.md
wake-upCompact brain snapshot the agent loads once per session
companion listCompanion playbooks, which are installed, which brains use them
companion addTurn a companion on for a brain
companion removeTurn a companion off for a brain
dreamRegenerate maps, auto-fix safe issues, and validate links
mriGenerate the interactive brain visualization; prints a file:// link
remove <name>Unregister a brain (keeps files on disk)
doctorCheck prerequisites and refresh installed agent skills
helpThe command list, or one command’s summary
commitCommit approved brain files and the maps they change (--paths)
syncFetch, merge and push brains; conflicts go to a person (--brain all)
resolve <path>Settle an open sync conflict path by path (--ours, --theirs, --file)
self-updateUpdate kluris to the newest release (--check only looks)
self-uninstallRemove the installed kluris; brains stay (--purge: also ~/.kluris and Kluris skills)

All CLI commands support --json for machine-readable output.

Every command that acts on a brain — search, wake-up, status, dream, mri, commit, sync, resolve, companion — takes --brain NAME. With two or more brains registered, see more than one brain.

Brains are plain git repos. Every command that opens one keeps it in step with your team, and kluris sync fetches, merges and pushes on demand; plain git works too, for branches and history.

Most users create and organize lobes and neurons by asking their AI agent, then run dream to refresh maps and links.

Inside your AI agent  ·  > /kluris-acme ...

Agent

Each brain has its own skill — kluris-<name>. Most agents expose it as /kluris-<name>; Hermes loads it with /skill kluris-<name>.

Type these inside Claude Code, Cursor, Codex, Copilot, Devin, OpenCode, Kilo Code, Junie, Hermes Agent or Antigravity CLI — with a project open, so the agent can read your code. Examples below use /kluris-acme for clarity.

/kluris-acme learn <topic>Agent analyzes code, proposes neurons
/kluris-acme remember <fact>Quick-capture a decision as a neuron
/kluris-acme remember from this sessionSweep the current chat, propose neurons for everything worth keeping
/kluris-acme add a <name> lobePropose a new lobe, approve before it lands
/kluris-acme add a sublobe for ...Nest a lobe under an existing one
/kluris-acme search <term>Search the brain for a topic
/kluris-acme what do we know about ...Ask the brain a question
/kluris-acme use brain knowledge and codebase and let's write a spec for ...Ground a spec in both the brain and the live code
/kluris-acme use brain knowledge and codebase and let's implement ...Implement a feature grounded in both the brain and the live code
/kluris-acme review this brainAudit the brain, propose more synapses
/kluris-acme create a decisionCreate a decision record neuron
/kluris-acme create an incidentCreate an incident report neuron
/kluris-acme create a runbookCreate a runbook neuron
/kluris-acme open <file>Open a neuron and read it
/kluris-acme deprecate <file>Mark a neuron as deprecated

Agent patterns are free-form — say it naturally. The agent figures out the shape.

What the agent does first

Agent

On the first /kluris-acme of a session, the agent runs kluris wake-up --brain acme --json once, through its shell. It keeps that snapshot — the brain.md body, every lobe with its neuron count, the 5 most recently updated neurons, the glossary, and any deprecation warnings — so it can decode your jargon and avoid citing superseded neurons. It refreshes the snapshot only after the brain changes: a remember or learn, a kluris dream, a kluris sync that merged teammates’ changes, or a file edit you tell it about. Teammates’ changes arrive through the kluris sync it runs before every write, or whenever you ask for the latest.

BOOTSTRAP In your AI agent
> /kluris-acme what do we know about Docker?
→ first call this session, via its shell:
  kluris wake-up --brain acme --json
→ snapshot cached: brain.md · lobes · recent
  · glossary · deprecation warnings
→ later turns reuse it; refreshed only
  after remember, learn, dream or a merge

You never call it yourself. To see what the agent sees, run kluris wake-up --brain acme in your terminal (add --json for the raw payload).

Where the skill goes

Agent

Every brain installs as one kluris-<name> skill: a SKILL.md with instructions and the kluris commands to run. Kluris writes it to the shared folder most agents read, and gives a few agents their own copy.

~/.agents/skills/Cursor, Codex, Devin, OpenCode, Kilo Code, Junie and other agents that read this shared folder
~/.claude/skills/Claude Code
~/.hermes/skills/ + profiles/*/skills/Hermes Agent, its own folder and every profile
~/.gemini/config/skills/Antigravity CLI (agy)
$COPILOT_HOME/skills/GitHub Copilot, when COPILOT_HOME is set

Created a new Hermes profile, or set COPILOT_HOME, after adding a brain? Run kluris doctor to install the skills there too. To skip an agent, trim agents.commands_for in the brain’s kluris.yml; the shared folder always gets every brain’s skill.

Appendix

More than one brain.

A work brain, a personal brain, a team brain you cloned from GitHub — kluris keeps them separate. Each brain installs as its own named skill, so the agent never has to guess which one you mean.

juggling three brains at once Terminal
$ kluris list
Registered Brains
Name      Path                       Description                      Companions
--------  -------------------------  -------------------------------  ---------------------------
acme      ~/Projects/acme            Shared brain for ACME projects   specmint-core, specmint-tdd
personal  ~/Projects/personal-brain  Personal tasks, notes and ideas  (none)
research  ~/Projects/research-brain  Research notes and findings      (none)

$ kluris status
Multiple brains registered. Pick one:
  [1] acme  (~/Projects/acme)
  [2] personal  (~/Projects/personal-brain)
  [3] research  (~/Projects/research-brain)
  [4] all
Choice: 2

personal
  Lobes: 3, Neurons: 18
  2026-04-05 brain: capture q2 goals
  2026-04-04 brain: initialize personal

$ git clone git@github.com:acme/team-brain.git ~/brains/team-brain
  Cloning into ~/brains/team-brain...

$ kluris register ~/brains/team-brain
Brain registered: team-brain
  Path: ~/brains/team-brain

Agent skill installed: kluris-team-brain
  Claude/Codex/Antigravity/etc: /kluris-team-brain
  Hermes: /skill kluris-team-brain  (or start with `hermes -s kluris-team-brain`)
  Created a new Hermes profile later? Run `kluris doctor` to refresh Kluris skills.
naming the brain: --brain, all, and scripts Terminal
$ kluris dream --brain all
acme health report:
  Lobes: infrastructure, knowledge, projects
  Maps regenerated: 3 (infrastructure, knowledge, projects)
  OK synapses
  …
personal health report:
  …
research health report:
  …
Brain is healthy.

$ kluris search auth --brain all
Error: --brain all is only supported on dream, status, mri, sync, and companion commands.

$ KLURIS_NO_PROMPT=1 kluris status
Error: Multiple brains registered. Pass --brain NAME or 'all'. Available: acme, personal, research

--brain NAME

Names the brain and skips the picker. Every command that acts on a brain takes it: search, wake-up, status, dream, mri, commit, sync, resolve and companion list / add / remove. Each installed kluris-<name> skill passes it for you, so an agent never meets the picker.

The picker

With two or more brains registered and no --brain, in a terminal, kluris asks which one you mean. The fan-out commands offer all as the last choice; wake-up, search, commit and resolve work on one brain, so they don’t. A brain whose folder has gone missing is marked (missing).

--brain all

Runs the command on every registered brain. Accepted only on the fan-out commands — dream, status, mri, sync and companion list / add / remove. Any other command rejects it with an error.

Scripts and CI

With --json, with no TTY, or with KLURIS_NO_PROMPT=1 there is no picker: kluris exits with an error that lists the registered brains (a JSON object under --json). Always pass --brain in scripts; set KLURIS_NO_PROMPT=1 for wrappers that inherit a terminal but can’t answer a prompt.

git clone + kluris register --brain NAME skips the picker One skill per brain Keep work and personal separate Every brain has its own git history

Your SME starts here.

Free forever. One shared brain for the AI agents your team already uses.

MIT licensed · One binary, no admin rights · Works offline · All data is yours

Installs a skill your agents already read

Claude Code · Cursor · Codex · GitHub Copilot · Devin · OpenCode · Kilo Code · Junie · Hermes Agent · Antigravity CLI

Kluris writes one kluris-<name> SKILL.md per brain into the shared ~/.agents/skills/ folder, which Cursor, Codex, Devin, OpenCode, Kilo Code, Junie and others read. Claude Code (~/.claude/skills/), Hermes Agent (its own folder and every profile), Antigravity CLI (~/.gemini/config/skills/) and GitHub Copilot ($COPILOT_HOME/skills/, when COPILOT_HOME is set) get their own copy. The skill is plain instructions plus shell calls to the kluris CLI, so any other agent that loads SKILL.md skills from one of those folders and can run a shell can use it too.

ngvoicu.dev
AI-Native Consulting

Want your team to work like this?

Kluris is one piece of a larger AI-native toolkit — and of a way of working your whole team can adopt: talks ("Becoming an AI Native Company"), hands-on team training that teaches employees to use AI, and AI adoption consulting for engineering teams.

office@ngvoicu.dev · +40 734 704 910

AI-native consulting →