enzyme

<div align="center">

# 🧬 Enzyme

[![Discord](https://img.shields.io/discord/1191288276536008745?label=Discord&logo=discord&style=flat-square)](https://discord.gg/nhvsqtKjQd)
[![License](https://img.shields.io/github/license/byenzyme/enzyme?style=flat-square)](LICENSE)
[![Release](https://img.shields.io/github/v/release/byenzyme/enzyme?style=flat-square)](https://github.com/byenzyme/enzyme/releases/latest)
[![Downloads](https://img.shields.io/github/downloads/byenzyme/enzyme/total?style=flat-square&label=Downloads&color=6c757d)](https://github.com/byenzyme/enzyme/releases)

</div>

Enzyme compiles your notes and other knowledge sources into a local index that:

1. Uses temporally grounded context sampling that captures the contextual use of tags and wikilinks, or natural accumulation in folders (i.e. pseudo-[Zettelkasten](https://zettelkasten.de/introduction/))
2. With this context, generate questions (called **catalysts**) and embed them as semantic routes to the whole knowledge base
3. Keeps refreshing, but separates new doc ingestion (local, fast) from catalyst evolution (cheap, periodic)

When your agent passes queries through the catalysts, it gets a more personalized way to get caught up on the knowledge base.

Enzyme saves an editable reading program. `workspace` blocks describe Markdown,
Are.na, and SQLite sources. Existing `vault` programs remain readable.
[**Jev**](https://typesafe.ai/blog/introducing-system-one-models-and-jev)
can generate the Markdown program through a deterministic scan:

```
profile relationships {
  seek "what matters between people"
  notice ["meaningful exchanges", "shared interests", "unfinished conversations"]
}

workspace "notes" {
  source markdown "notes" { path "~/notes" }

  question budget 40
  sample across time
  favor recent periods

  learn questions from folder "people"
    including linked pages
    about relationships
  learn questions from folder "meetings" about operational
  learn questions from tags ["founding", "ai-ux"] about decisions
  learn questions from folder "inbox"

  project questions into "~/notes/Readwise"

  // Guidance compiled for your agent, not an enforced hook.
  when asked {
    "Use grep for names, titles, and exact phrases."
    retrieve passages through learned questions
    answer with sources
  }
}
```

For a Markdown folder addressed by path (`enzyme -p <folder>`), the source path
remains the runtime and index location, and changing an existing `vault`
program to this form does not move its index. Addressed with
`--workspace <name>`, the same folder gets its own index under
`$ENZYME_HOME/workspaces/<name>/`, built from scratch on the first `init`.

## Get started

Open your Markdown notes folder in an agent that can run terminal commands, such
as Claude Code or Codex, and paste this prompt. If your agent is open elsewhere,
replace the first sentence with the path to your notes.

```text
Set up Enzyme for the Markdown notes folder I have open. If you cannot identify it, ask me for its path.

Install Enzyme if needed using https://raw.githubusercontent.com/byenzyme/enzyme/main/install.sh, and install the instructions for this agent. Read and follow the installed enzyme-workspace-setup skill.

You may use Enzyme's online service to suggest settings from my notes and prepare search. Show me what you propose to include or exclude, and let me correct it before building the local search index.

Then answer one useful question using my notes, with links to the sources, and suggest a question I can ask next. Keep my existing notes in place and unchanged. Ask separately before any cleanup, model download, or recurring task.
```

The agent installs Enzyme, reviews the settings with you, and demonstrates an
answer from your own notes. You can keep writing and organizing your notes as you
already do; cleanup is not a prerequisite.

### Terminal setup

If you prefer to install it yourself:

```bash
curl -fsSL https://raw.githubusercontent.com/byenzyme/enzyme/main/install.sh | bash
cd /path/to/your/notes
enzyme install claude # or: codex, hermes, openclaw
```

Then use the prompt above. For setup without an agent:

```bash
enzyme compile -v
# Review the .enzyme settings file at the path printed by compile.
enzyme init --quiet
enzyme doctor
enzyme petri --query "a question about your notes"
enzyme catalyze "a question about your notes"
```

For Markdown notes, run `enzyme compile` and review the settings file it saves
before `enzyme init` builds the local index.

For Apple Notes, a preset builds a named `workspace` program from your Notes
database. Review the saved `.enzyme` program before running `init`:

```bash
enzyme --workspace apple-notes compile --preset apple-notes \
  "$HOME/Library/Group Containers/group.com.apple.notes/NoteStore.sqlite"
enzyme --workspace apple-notes init
```

For Are.na, use `enzyme --workspace <name> compile --preset arena <channel-url>`
and then `enzyme --workspace <name> init`. Run `refresh` with the
same `--workspace` name to pick up later changes (`--collection` is an accepted
alias).

Scripts and host apps can rely on defined exit codes (0 ok, 1 runtime failure,
2 usage, 3 configuration, 4 workspace busy, 5 `init` indexed but catalysts
failed their quality gate). Concurrent `init`/`refresh` calls
on one workspace wait for each other, bounded by `--lock-timeout`.

Enzyme was built for knowledge bases that grow rapidly:

* Agent memory corpora
* Zettelkasten practices in Obsidian that accumulate new dated notes into singular folders
* Meeting transcriptions built around AI-native, Markdown CRM setups.

It's designed to support knowledge captures that might be later be important, even if they don't serve a current task. Enzyme is focused on doing one thing well: **giving agents the tools to make ideas compound**.

And it ships with a set of `profiles` designed around a personal knowledge base, that were refined over [2 years of personal use](https://joshpham.com/kit/how-i-use-enzyme). Here are some examples of how they are used:


| Read...                  | For...                                          | Profile               |
|--------------------------|-------------------------------------------------|-----------------------|
| Project notes            | what's stuck and what keeps blocking            | `operational`         |
| Decision records         | why a choice won, what would change it          | `decision_trace`      |
| Saved articles           | connections to what you're already working on   | `resonance_trace`     |
| Journals                 | what keeps returning across entries             | `reflective`          |
| People notes             | what matters in these relationships             | `relational`          |
| Feedback / activity logs | what works for you, under what constraints      | `preference_evidence` |
| *(default)*              | costs, assumptions, live tensions               | `tension_trace`       |

## Agent tools for retrieval

`enzyme petri` shows what Enzyme found worth asking about. In an interactive terminal it renders a tree; piped, it emits JSON:

```bash
enzyme petri | jq '.entities[:2]'
```

```json
[
  {
    "name": "system-design",
    "type": "tag",
    "activity_trend": "active",
    "frequency_12m": 84,
    "catalysts": [
      {
        "text": "What does the commitment to simplicity cost when the pressure to ship keeps winning?",
        "context": "velocity vs craft in infrastructure",
        "era": "2024-Q3"
      },
      {
        "text": "Where does the analysis of user needs gather information that delays rather than clarifies the core value?",
        "context": "research as avoidance",
        "era": "2025-Q1"
      }
    ]
  },
  {
    "name": "working-with-others",
    "type": "tag",
    "activity_trend": "rising",
    "frequency_12m": 47,
    "catalysts": [
      {
        "text": "What assumptions about leadership are held by those who are good at building things?",
        "context": "craft vs delegation",
        "era": "2024-Q4"
      },
      {
        "text": "How does the goal of not depending on others shape the approach to collaboration?",
        "context": "independence vs team trust",
        "era": "2025-Q2"
      }
    ]
  }
]
```

Each entity carries catalysts spanning different eras — questions that cut across months of content.

```bash
enzyme catalyze "why we keep rewriting the auth layer"
```

```json
{
  "query": "why we keep rewriting the auth layer",
  "results": [
    {
      "file_path": "retros/2024-q3-platform-retro.md",
      "content": "scoped auth extraction as a two-week project for the third time. real blocker wasn't the token service — nobody wanted to own the session model. every proposal added a layer instead of removing one.",
      "similarity": 1.46
    },
    {
      "file_path": "adrs/007-auth-service-extraction.md",
      "content": "the monolith's session handling has become the bottleneck for every team shipping independently. chose separation of concerns over the coordination cost of a new service boundary.",
      "similarity": 1.24
    },
    {
      "file_path": "reading/highlights-accelerate.md",
      "content": "'Teams that can deploy independently are twice as likely to be in the high-performer category.' — we keep choosing the rewrite over the boundary.",
      "similarity": 1.13
    }
  ],
  "top_contributing_catalysts": [
    {
      "entity": "system-design",
      "text": "What does the commitment to simplicity cost when the pressure to ship keeps winning?",
      "relevance_score": 0.74
    }
  ]
}
```

*Output above is illustrative — it shows the shape of a result, not a captured run.*

## message archives (_experimental_)

Enzyme indexes SQLite tables alongside Markdown — iMessage, WhatsApp, Mail, or any table of dated rows.

Declare a `source sqlite` inside a named `workspace` program, then run `init`
and periodic `refresh`. The [SQLite source setup skill](https://github.com/byenzyme/enzym