Lobu

Lobu — Give every agent a live model of your world

Lobu is an open-source, event-sourced context layer for AI agents. Every tool call, data change, device signal, API event, and conversation becomes an event, linked to the entities and identities it belongs to — a person, a project, a customer, a home, a company. That gives agents a live, queryable model of your world instead of a transcript they forget when the session ends.

ChatGPT, Claude, Codex, and your own agents read and write that same permission-aware history and current context, whether you're wiring up your own accounts or an entire company's stack. When a responsibility should outlive one chat, any agent can discover and hand it to a persistent Lobu specialist over MCP.

Connect your tools once. Every agent resumes from the same live context.

WITHOUT LOBU                         WITH LOBU

Agent A -> Slack / GitHub / CRM Slack GitHub CRM DBs Devices Agent B -> Slack / GitHub / CRM \ | | | / Agent C -> Slack / GitHub / CRM +-----+-----+----+----+ | Each agent re-fetches. v Each session forgets. +-------------------+ | LOBU | | events + entities | | history + policy | +---------+---------+ | shared context +-----------------+-----------------+ | | | ChatGPT Claude / Codex Your agents

See it in ChatGPT

The 86-second muted demo shows ChatGPT using Lobu over MCP to pull connected context and call governed tools without leaving the conversation. The same shared context remains available to Claude, Codex, and custom agents.

https://github.com/user-attachments/assets/26e6329a-1bc6-4480-8e57-e9388e38dde9

Start with the agent you already use

Point any MCP client at Lobu. No Lobu agent runtime or lobu.config.ts is required.

# Claude Code

npx @lobu/cli@latest connect claude-code

Codex

npx @lobu/cli@latest connect codex

OpenCode

npx @lobu/cli@latest connect opencode

Complete OAuth when prompted, connect the sources you want to share, and ask your agent to use Lobu when it needs shared context.

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.

Setup guides: Claude · ChatGPT · Codex · Grok

Download Lobu: Mac app · Chrome extension

Upgrading a Mac install made before the ai.lobu.mac app identity? Install the

DMG by hand — the in-app updater does not carry an install across the bundle

identifier change. It replaces /Applications/Lobu.app in place; also delete

/Applications/Owletto.app if a pre-rename build is still there, since that one

sits at its own path. From 20.0.1 your settings and the app's device identity

carry across the rename, so device-pinned Automations keep running against the

same worker. Login Items and privacy grants cannot come with them — macOS keys

both to the bundle identifier — so the new app asks about Open at Login once and

re-prompts for each permission on first use.

To test changes merged to main, run bunx @lobu/cli@canary --help. The canary tag moves only when a maintainer runs Publish Packages from main in GitHub Actions with channel canary; that run requires the commit's CI and image checks and smokes the packed CLI before publishing. The published version is then exercised across the Linux runtime matrix, so check the run's result before depending on it. Use @latest for stable releases. Canary versions include the full commit SHA so you can pin a preview when reproducing a bug. Package managers can cache the moving tag: copy the exact version from the successful workflow run, use it in place of canary, and confirm the installed version with lobu --version.

Recall what the company knows

Ask from Claude Code, Codex, or ChatGPT:

What did we decide about enterprise onboarding, and what changed since the last release?

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.

Hand work to a persistent Lobu specialist

Ask your primary agent:

Ask our customer-researcher specialist to review the latest feedback and propose the next three interviews.

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.

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.

Why Lobu

Instead of every agent rebuilding the same state through per-session tool calls, Lobu runs a shared data layer:

• Connect once. Polls, webhooks, APIs, and agent-written connectors feed one append-only event log.
• Know once. Events can be indexed as searchable knowledge and linked to typed entities such as companies, projects, incidents, and customers.
• Use from any agent. Authorized MCP clients read and contribute to the same organizational state according to their grants.
• Delegate when useful. Persistent Lobu specialists can own a role, conversation history, tools, and recurring responsibilities.
• Keep control. Identity, source permissions, approvals, credential brokering, provenance, and audit stay server-side.

flowchart TD

Sources["Connectors / webhooks / devices / APIs"] --> Log[("append-only log")] Log -->|"resolve identities attach provenance"| Graph["context graph entities + links current + history"] Graph -->|"query"| Agents["agents + specialists"] Graph -->|"watch / subscribe"| Agents Agents -->|"sandbox + scoped tools / MCP policy + approvals"| Actions["actions on systems"] Actions -->|"action events"| Log

MCP is for doing. Lobu's event graph is for knowing.

One context layer, personal or company

The primitives don't change between a single person's accounts and an entire company's stack — only what's connected does. Identities, entities, events, history, and policy work the same way at either scope.

PERSONAL                               COMPANY

WhatsApp Gmail Calendar Mac Slack GitHub CRM DB \ | | / \ | | / +------+-------+-----+ +------+-----+---+ \ / +------- LOBU -------+ | identities | | entities + events | | history + policy | +---------+----------+ | shared agent context +------------+------------+ | | "When is Alice home?" "Why is Acme at risk?"

Three ways to use Lobu

1. Add shared context to existing agents

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.

Docs: Memory · Claude · ChatGPT · Codex

2. Run persistent Lobu specialists

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.

Scaffold and run one locally:

npx @lobu/cli@latest init my-specialist

cd my-specialist npx @lobu/cli@latest run npx @lobu/cli@latest chat -c local "hello"

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.

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 for the separate database and service configuration.

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.

Docs: Getting started · Agent workspace · Skills · Slack

3. Build with the CLI and TypeScript SDK

The same governed data and operations are available without an agent:

npx @lobu/cli@latest memory run                     # list the memory tools

npx @lobu/cli@latest memory run search_memory '{"query":"onboarding"}' npx @lobu/cli@latest call run_sdk --arg title='List recent entities' \ --arg script='export default async (_ctx, client) => client.entities.list({ limit: 5 })'

Or from Node and TypeScript:

import { client, searchMemory } from "@lobu/client";

client.setConfig({ baseUrl: "https://lobu.ai", headers: { Authorization: Bearer ${process.env.LOBU_TOKEN} }, });

const hits = await searchMemory({ path: { orgSlug: "my-org" }, body: { query: "onboarding" }, });

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.

Core concepts

Shared context

Connectors 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.

Typed entities connect that history to the things you care about: Company, Project, Customer, Incident, or schemas you defin