AutoGineer
Generated banner for PMB
Generated logo for PMB

PMB

Memory server

First committed by oleksiijko

Published in oleksiijko/pmb. Publisher page

285 GitHub stars

What it is

Local-first persistent memory for AI coding agents (Claude Code, Cursor, Codex) over MCP. Decisions, lessons and facts live in one SQLite file on your disk. Offline, multilingual.
— the description by oleksiijko

AutoGineer overview, from the brain’s own files

PMB provides persistent memory for MCP-aware AI coding agents like Claude Code, Cursor, and Codex. By using a local SQLite database as the source of truth, it captures decisions, lessons, and project facts, allowing agents to retain context across sessions without relying on cloud storage or external API keys. The system uses a hybrid approach combining lexical search, vector embeddings, and entity graphs to surface relevant information to the agent. It includes tools for indexing project structures, tracking commit intent, and managing memory through a dashboard, ensuring that agents can access historical context automatically.

How it works

Memory model: Hybrid

AutoGineer overview, from the brain’s own files

PMB operates as an MCP server that connects to your AI agent. It uses a hybrid memory model where durable events are stored in a local SQLite database, while search indexes are maintained in LanceDB. When an agent interacts with the system, PMB uses a combination of BM25 lexical search, vector embeddings, and entity graph analysis to retrieve relevant information. The system includes hooks that automatically observe agent activity and inject context into the agent's workflow, while also allowing for manual indexing of files, PDFs, and project data.

Folders
FolderRoleFiles
.claudeagent-config1
.githubagent-config10
docsdocs41
scriptsscripts47
srcsource-code173
teststests199
dockerfolder4
mintlifyfolder34
npmfolder5

Requirements

Runtimes: Python >=3.11

Databases: LanceDB, SQLite

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Google Antigravity, Kiro, OpenCode, Amp, Roo Code, Cline, JetBrains Junie, Devin (ex-Windsurf)

Set it up

  1. This brain runs code automatically: 1 script. Review Makefile before opening the folder in Claude Code. No step below turns a hook on for you.

    • Makefile: pip install -e .
  2. Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/oleksiijko/pmb/blob/d0e2f2e287acb10e7c7fb794941a76533ade52d6/README.md#install
  3. Not scanned by AutoGineerAutoGineer could not scan everything it runs. https://pypi.org/project/pmb-ai/

  4. First committed by oleksiijko. Published in oleksiijko/pmb. Licence: Apache License 2.0.

Usage

AutoGineer overview, from the brain’s own files

  • Install the PMB package via pip or npm.
  • Run the setup command to configure your agent and wire the MCP connection.
  • Use the CLI to index project files, track changes, or import existing data.
  • Interact with your AI agent as usual, allowing PMB to automatically inject relevant memory and record new events.
“pmb recall "auth decision"”
The system searches the local SQLite memory and returns stored information regarding past authentication decisions.
“pmb index project .”
The system scans the current directory to index the project structure and symbols into the memory store.

Documentation by oleksiijko

<!-- mcp-name: io.github.oleksiijko/pmb-ai -->

<div align="center">

<img src="https://raw.githubusercontent.com/oleksiijko/pmb/main/docs/assets/logo.png" width="100" alt="PMB logo">

PMB

Local-first memory for your AI coding agent.
SQLite is the source of truth. No cloud, no API keys, no re-explaining.

Image: Website Image: PyPI Image: CI Image: Docs Image: Python Image: License Image: MCP Image: GitHub MCP Registry

<img src="https://raw.githubusercontent.com/oleksiijko/pmb/main/docs/assets/dashboard-map.png" width="760" alt="PMB dashboard - your project's memory as a live entity graph">

Local-first memory, visualized. 3,800+ entities and 41,000+ connections, captured automatically as you work.

Website · Docs · Quickstart · Demo · Why PMB · How it works · FAQ

Your AI agent forgets everything between sessions. So you re-explain the same decisions, lessons and constraints over and over. PMB remembers them in one local workspace and feeds them back through MCP - no cloud, no API keys, no LLM call on the read path. And it tells you when memory is actually helping, instead of claiming "+X%".

