Generated banner for understory 🌱
Generated logo for understory 🌱

understory 🌱

Memory framework

First committed by thecodacus

Published in thecodacus/understory. Publisher page

345 GitHub stars

What it is

LLM-managed knowledge base following the OKF spec β€” MCP server + web UI
β€” the description by thecodacus

AutoGineer overview, from the brain’s own files

Understory is a memory framework designed to act as the persistent knowledge layer for AI agents. It organizes information as a living knowledge graph of plain markdown files, adhering to the Open Knowledge Format (OKF) v0.1 specification. By providing an MCP server and a web UI, it allows agents to query, add, and maintain their own knowledge base. The system emphasizes graph health through deterministic maintenance tools that automatically resolve orphans and broken links, ensuring the knowledge base remains structured and navigable. It supports multiple isolated memory profiles, making it suitable for managing distinct contexts like work, health, or personal projects, all while remaining human-readable and git-diffable.

How it works

Memory model: LLM wiki

AutoGineer overview, from the brain’s own files

Understory stores information as markdown files with YAML frontmatter in a bundle directory. It provides an MCP server that exposes tools for agents to query, add, update, and maintain these files. The system uses an internal agent to manage the knowledge graph, ensuring that new information is either integrated into existing concepts or back-linked correctly. A web UI provides a visual representation of the graph, while a maintenance tool automatically identifies and fixes orphaned concepts or broken links. The system can be configured to run locally or via Docker, supporting various LLM providers for the agent's reasoning tasks.

Folders
FolderRoleFiles
.githubagent-config1
packagessource-code78
scriptsscripts1
sample-bundlefolder8

The agent writes

Requirements

Apps: Docker

Runtimes: Node.js >=20

API keys (by name): ADMIN_TOKEN, ANTHROPIC_API_KEY, AUTH_TOKEN, DEEPSEEK_API_KEY, LLAMACPP_API_KEY, LLM_API_KEY, LLM_FALLBACK_API_KEY, LOCAL_API_KEY, OPENROUTER_API_KEY

Works with: Claude Code

Set it up

  1. Not scanned by AutoGineerThe author’s README also describes installing it with Docker Compose. Read its install section: AutoGineer did not scan that path. https://github.com/thecodacus/understory/blob/7625aa400086d2c1fb81cbbc4975ce00cc23ec77/README.md#quick-start-docker
  2. First committed by thecodacus. Published in thecodacus/understory. Licence: Apache License 2.0.

Usage

AutoGineer overview, from the brain’s own files

  • Connect the MCP server to an AI agent to provide persistent, long-term memory.
  • Use the web UI to visualize the knowledge graph and manually inspect or chat with the agent about the stored data.
  • Run maintenance tasks to automatically clean up and wire orphaned concepts within the knowledge base.
  • Manage multiple isolated memory bundles using the profile system for different project contexts.
  • Track agent reasoning paths through trace logs to understand how information was retrieved or updated.
β€œmemory_add: We deploy on Fridays, never Mondays.”
The agent creates or updates a concept in the markdown bundle and wires it into the knowledge graph.
β€œmemory_maintain”
The agent scans the graph for orphans or broken links and automatically repairs them to ensure structural integrity.

Documentation by thecodacus

understory 🌱

Memory that grows.

The layer beneath your agents: a self-wiring, plain-markdown memory. Every fact your agents learn is filed as a markdown concept, cross-linked into a living knowledge graph, and kept healthy by the agent itself β€” searchable, diffable, and entirely yours. Runs great on local models.

Bundles follow the Open Knowledge Format (OKF) v0.1 spec β€” plain markdown files with YAML frontmatter, readable by humans, diffable in git, portable across tools.

Three ways in, one agent:

  • MCP server β€” memory_query / memory_add / memory_update / memory_status / memory_maintain tools over stdio or streamable HTTP. Each call drives an internal LLM agent with the OKF spec in its system prompt.

  • Web UI β€” browse the bundle (tree, concept viewer with Mermaid diagrams, update log, conformance badge), see the memory as an Obsidian-style force-directed graph (drag/pan/zoom, colored by type, sized by connections, orphans ringed red, click to open), and chat with the same agent to test it. Tool calls render inline so you can watch it work.

  • Query-path replay β€” every agent run (query/mutation/chat) records its traversal (searches β†’ reads β†’ writes) as a compact notation, persisted under <bundle>/.traces/. The graph view lists recent runs; selecting one replays the path as numbered directed hops over the graph β€” visited concepts ringed, search hits dotted, everything else faded.

  • CLI β€” pnpm agent:query "..." / pnpm agent:mutate "..." smoke entries.

  • Profiles β€” optionally host several isolated memories on one server, each selected by its own API key. See Profiles.

