Skip to content
Back to search

lobu

Open-source control plane and runtime for organisational agents: shared company context & brain

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/lobu-ai/lobu with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/lobu-ai/lobu'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lobu-ai--lobu/badge.svg)](/listings/lobu-ai--lobu)

HTML

<a href="/listings/lobu-ai--lobu"><img src="/api/listings/lobu-ai--lobu/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "lobu",
  3. "owner": {
  4. "name": "Lobu"
  5. },
  6. "plugins": [
  7. {
  8. "name": "lobu",
  9. "source": "./claude-plugin",
  10. "description": "Shared, permission-aware company context and governed actions for Claude and other AI agents.",
  11. "category": "development",
  12. "tags": ["agents", "mcp", "company-context", "memory", "permissions"]
  13. }
  14. ],
  15. "description": "Official Lobu plugins for giving Claude shared company context and governed access to company systems."
  16. }
README.md · README · 308 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Lobu — Give every agent a live model of your world
  2. **Lobu is an open-source, event-sourced context layer for AI agents.** Every tool call, data
  3. change, device signal, API event, and conversation becomes an event, linked to the entities and
  4. identities it belongs to — a person, a project, a customer, a home, a company. That gives agents
  5. a live, queryable model of your world instead of a transcript they forget when the session ends.
  6. ChatGPT, Claude, Codex, and your own agents read and write that same permission-aware history and
  7. current context, whether you're wiring up your own accounts or an entire company's stack. When a
  8. responsibility should outlive one chat, any agent can discover and hand it to a persistent Lobu
  9. specialist over MCP.
  10. Connect your tools once. Every agent resumes from the same live context.
  11. ```text
  12. WITHOUT LOBU WITH LOBU
  13. Agent A -> Slack / GitHub / CRM Slack GitHub CRM DBs Devices
  14. Agent B -> Slack / GitHub / CRM \ | | | /
  15. Agent C -> Slack / GitHub / CRM +-----+-----+----+----+
  16. |
  17. Each agent re-fetches. v
  18. Each session forgets. +-------------------+
  19. | LOBU |
  20. | events + entities |
  21. | history + policy |
  22. +---------+---------+
  23. |
  24. shared context
  25. +-----------------+-----------------+
  26. | | |
  27. ChatGPT Claude / Codex Your agents
  28. ```
  29. ## See it in ChatGPT
  30. The 86-second muted demo shows ChatGPT using Lobu over MCP to pull connected context and call
  31. governed tools without leaving the conversation. The same shared context remains available to
  32. Claude, Codex, and custom agents.
  33. https://github.com/user-attachments/assets/26e6329a-1bc6-4480-8e57-e9388e38dde9
  34. ## Start with the agent you already use
  35. Point any MCP client at Lobu. No Lobu agent runtime or `lobu.config.ts` is required.
  36. ```bash
  37. # Claude Code
  38. npx @lobu/cli@latest connect claude-code
  39. # Codex
  40. npx @lobu/cli@latest connect codex
  41. # OpenCode
  42. npx @lobu/cli@latest connect opencode
  43. ```
  44. Complete OAuth when prompted, connect the sources you want to share, and ask your agent to use
  45. Lobu when it needs shared context.
  46. The same MCP endpoint works with **Claude Code, Codex, OpenCode, Antigravity, ChatGPT, Claude Desktop, Cursor**, and custom MCP clients. Run `lobu connect` to detect a client, install the supported MCP and skill bundle, or get the exact native handoff when the host requires UI setup. Authentication happens in that agent on first use.
  47. Setup guides: [Claude](https://lobu.ai/connect-from/claude-code/) · [ChatGPT](https://lobu.ai/connect-from/chatgpt/) · [Codex](https://lobu.ai/connect-from/codex/) · [Grok](https://lobu.ai/connect-from/grok/)
  48. Download Lobu: [Mac app](https://github.com/lobu-ai/lobu/releases/latest/download/Lobu.dmg) · [Chrome extension](https://chromewebstore.google.com/detail/jhgcecbdpnoehfnhpdfihlchjddapepi)
  49. > Upgrading a Mac install made before the `ai.lobu.mac` app identity? Install the
  50. > DMG by hand — the in-app updater does not carry an install across the bundle
  51. > identifier change. It replaces `/Applications/Lobu.app` in place; also delete
  52. > `/Applications/Owletto.app` if a pre-rename build is still there, since that one
  53. > sits at its own path. From 20.0.1 your settings and the app's device identity
  54. > carry across the rename, so device-pinned Automations keep running against the
  55. > same worker. Login Items and privacy grants cannot come with them — macOS keys
  56. > both to the bundle identifier — so the new app asks about Open at Login once and
  57. > re-prompts for each permission on first use.
  58. To test changes merged to `main`, run `bunx @lobu/cli@canary --help`. The
  59. `canary` tag moves only when a maintainer runs **Publish Packages** from `main`
  60. in GitHub Actions with channel `canary`; that run requires the commit's CI and
  61. image checks and smokes the packed CLI before publishing. The published version
  62. is then exercised across the Linux runtime matrix, so check the run's result before
  63. depending on it. Use `@latest` for stable releases. Canary versions include the
  64. full commit SHA so you can pin a preview when reproducing a bug. Package managers
  65. can cache the moving tag: copy the exact version from the successful workflow run,
  66. use it in place of `canary`, and confirm the installed version with `lobu --version`.
  67. ### Recall what the company knows
  68. Ask from Claude Code, Codex, or ChatGPT:
  69. > What did we decide about enterprise onboarding, and what changed since the last release?
  70. Lobu searches shared, durable organizational memory under the caller's permissions, regardless of which agent asks. The answer can combine connected discussions, project activity, customer records, saved decisions, and typed company entities without rebuilding that context from scratch in every chat.
  71. ### Hand work to a persistent Lobu specialist
  72. Ask your primary agent:
  73. > Ask our customer-researcher specialist to review the latest feedback and propose the next three interviews.
  74. The agent discovers the specialists available to you, selects the right one, delegates the task, and brings the result back. The specialist has its own identity, instructions, tools, durable conversations, and access policy.
  75. To the user this stays one conversation in their primary agent. The specialist itself persists: it remains available to other authorized people and agents instead of disappearing with the current chat.
  76. ## Why Lobu
  77. Instead of every agent rebuilding the same state through per-session tool calls, Lobu runs a shared data layer:
  78. - **Connect once.** Polls, webhooks, APIs, and agent-written connectors feed one append-only event log.
  79. - **Know once.** Events can be indexed as searchable knowledge and linked to typed entities such as companies, projects, incidents, and customers.
  80. - **Use from any agent.** Authorized MCP clients read and contribute to the same organizational state according to their grants.
  81. - **Delegate when useful.** Persistent Lobu specialists can own a role, conversation history, tools, and recurring responsibilities.
  82. - **Keep control.** Identity, source permissions, approvals, credential brokering, provenance, and audit stay server-side.
  83. ```mermaid
  84. flowchart TD
  85. Sources["Connectors / webhooks / devices / APIs"] --> Log[("append-only log")]
  86. Log -->|"resolve identities<br/>attach provenance"| Graph["context graph<br/>entities + links<br/>current + history"]
  87. Graph -->|"query"| Agents["agents + specialists"]
  88. Graph -->|"watch / subscribe"| Agents
  89. Agents -->|"sandbox + scoped tools / MCP<br/>policy + approvals"| Actions["actions on systems"]
  90. Actions -->|"action events"| Log
  91. ```
  92. **MCP is for doing. Lobu's event graph is for knowing.**
  93. ## One context layer, personal or company
  94. The primitives don't change between a single person's accounts and an entire company's stack —
  95. only what's connected does. Identities, entities, events, history, and policy work the same way
  96. at either scope.
  97. ```text
  98. PERSONAL COMPANY
  99. WhatsApp Gmail Calendar Mac Slack GitHub CRM DB
  100. \ | | / \ | | /
  101. +------+-------+-----+ +------+-----+---+
  102. \ /
  103. +------- LOBU -------+
  104. | identities |
  105. | entities + events |
  106. | history + policy |
  107. +---------+----------+
  108. |
  109. shared agent context
  110. +------------+------------+
  111. | |
  112. "When is Alice home?" "Why is Acme at risk?"
  113. ```
  114. ## Three ways to use Lobu
  115. ### 1. Add shared context to existing agents
  116. Agents can search and save memory, query structured entities, inspect connected sources, and delegate to Lobu specialists without moving to a new chat interface or adopting Lobu's runtime.
  117. Docs: [Memory](https://lobu.ai/getting-started/memory/) · [Claude](https://lobu.ai/connect-from/claude-code/) · [ChatGPT](https://lobu.ai/connect-from/chatgpt/) · [Codex](https://lobu.ai/connect-from/codex/)
  118. ### 2. Run persistent Lobu specialists
  119. Create a specialist for a durable responsibility: customer research, support triage, release coordination, incident follow-up, or an internal domain. People can talk to it from the Lobu web app or Slack, while other agents can call the same specialist over MCP.
  120. Scaffold and run one locally:
  121. ```bash
  122. npx @lobu/cli@latest init my-specialist
  123. cd my-specialist
  124. npx @lobu/cli@latest run
  125. npx @lobu/cli@latest chat -c local "hello"
  126. ```
  127. `lobu run` starts the local stack with an embedded Postgres database by default and opens the web UI on `:8787`. It applies the project's `lobu.config.ts` automatically only in embedded mode. To use external Postgres, set `DATABASE_URL`, ensure pgvector is available, then authenticate and apply the project to that runtime separately.
  128. The current canary CLI downloads the required runtime components on first use and caches them for later runs. `--help`, `--version`, and commands that only connect to a remote runtime do not install the local stack. Docker images include their runtime dependencies at build time and start directly; local embedding model weights can still download on first use. See [Docker deployment](docs/DOCKER.md) for the separate database and service configuration.
  129. `lobu init`, including `init -y`, generates `ENCRYPTION_KEY` in the project's `.env`. A manual setup must supply this key before starting: generate a 32-byte base64 value with `openssl rand -base64 32`. Keep the same key with the persistent database; replacing it makes previously encrypted secrets unreadable.
  130. Docs: [Getting started](https://lobu.ai/getting-started/) · [Agent workspace](https://lobu.ai/guides/agent-prompts/) · [Skills](https://lobu.ai/getting-started/skills/) · [Slack](https://lobu.ai/platforms/slack/)
  131. ### 3. Build with the CLI and TypeScript SDK
  132. The same governed data and operations are available without an agent:
  133. ```bash
  134. npx @lobu/cli@latest memory run # list the memory tools
  135. npx @lobu/cli@latest memory run search_memory '{"query":"onboarding"}'
  136. npx @lobu/cli@latest call run_sdk --arg title='List recent entities' \
  137. --arg script='export default async (_ctx, client) => client.entities.list({ limit: 5 })'
  138. ```
  139. Or from Node and TypeScript:
  140. ```ts
  141. import { client, searchMemory } from "@lobu/client";
  142. client.setConfig({
  143. baseUrl: "https://lobu.ai",
  144. headers: { Authorization: `Bearer ${process.env.LOBU_TOKEN}` },
  145. });
  146. const hits = await searchMemory({
  147. path: { orgSlug: "my-org" },
  148. body: { query: "onboarding" },
  149. });
  150. ```
  151. Mint a token with `lobu token create`. The MCP tools and typed SDK operations share the server-side tool registry and access rules; `lobu memory run` dispatches through the MCP endpoint, and `lobu call` through the REST tool route by default (MCP when `LOBU_API_TOKEN` and `LOBU_MEMORY_URL` are set). `lobu call run_sdk`, `query_sdk`, and `query_sql` require a `title` arg, which names the call in the activity feed.
  152. ## Core concepts
  153. ### Shared context
  154. [Connectors](https://lobu.ai/getting-started/author-a-connector/) collect activity on a schedule or through webhooks. Discussions, project changes, customer records, API events, and saved agent knowledge land in the same append-only history.
  155. Typed entities connect that history to the things you care about: `Company`, `Project`, `Customer`, `Incident`, or schemas you define. Corrections supersede old facts rather than erasing their provenance.
  156. Connectors are extensible. You can build them in TypeScript, and coding agents can use Lobu's connector contract and validation flow to create integrations for sources Lobu does not ship with.
  157. Docs: [Memory](https://lobu.ai/getting-started/memory/) · [Connectors](https://lobu.ai/getting-started/author-a-connector/) · [API](https://lobu.ai/reference/api-reference/)
  158. ### Persistent specialists
  159. A Lobu specialist has a stable role, instructions, memory, tools, and conversation history. It can be reached from web chat or Slack and called by external agents through `client.conversations.send`.
  160. Specialists use role files for identity and instructions: `IDENTITY.md`, `SOUL.md`, and `USER.md`. Guardrails can inspect input, output, and tool calls. Connector actions follow organization Auto, Ask, or Block rules in Settings → Policies; guardrails still apply under Auto, and action results return to the shared event log.
  161. External agents do not ask users to write delegation code. They pass scripts like these to Lobu's `query_sdk` and `run_sdk` MCP tools:
  162. Scripts must default-export an async function. Lobu passes the execution context as the first argument and the ClientSDK as the second; keep `await` and `return` inside that function. A bare top-level `await` or `return` fails compilation. The same function format works with `lobu call run_sdk --arg title='…' --arg script='…'`.
  163. ```ts
  164. // Discover specialists through query_sdk.
  165. export default async (_ctx, client) => {
  166. const { agents } = await client.agents.list();
  167. return agents;
  168. };
  169. ```
  170. ```ts
  171. // Delegate through run_sdk and wait for the specialist's reply.
  172. export default async (_ctx, client) => {
  173. return client.conversations.send({
  174. agent_id: "customer-researcher",
  175. thread: "enterprise-onboarding",
  176. text: "Review the latest customer feedback and propose the next three interviews.",
  177. });
  178. };
  179. ```
  180. Docs: [Agent workspace](https://lobu.ai/guides/agent-prompts/) · [Guardrails](https://lobu.ai/guides/guardrails/) · [Security](https://lobu.ai/guides/security/)
  181. ### Automations
  182. Automations are versioned background responsibilities activated manually, on a schedule, by a connector event, or by another Automation's durable output. They read governed sources, persist structured results, and can notify Slack, open a ticket, or start agent work while nobody is in chat.
  183. Collection and activation stay independent: connect a source once, keep its durable history useful to every authorized agent, then choose whether a responsibility should run on a schedule or immediately when a matching event arrives. Polling connectors, authenticated webhooks, and Automation outputs use their appropriate ingestion paths but converge on the same durable Automation run lifecycle. Initial syncs establish a baseline without flooding subscribers; repeated deliveries are deduplicated.
  184. See the [activation and chaining model](docs/AUTOMATIONS.md).
  185. ### Optional execution
  186. Shared context and delegation over MCP do not require Lobu to execute code for the calling agent. When a Lobu specialist needs a shell, the built-in runtime provides lightweight `just-bash` execution. Remote sandbox providers such as Vercel Sandbox can be connected for workloads that need stronger isolation or more compute.
  187. Which sandbox runs the code is a deployment choice. Lobu provides the shared context, permissions, and governance around it.
  188. ## Channels
  189. Lobu specialists can serve **Slack, Telegram, WhatsApp, Discord, Teams, Google Chat**, the web app, and a [REST API](https://lobu.ai/reference/api-reference/). Channel conversations remain separate while reading the same authorized organizational context.
  190. Setup: [Slack](https://lobu.ai/platforms/slack/) · [Telegram](https://lobu.ai/platforms/telegram/) · [Discord](https://lobu.ai/platforms/discord/) · [WhatsApp](https://lobu.ai/platforms/whatsapp/) · [Teams](https://lobu.ai/platforms/teams/) · [Google Chat](https://lobu.ai/platforms/google-chat/)
  191. ## How Lobu differs
  192. - **Agent frameworks** help developers implement an agent loop. Lobu gives agents and people a shared organizational state and a place to keep persistent specialists.
  193. - **Direct MCP integrations** expose tools from one provider. Lobu continuously builds durable, cross-source context that every authorized agent can reuse.
  194. - **Agent runtimes** host a particular agent. Lobu lets people keep using Claude Code, Codex, ChatGPT, or their own runtime and add Lobu only where shared context or delegation is useful.
  195. - **Workflow engines** encode a graph of predetermined steps. Lobu Automations handle durable triggers and background responsibilities, while agents decide how to complete open-ended work.
  196. ## Agent configuration
  197. Runtime configuration is managed through the web app or the same org-scoped REST API used by the CLI. Local `lobu.config.ts` projects support validation and repeatable apply workflows.
  198. ```bash
  199. npx @lobu/cli@latest login
  200. npx @lobu/cli@latest org set my-org
  201. npx @lobu/cli@latest agent list
  202. ```
  203. Docs: [CLI reference](https://lobu.ai/reference/cli/) · [`lobu apply`](https://lobu.ai/reference/cli/#apply)
  204. ## Deployment
  205. Use the embedded runtime locally or self-host Lobu with external Postgres. Production guides: [Docker](https://lobu.ai/deployment/docker/) · [Cloud](https://lobu.ai/deployment/cloud/) · [Kubernetes](https://lobu.ai/deployment/kubernetes/)
  206. ## Security and privacy
  207. Permissions and audit stay on Lobu's gateway. Lobu MCP servers and the credential-brokering layer handle provider and connector credentials, OAuth and token refresh, and third-party API proxying. Workers receive scoped placeholders or short-lived provider-derived access, never OAuth tokens or durable stored credentials. Connector actions follow organization approval policies, and connected data remains organization-scoped.
  208. The built-in `just-bash` and embedded execution modes are policy and convenience boundaries, not VMs for hostile code. Use a remote sandbox provider when the workload needs a stronger isolation boundary.
  209. Docs: [Security](https://lobu.ai/guides/security/) · [Secret proxy](https://lobu.ai/guides/secret-proxy/) · [Guardrails](https://lobu.ai/guides/guardrails/) · [Threat model](docs/SECURITY.md)
  210. ## Design partners
  211. We are working with technical teams that already use Claude Code, Codex, ChatGPT, or custom agents and want those agents to share company context or delegate to persistent specialists.
  212. The best starting point is one team, one or two connected sources, and one repeated responsibility. [Talk to the founder](https://lobu.ai/schedule/) or reach out on [X/Twitter](https://x.com/bu7emba).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.