⭐ Star the repo if PMB saves you a re-explanation.

</div>

PMB gives Claude Code, Cursor, Codex and the other MCP-aware agents a real memory: decisions you made last week, lessons you taught them, personal facts, project structure, PDFs. They survive every restart, every model upgrade, every agent switch - because they live in a local workspace you own, with SQLite as the durable source of truth and rebuildable search indexes beside it.

No API keys. No subscription. No LLM call on the read path. Just local files.

Quickstart

pip install pmb-ai                 # 1. install
pmb setup                          # 2. detect your agent + wire the MCP entry
pmb warmup                         # 3. preload the model (first recall is instant)
# 4. restart your agent, then just talk to it - memory is automatic
pmb stats                          # 5. see what's stored
pmb recall "auth decision"         # 6. search memory from the terminal
pmb doctor                         # 7. confirm everything is wired

That's it - your agent now remembers. No account, no keys, nothing leaves your machine.

Command name: the CLI is pmb. Via pip you also get the alias pmb-ai; via npm (npx pmb-ai setup) the command is pmb-ai and it installs the Python package first, then runs setup. Same tool - use whichever your install gave you.

Links: pmbai.dev (site) · docs.pmbai.dev (docs) · Getting started · Deleting memories.

Demo

What it feels like - same prompt, with and without memory:

<div align="center">

<a href="https://github.com/oleksiijko/pmb/raw/main/docs/assets/pmb-setup.mp4"><img src="https://raw.githubusercontent.com/oleksiijko/pmb/main/docs/assets/pmb-setup-poster.png" width="820" alt="Watch the 2-minute PMB setup"></a>

<sub>▶ Click to play the 2-minute setup</sub>

<img src="https://raw.githubusercontent.com/oleksiijko/pmb/main/docs/assets/before-after.svg" width="880" alt="Same prompt, with and without memory: without PMB the agent asks which file and what the bug was; with PMB it recalls verdict-policy.ts:142 in 6 ms.">

</div>

You:    fix that LoadGuard pricing bug we hit last Tuesday

Agent:  prepare(message="fix LoadGuard pricing bug")
        ↓ (6 ms)
        → project_context: 12 events about LoadGuard,
          4 lessons (incl. "never lower NEGOTIATE/SKIP under 25%"),
          3 decisions, 2 open goals
        → active_arcs: "LoadGuard verdict-policy refactor (started Tue)"
        → lessons: 1 directly matches "pricing"
        → recent_activity: 8 commits this week

        Looking at src/engine/verdict-policy.ts (you opened it Tuesday
        14:32, last changed Wednesday). The pricing bug is on line 142
        where the bundle fallback tightened below the rate-floor. Per the
        lesson you saved, we never drop the threshold under 25% - restoring
        the guard there.

The agent didn't ask. It didn't guess. It read its memory in 6 ms and showed up already informed.

Why PMB

  • Local-first, zero-config. SQLite holds the durable memory; rebuildable search indexes stay local. No account, API keys, telemetry, or cloud to trust.

  • It actually gets used. On Claude Code / Codex, hooks inject the right memory before the model thinks - you never have to remember to call a tool.

  • Multilingual, no setup. The embedder covers 50+ languages; a Russian query finds an English fact. No per-language config.

  • MCP-native. One pmb connect wires Claude Code, Cursor, Codex, Windsurf, Zed, VS Code, and more.

  • Fast read path. Recall in ~35 ms warm; writes return in under a millisecond - no LLM call to remember.

  • Honest impact. The dashboard shows which lessons actually changed outcomes, instead of claiming "+X%".

  • Your data, in the open. pmb export dumps everything to Markdown/JSON. Apache 2.0.

See your memory

pmb dashboard opens a local, liquid-glass web UI on http://127.0.0.1:8765 over everything PMB captured - written automatically, just by working. It binds to 127.0.0.1 only, so nothing leaves your machine.

<div align="center">