Design rule: conformance is enforced in code, not prompts. The deterministic bundle layer validates frontmatter (type required), regenerates index.md files, appends log.md entries (newest-first, spec Β§7), and sandboxes all paths to the bundle root. The LLM decides what to change; the code guarantees the result is a conformant bundle.

Quick start (Docker)

No clone needed β€” the image is public. Save this as docker-compose.yml:

services:
  understory:
    image: ghcr.io/thecodacus/understory:latest
    ports:
      - "3800:3800"
    # Lets the container reach a llama.cpp server running on the host via
    # http://host.docker.internal:8080/v1 (see "Local llama.cpp" below).
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      # Your memory lives here as plain markdown β€” a named volume, or point
      # a bind mount (e.g. ./my-memory:/bundle) at any OKF bundle.
      - understory-memory:/bundle
    environment:
      BUNDLE_ROOT: /bundle
      LLM_API_BASE_URL: ${LLM_API_BASE_URL}
      LLM_API_KEY: ${LLM_API_KEY}
      LLM_API_FORMAT: openai
      LLM_MODEL: ${LLM_MODEL:-}
      # Optional fallback
      LLM_FALLBACK_API_BASE_URL: ${LLM_FALLBACK_API_BASE_URL:-}
      LLM_FALLBACK_API_KEY: ${LLM_FALLBACK_API_KEY:-}
      LLM_FALLBACK_API_FORMAT: ${LLM_FALLBACK_API_FORMAT:-openai}
      LLM_FALLBACK_MODEL: ${LLM_FALLBACK_MODEL:-}
    restart: unless-stopped

volumes:
  understory-memory:
docker compose up -d
Choosing a provider

The generic provider system supports any OpenAI-compatible or Anthropic-compatible API. Set LLM_API_BASE_URL + LLM_API_KEY + LLM_MODEL and leave LLM_PROVIDER unset.

DeepSeek:

LLM_API_BASE_URL=https://api.deepseek.com/v1 LLM_API_KEY=sk-... LLM_MODEL=deepseek-chat

OpenAI:

LLM_API_BASE_URL=https://api.openai.com/v1 LLM_API_KEY=sk-... LLM_MODEL=gpt-4o

Anthropic (Claude):

LLM_API_BASE_URL=https://api.anthropic.com/v1 LLM_API_KEY=sk-ant-... LLM_API_FORMAT=anthropic LLM_MODEL=claude-sonnet-5

Groq:

LLM_API_BASE_URL=https://api.groq.com/openai/v1 LLM_API_KEY=gsk_... LLM_MODEL=llama-3.3-70b-versatile

Local llama.cpp:

LLM_API_BASE_URL=http://host.docker.internal:8080/v1 LLM_MODEL=

When understory runs in Docker, localhost is the container itself, not the host β€” so a llama-server on the host is reached at host.docker.internal (the compose files above already map it via extra_hosts). Running from source on the same box as llama-server, use http://localhost:8080/v1.

Local llama.cpp with DeepSeek fallback:

LLM_API_BASE_URL=http://host.docker.internal:8080/v1 LLM_MODEL= \
LLM_FALLBACK_API_BASE_URL=https://api.deepseek.com/v1 LLM_FALLBACK_API_KEY=sk-... LLM_FALLBACK_MODEL=deepseek-chat

The old LLM_PROVIDER + per-provider key env vars still work (backward-compatible) but are deprecated.

Then:

  • Web UI β†’ http://localhost:3800 β€” browse the memory, watch the graph, chat with the agent

  • MCP endpoint β†’ http://localhost:3800/mcp (streamable HTTP) β€” register it in any MCP client:

    claude mcp add --transport http ustory http://localhost:3800/mcp
  • Your agent now has memory_query / memory_add / memory_update / memory_status / memory_maintain, and gets a seed overview of the memory at every session start.

Teach it something (memory_add: "We deploy on Fridays, never Mondays"), then open the graph and watch the concept wire itself in. Deploying with Portainer? Use docker-compose.portainer.yml as a repository stack.

Stack

pnpm monorepo:

