Build knowledge
your agents can rely on.

Turn work into shared knowledge.

The fix your agent found today should help the next agent tomorrow.

Ask your agent to save what you learned, right inside its chat window. Or capture directly through MCP, SSH or the API. It becomes a file in your shared workspace, ready for the next task.

cat > /runbooks/retry-policy.md <<EOF
# Retry policy
1. Retry transient failures only.
2. Use exponential backoff with jitter.
3. Stop after three attempts.
EOF

$ cat retry-policy.md |
  ssh -p 2222 writer@knowledge \
  'cat > /runbooks/retry-policy.md'

curl https://knowledge.example/api/shell \
  -H "Authorization: Bearer $OPENLORE_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"command":"cat > /runbooks/retry-policy.md <<EOF\n# Retry policy\n1. Retry transient failures only.\n2. Use exponential backoff with jitter.\n3. Stop after three attempts.\nEOF"}'

Your workspace. Your rules.

Decide what belongs in your knowledge repository before it gets there.

Set file budgets, apply rules by folder and validate knowledge formats. The same write checks apply across SSH, MCP and the API.

version: 1
rules:
  concise:
    match: ["**/*.md"]
    use: size/lines
    with: { max: 120 }
  small:
    match: ["**/*.md"]
    use: size/kilobytes
    with: { max: 64 }

version: 1
rules:
  short-runbooks:
    match: ["**/*.md"]
    use: size/lines
    with: { max: 100 }

# Applies inside /runbooks.
# Other folders keep their own rules.

version: 1
rules:
  knowledge-format:
    match: ["**/*.md"]
    use: okf

# Open Knowledge Format (OKF)
# checks each concept on write.

shellexec:
  pre_commit:
    - cmd: "/usr/local/bin/check-knowledge"
      timeout: 10s
  post_write:
    - cmd: "/usr/local/bin/notify-indexer"
      async: true

# Use your own scripts for these steps.
# Check knowledge before saving it.
# Notify your search tool after it is saved.

# A shared Agent Skills collection
/skills/
  incident-response/
    SKILL.md
    references/

Keep the knowledge.
Keep the connection.

Shared drives are where docs go to die. Keep useful knowledge connected to the work behind it.

Bring the decision into OpenLore and keep a link to the original issue, pull request or research. Your existing tools stay the source; your agents get the context in one place.

Shared knowledge.
Not shared permissions.

Give each person and agent the access they need. Nothing more.

Define read and write permissions by role, scoped to a set of files. The same policy applies over MCP, SSH and the API. Share file links without opening the whole workspace.

{
  "docsets": {
    "runbooks": {
      "paths": ["/runbooks"],
      "access": {
        "allow": {
          "maintainer": "rw",
          "researcher": "ro"
        },
        "deny": ["external"]
      }
    }
  }
}

Knowledge you can see.
Infrastructure you control.

A shared view for your agents. An inspectable workspace for you.

See how knowledge fills your workspace, explore its context footprint, inspect agent activity and improve your skills over time. OpenLore is self-hosted: you own the files, choose where it runs and define who gets access.

Install it. Or ask your agent.

One binary. Your files. Start locally, then configure access and share it with your team.

# 01 — Install
curl -fsSL https://openlore.sh/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"

# 02 — Serve your documentation
openlore ./docs

# 03 — Explore from another terminal
ssh -p 2222 localhost "ls /"

Help me install and configure OpenLore.
Fetch the setup guide with `ssh openlore.sh teach`
and follow its instructions with me.

Before sharing a server, configure authentication, grants, HTTPS, and persistent storage.

Auth · Configure the server · Example openlore.yml

Verify this server.

Verify the fingerprint through a trusted channel before adding this key to known_hosts.

Apache 2.0. Built in Go.

The server and docs are developed in the open. Contributions welcome.