<img src="https://raw.githubusercontent.com/oleksiijko/pmb/main/docs/assets/dashboard-map.png" width="820" alt="PMB dashboard - Map (entity graph)">

Map - every entity and connection in your project, as a live graph.

<img src="https://raw.githubusercontent.com/oleksiijko/pmb/main/docs/assets/dashboard-timeline.png" width="820" alt="PMB dashboard - Timeline (journal)">

Timeline - your memory as a journal, newest first.

</div>

Nine tabs: Map (entity graph, live), Timeline (git-graph by project), Overview, Entities, Arcs (narrative threads), Lessons (per-rule follow-rate, dead-lesson detection), Duplicates (inline merge), Performance (per-tool latency), Recall (debug ranker).

Verified local backups

pmb snapshot create --note "before maintenance"
pmb snapshot list
pmb snapshot verify <snapshot-id>
# Stop PMB servers, agent connections, and dashboards before restoring.
pmb snapshot restore <snapshot-id>

Snapshots use SQLite online backup to include committed WAL data and record file checksums. Restore checks the snapshot before changing memory and saves a verified copy of the previous state. Use pmb snapshot list --json in scripts. See backup and recovery for scope and limitations.

What you can store

# Personal facts that change (time-travel: old values archived, never lost)
record_keyed_fact("user", "city", "Warsaw")

# Project structure - symbols, imports, .gitignore-aware
pmb index project .

# Why each file exists + the intent behind every commit (Haiku-summarised, local)
pmb track modules                # one-line purpose per indexed file
pmb track changes                # new commits: what changed and WHY

# PDFs (research papers, manuals, contracts)
pmb index pdf paper.pdf
pmb index pdf ~/docs --recurse

# Whatever your agent logs as it works: decisions, lessons, completed tasks, goals

PMB is content-agnostic. If it's text the agent will care about later, PMB remembers and retrieves it.

What the agent gets back

A single MCP call - prepare(message) - returns the right things at the right level of detail, in 4-16 ms:

FieldWhat it is
project_contextFull project overview if the message mentions a project: key facts, lessons (RULES to follow), decisions, open goals, related entities, the project's narrative arc
lessonsProcedural rules matching the query, each with a surface_id so the agent can confirm it followed the rule later
recent_activityLast 24 h of decisions / edits / completions for session continuity
open_goalsIn-progress goals so the agent knows what you're pursuing
active_arcsNarrative arcs the project is currently living in

For everything else there's recall(query) (hybrid search, 35 ms warm) and 27 other tools in docs/reference/COMMANDS.md.

How it works

flowchart LR
    A[Your agent] -->|MCP stdio| B[PMB MCP server]
    B --> C[Engine]
    C -->|read 35 ms| R[Hybrid recall<br/>BM25 + vector + graph + rerank]
    C -->|write under 1 ms| W[Async embed queue<br/>SQLite first, vectors later]
    R --> D[(SQLite)]
    R --> E[(LanceDB)]
    W --> D
    W --> E
    style A fill:#dbeafe,color:#1e3a8a
    style B fill:#ede9fe,color:#5b21b6
    style C fill:#dcfce7,color:#14532d

  • Storage - every durable event lives in SQLite, the source of truth. Rebuildable vector indexes live in LanceDB beside it. The whole workspace stays on your disk and can be copied or exported anytime.

  • Recall - BM25 (lexical) + dense vector (semantic) + entity graph + optional cross-encoder rerank, fused via Reciprocal-Rank-Fusion.

  • Writes - async. The MCP tool returns in under a millisecond; the embed + LanceDB insert happen on a background thread.

  • Dedup - four layers: exact text match -> cosine >= 0.92 auto-merge -> cosine 0.80-0.92 borderline (LLM verify later) -> manual review in the dashboard. Old values are archived, never deleted; full history via keyed_fact_as_of(t).

  • Multilingual - no language packs. The default embedder (paraphrase-multilingual-MiniLM-L12-v2) covers 50+ languages, so где я живу finds a keyed-fact stored as user.city = Warsaw. Intent detection rides English semantic anchors that transfer cross-lingually, and the cold lexical path self-compiles from your own traffic. Recall stays strong across ~11 languages (top-3 ~= 0.9 on a 101-query eval; top-1 = 1.00 for en/fr/pt/ru). See docs/contributing/adding-a-language.md.