PackageWhat
packages/coreOKF bundle layer (zero LLM) + agent (Vercel AI SDK tool loop: search/read/list/write/patch/delete) + provider registry
packages/serverExpress: MCP streamable-HTTP at /mcp, stdio bin, REST browse API at /api/*, streaming chat at /api/chat, serves the web build
packages/webVite + React + TS + Tailwind: bundle browser + agent chat (useChat)

Providers are configured through LLM_API_BASE_URL, LLM_API_KEY, LLM_API_FORMAT (openai or anthropic), and LLM_MODEL. Any OpenAI-compatible endpoint (DeepSeek, OpenAI, Groq, OpenRouter, llama.cpp, etc.) works with LLM_API_FORMAT=openai; Anthropic-compatible endpoints use LLM_API_FORMAT=anthropic. Optional fallback uses the matching LLM_FALLBACK_* variables.

llama.cpp
# on the inference box β€” --jinja enables OpenAI-style tool calling
llama-server -m model.gguf --jinja --host 0.0.0.0 --port 8080

# here β€” no model id needed, it's discovered for llama-server-like local endpoints
LLM_API_BASE_URL=http://inference-box:8080/v1 LLM_API_FORMAT=openai LLM_MODEL= \
BUNDLE_ROOT=./sample-bundle node packages/server/dist/index.js

Works behind llama-swap too: discovery prefers the currently loaded model so a query doesn't trigger a multi-minute model swap. Pin a specific model with LLM_MODEL=.

From source

pnpm install
pnpm build
cp .env.example .env   # add your API key

BUNDLE_ROOT=./sample-bundle \
LLM_API_BASE_URL=https://api.deepseek.com/v1 \
LLM_API_KEY=sk-... \
LLM_API_FORMAT=openai \
LLM_MODEL=deepseek-chat \
node packages/server/dist/index.js
# β†’ http://localhost:3800  (web UI + /api + /mcp)

Or build the container yourself: docker compose up --build (the repo's docker-compose.yml builds from source and mounts ./sample-bundle).

Dev mode (server on :3800, Vite HMR on :5180 with proxy):

BUNDLE_ROOT=./sample-bundle pnpm --filter @understory/server dev
pnpm --filter @understory/web dev

MCP registration (Claude Code / Desktop)

claude mcp add ustory \
  -e BUNDLE_ROOT=/path/to/your/bundle \
  -e LLM_API_BASE_URL=https://api.deepseek.com/v1 \
  -e LLM_API_KEY=sk-... \
  -e LLM_API_FORMAT=openai \
  -e LLM_MODEL=deepseek-chat \
  -- node /path/to/understory/packages/server/dist/mcp/stdio.js

Or point an HTTP MCP client at http://host:3800/mcp.

Auth

By default the server is open β€” fine on localhost or a trusted LAN. Before exposing it anywhere else, set AUTH_TOKEN:

AUTH_TOKEN=$(openssl rand -hex 24)

With it set, /mcp and /api require Authorization: Bearer <token> (the web UI stays reachable and prompts for the token). Register authenticated MCP clients with a header:

claude mcp add --transport http ustory http://host:3800/mcp \
  --header "Authorization: Bearer <token>"

The stdio transport needs no token β€” it's a local process spawned by the client.

Profiles: several isolated memories on one server

One server can host a separate memory per profile, for example work, health and a side project. Each profile has its own bundle on disk and its own API key, and the key is the only thing that selects a memory. A request made with the work key is served from the work bundle and cannot name, read or search any other profile. The URLs stay the same for everyone.

Turn it on by pointing PROFILES_ROOT at a directory (it takes precedence over BUNDLE_ROOT):

services:
  understory:
    # ...as in the quick start, plus:
    volumes:
      - understory-profiles:/profiles
    environment:
      PROFILES_ROOT: /profiles
      ADMIN_TOKEN: ${ADMIN_TOKEN:-}   # optional, enables the /admin API

volumes:
  understory-profiles:

Manage profiles with the bundled CLI. It works against a running server, which picks up changes on the next request:

docker compose exec understory node server/dist/profiles-cli.js create work
# profile: work
# api key: usk_...        <- shown once; only a hash is stored

docker compose exec understory node server/dist/profiles-cli.js list
docker compose exec understory node server/dist/profiles-cli.js rotate work          # old key stops working
docker compose exec understory node server/dist/profiles-cli.js remove work          # revokes the key, keeps the memory
docker compose exec understory node server/dist/profiles-cli.js remove work --purge  # also deletes the memory

From a source checkout the same commands are PROFILES_ROOT=... pnpm --filter @understory/server profiles <command>.

Give each agent its profile's key:

claude mcp add --transport http work-memory http://host:3800/mcp \
  --header "Authorization: Bearer usk_..."

The web UI asks for a key and opens that profile's memory. The sidebar shows which profile you are in, with a switch button to enter a different key.

Things worth knowing:

  • In profile mode every request needs a profile key. AUTH_TOKEN is not used.

  • With ADMIN_TOKEN set, GET/POST /admin/profiles, POST /admin/profiles/<name>/rotate and DELETE /admin/profiles/<name>[?purge=true] do what the CLI does. The admin token manages profiles but cannot open any memory, and a profile key cannot reach /admin.

  • Layout is PROFILES_ROOT/<name>/ per bundle plus PROFILES_ROOT/profiles.json for the registry. To move an existing bundle into a profile, put it at PROFILES_ROOT/<name>/ and run create <name>, which adopts the directory.

  • The query cache, hot memory, traces, git history and dreaming are all per profile. Dreams run one profile after another.

  • The stdio transport serves one bundle. Point its BUNDLE_ROOT at a profile's directory to use that memory locally.

Serving under a sub-path

The web UI uses relative URLs throughout, so it works behind a path-prefixing reverse proxy β€” no configuration needed. Any proxy that strips the prefix before forwarding works:

# Tailscale
tailscale serve --bg --set-path=/understory http://localhost:3800
# Caddy
handle_path /understory/* {
  reverse_proxy localhost:3800
}

One rule: open the UI with a trailing slash (https://host/understory/, not .../understory) β€” relative URLs resolve against the last path segment, so without the slash they escape the prefix. If your proxy can redirect /understory β†’ /understory/, do that.

Seed memory

A client LLM that only sees four bare tool names never gets the instinct to check memory. So at session start the server injects a compact overview of what the knowledge base contains (directories, concepts with types + descriptions, recent activity) through both channels that reach the model:

  1. the MCP initialize instructions field (clients like Claude put it in the system prompt), and

  2. the memory_query tool description β€” the universal fallback every tool-calling client loads.

The seed regenerates fresh for every new session. After memory_add / memory_update in a long-lived (stdio) session, the tool description refreshes via tools/list_changed, so the session sees its own writes. Out-of-band edits (hand edits, other clients) are picked up on the next session.

Graph health & maintenance

Memory is a graph, not a pile of notes, and graphs rot: concepts go orphaned (nothing links to them) and links go broken. Two mechanisms keep it healthy:

  • Write-time linking β€” new knowledge either enriches the concept it belongs to (an attribute of an existing entity is patched in, not filed separately) or, when it's a distinct entity, is created and back-linked from related concepts. Contradictions are superseded in place, never left standing alongside the old value.

  • memory_maintain β€” a deterministic lint (orphans + broken links, surfaced in memory_status under graph) drives an internal agent to wire orphans into related concepts and fix dangling links. Run it periodically to counter drift; it's a no-op when the graph is already healthy.

This design mirrors the pattern in Karpathy's LLM Wiki (index.md + log.md, create-vs-enrich, lint for orphans). Deferred from that pattern until scale warrants: an explicit page-type schema, and hybrid FTS5+embedding search (the naive scan in search.ts is fine into the low thousands of concepts).

Tests

pnpm test                                  # core: 18 tests (spec Β§5/Β§6/Β§7/Β§9, sandbox, search, concurrency)
pnpm --filter @understory/server exec tsx scripts/mcp-smoke.mts   # MCP stdio round-trip (needs SMOKE_BUNDLE + an API key)

Environment

See .env.example. BUNDLE_ROOT is required; GIT_AUTOCOMMIT=true commits every mutation.

LICENSE

Shown as plain text.

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright 2026 Anirban Kar

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
101 files Β· 98 not served here

Advantages

  • The memory is stored as plain markdown files, making it human-readable, portable, and easily diffable in git. evidence: README.md
  • Deterministic maintenance tools automatically resolve graph rot like orphaned concepts and broken links. evidence: README.md
  • Supports isolated memory profiles, allowing one server to manage multiple distinct knowledge bases securely. evidence: README.md

Limitations

  • The current search implementation is a naive scan, which may become inefficient as the number of concepts grows into the thousands. evidence: README.md
  • Requires an external LLM provider to perform reasoning and tool-calling tasks. evidence: README.md

Security

Risk level: No risk found

This brain runs

This brain runs nothing: AutoGineer found no hooks, scripts, plugin code or MCP servers in its files.

Attribution and licence

First committed by
GitHub avatar of thecodacusthecodacus
Publisher
Anirban Kar (Community)
Source
thecodacus/understory Β· commit 7625aa4
Licence
Apache License 2.0 (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
thecodacus, michaelherold, Lathly, Piggidragon, TheAmericanMaker

AutoGineer is not affiliated with or endorsed by thecodacus.

Install from source

98 of its files are not served here, so there is no ZIP. thecodacus/understory at 7625aa4