Install

The Quickstart above is all most people need. Other ways:

# From source
git clone https://github.com/oleksiijko/pmb.git && cd pmb
python -m venv .venv && source .venv/bin/activate
pip install -e .
pmb warmup                       # prime the ~450 MB embedder once

Wire one or more agents (all stdio - the server runs as a child of your agent; no network, no port, no token):

pmb connect claude-code   # also: codex · cursor · windsurf · gemini · vscode · zed · opencode · continue

Point several agents at one memory:

pmb connect claude-code --workspace personal
pmb connect cursor      --workspace personal   # both read/write the same workspace

Sharing one memory across machines or a team? That's an optional HTTP mode with bearer-token auth - see docs/guide/TEAM.md. Not needed for local use.

Running the tests? Use the venv's Python: .venv/bin/python -m pytest (or .venv\Scripts\python.exe -m pytest on Windows). Bare pytest outside the venv just reports missing numpy/fastmcp/typer.

CLI cheat sheet

# Memory
pmb stats                                   show counts and storage info
pmb recall "query"                          search with full debug
pmb dashboard                               web UI on port 8765 (graph, settings, errors)

# Ingest
pmb index pdf paper.pdf                     extract + chunk + embed
pmb index pdf ~/docs --recurse              entire directory
pmb index project .                         scan codebase
pmb track changes                           summarise commit intent (why)
pmb track modules                           one-line purpose per module
pmb import chatgpt ~/Downloads/export.json  bring existing history

# Continuity & efficiency (opt-in)
pmb resume save                             write .pmb/resume.md (commit it)
pmb resume install                          refresh resume.md at every turn end
pmb health lessons-impact                   which lessons actually help outcomes
pmb memory ledger                           Memory Delta handles this session

# Maintenance
pmb regraph                                 rebuild entity graph
pmb consolidate                             run sleep pass (optional)
pmb compact                                 archive old events
pmb dedupe                                  resolve borderline duplicates

# Hooks (force-feed PMB at the protocol level - no model cooperation)
pmb hooks install claude-code               wire all lifecycle hooks
pmb hooks list                              show what's installed
pmb hooks capabilities                      ambient mechanism each agent supports
pmb hooks uninstall claude-code             remove them
pmb auto-context "fix bug in PMB"           preview per-turn injection
pmb session-restore -m 180                  preview post-compaction restore
pmb lesson-followcheck --dry-run            preview follow-through scoring

# Ambient memory (the write side - memory journals the agent's work)
pmb autowrite --dry-run                     preview ambient auto-write for this turn
pmb ambient-watch .                         ambient auto-write for MCP-only hosts (git observer)
pmb forget-auto                             drop memory the ambient layer wrote itself

# Config
pmb config list                             default tier (25 keys you care about)
pmb config list --pro                       every key, including 80 advanced knobs
pmb config set recall.ppr_enabled true      toggle a feature
pmb connect --rules-only                    refresh CLAUDE.md only

Step-by-step per agent: docs/guide/usage.md. Full reference: docs/reference/COMMANDS.md.

Hooks - memory that doesn't wait to be asked

The hard part of agent memory isn't storing - it's getting the agent to use what's stored. Soft instructions in a rules file get skipped. So PMB wires hooks at the protocol level (pmb hooks install claude-code), each removing a dependency on the model remembering to act:

  • UserPromptSubmit -> auto-recall. Every message is classified (regex, multilingual, sub-ms) and the matching memory - lessons, past decisions, recall hits, project overview - is injected before the model thinks. Trivial messages inject nothing.

  • PostToolUse -> ambient observe. Every tool the agent runs is appended to a lightweight action journal (a single SQLite INSERT, no model). Reads and ls are filtered out; edits, tests and commits are kept.

  • SessionStart -> session-restore. After a context compaction the agent rebuilds "where you left off" from what the session recorded, instead of re-asking you.

  • Stop -> follow-through + ambient auto-write. (a) It checks which surfaced lessons actually showed up in what the agent did and marks them followed, deterministically. (b) If the agent did NOT call a record_* tool, it synthesizes one activity entry from the observed actions - so real work is captured even when the agent stays silent.

Preview any without an agent: pmb auto-context "...", pmb session-restore -m 180, pmb lesson-followcheck --dry-run, pmb autowrite --dry-run.

Ambient memory - the write side

Auto-recall fixed the read side; ambient memory does the same for the write side - the memory journals the agent's work even when it forgets record_batch:

  • Coordinated. If the agent already called a record_* tool this turn, ambient stays silent; it only fills the gap.

  • Outcome-scored, not churn. A turn is journaled only if results clear a quality bar (tests passed, a failure fixed, a deploy ran), not by file count alone.

  • Honest + reversible. Every ambient entry is tagged source=autowrite, shown as auto in the dashboard, and removable with pmb forget-auto. On by default; disable with pmb config set autowrite.enabled false.

  • Works on every host. Claude Code (hooks), Codex (pmb codex-notify), MCP-only hosts like Cursor/Zed/VS Code (git observer, pmb ambient-watch .). Check yours with pmb hooks capabilities.

Synthesis is template-based by default (instant, no model). Opt into a local/API/CLI model summary with pmb config set autowrite.synthesizer llm:ollama or llm:openai (it has a timeout and falls back to the template).

Self-improvement loop

Every surfaced lesson carries a surface_id. Follow-through is recorded both ways: the agent confirms via mark_lesson_followed(surface_id, True), and the Stop hook infers it from recorded activity. The Lessons tab then shows, per rule: how often it was shown, how often it was followed, ★ USEFUL (followed >= 2x), ? UNVERIFIED (surfaced but unconfirmed), and 💀 DEAD only when a rule is repeatedly ignored (>= 2). You see which rules help and prune the ones that don't.

Settings - 25 you care about, 80 you don't

PMB has 105 tunables. The 25 that affect day-to-day quality are default-tier (pmb config list). The rest are internal weights and experimental flags, hidden behind --pro so the surface stays scannable. Every pro key still reads with pmb config get and writes with pmb config set - hidden from list, not gated.

KeyDefaultWhat it does
recall.top_k5How many results recall returns
recall.bm25_weight0.7BM25 vs vector mix (1.0 = pure BM25)
recall.ppr_enabledtrueMulti-hop graph diffusion, gated by intent
recall.keyed_fact_boost0.35How hard personal-attr facts win on personal queries
recall.rerankfalseAlways-on cross-encoder (regresses LoCoMo, keep off)
embedding.modelparaphrase-multilingual-MiniLM-L12-v2The vector model
graph.extractorregexregex / spacy / llm:claude / llm:openai / llm:ollama / llm:codex
mcp.record_batch_asynctrueFire-and-forget writes (sub-ms return)
agent.apply_lessonstrueAgent surfaces lessons before acting
dedup.enabletrueAll four dedup layers
decay.factor_per_day0.985Importance half-life
chat.modelhaikuDefault model for pmb-chat

Numbers

Recall p50 / p95 warm35 ms / 110 ms
prepare(message) warm4-16 ms
record_batch_async< 1 ms
MCP cold boot3.7 s
LoCoMo recall@10 (n=10)94.5 %
Multilingual mega-stress top-10 (900 q)99.2 %
# Reproduce locally
python scripts/benchmarks/benchmark_locomo.py --n-conversations 10
python scripts/benchmarks/mega_stress_test.py

<a name="privacy"></a>Privacy

  • 100 % offline by default. No network calls from the engine, zero telemetry - there is no PMB server to call home to.

  • Workspace = a directory under ~/.pmb/<name>/. Copy it to Dropbox, push it to git, share it on a USB drive. Your call.

  • Secrets are auto-redacted at write time (OpenAI / Anthropic / AWS / Stripe / GitHub keys; configurable).

  • Apache 2.0 licensed. Forks welcome.

FAQ

Does PMB call an LLM? On read: never. On write: never by default. Optional: pmb consolidate can run a local Ollama, Claude CLI, Anthropic, or OpenAI pass to write short reflections - opt-in.

What about cost? $0. There is no PMB service.

Does the agent need to know about PMB? After pmb connect, the rules are appended to CLAUDE.md / AGENTS.md automatically. The default profile exposes 10 core MCP tools (including the prepare() read-first pattern); wider profiles exist for ingestion and admin.

Will it slow my agent down? Tools return in single-digit milliseconds for everything except recall (35-110 ms warm), which is below human perception.

Can two agents share one memory? Yes - point them at the same workspace. SQLite WAL + a 10 s busy-timeout handle concurrent writes.

Wipe a fact? pmb forget <ulid> archives it (excluded from recall, restorable). Hard-delete: pmb delete <ulid> --hard.

Windows? Yes - tested on Windows 11, macOS 14, Ubuntu 22.04. Cyrillic paths and console encoding are handled.

PDFs / code / Markdown? pmb index pdf paper.pdf, pmb index project ., pmb import markdown ~/notes/, pmb import chatgpt path.json.

Cold start is slow. First recall loads the embedding model (~3 s). Run pmb warmup once, or let the prewarm thread handle it in the background.

Roadmap? See docs/ROADMAP.md: litestream backup, optional cloud-sync (BYO bucket), tree-sitter project indexing, image OCR.

Contributing

Issues and PRs welcome. There's one full-time maintainer; please open a discussion before a large change so we can align on direction.

git clone https://github.com/oleksiijko/pmb.git && cd pmb
python -m venv .venv && source .venv/bin/activate
pip install -c requirements-dev.lock -e ".[dev,crypto]"
python scripts/prewarm_models.py
pytest                  # full suite, ~4 minutes
pytest -k recall        # fast subset, ~12 s
Dev commands
bash scripts/test.sh                 # whole suite (CI-equivalent)
bash scripts/test.sh tests/recall    # a subset (any pytest args pass through)
bash scripts/codeql_local.sh         # run CI's CodeQL security-extended locally
bash scripts/install-dev-hooks.sh    # pre-commit hook: ruff + CodeQL before each commit

scripts/codeql_local.sh auto-installs the CodeQL bundle on first run and runs the exact suite CI uses, so security findings are caught locally instead of on a push. The pre-commit hook bypasses with git commit --no-verify (or skip just the scan with SKIP_CODEQL=1).

License: Apache 2.0.

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 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 PMB contributors

   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.
512 files · 496 not served here

Advantages

  • Operates entirely locally with no cloud accounts, API keys, or telemetry required. evidence: README.md
  • Supports multiple AI coding agents through a unified MCP-native interface. evidence: README.md

Limitations

Security

Risk level: Low risk

This brain runs

Install scripts (1)

  • Makefile (make install): pip install -e .
  • Low risk: network-instructions (Makefile:5)
  • Low risk: scripts-present (scripts/_bench_data.py)
  • Low risk: scripts-present (scripts/benchmarks/bench_qa_scenarios.py)
  • Low risk: scripts-present (scripts/benchmarks/benchmark_locomo.py)

Attribution and licence

First committed by
GitHub avatar of oleksiijkooleksiijko
Declared authors
  • PMB contributors (declared in pyproject.toml)
  • PMB contributors (declared in CITATION.cff)
Publisher
Oleksii Bondar (Community)
Source
oleksiijko/pmb · commit d0e2f2e
Licence
Apache License 2.0 (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
oleksiijko, dmitrii-starikov, VIVAAN-DHAWAN, jbendotnet, motojojoe

AutoGineer is not affiliated with or endorsed by oleksiijko.

Install from source

496 of its files are not served here, so there is no ZIP. oleksiijko/pmb at d0e2f2e