Build proactive AI agents on a graph
that builds itself

Connect your company's data in real time, plug in your model, and let your agents act the moment something changes, as a bot, an API, or another agent.

Paste it into claude code, cursor, or opencode, and it scaffolds the project for you.

Or start it yourself:

Architecture

Raw events in. Typed memory out. Agents act.

Connectors stream events into memory. Watchers derive typed entities. Agents read it, talk to users, and act.

Connectors
stream events from any source
Memory
events
LLM watcher
entitiestable
nametypeupdated
4100account2d
$42kvariance5h
Delayed refundslikely cause1h
append-only knowledge graph
Agents
Chat bots
Other agents
HTTPMCPSDK
External services
reactions
reach users, or call from code
What ships

One typed file wires it together.

Pick a piece to see the code for this use case. Click again to hide.

lobu.config.tslobu.config.ts
import {
  connectorFromFile,
  defineAgent,
  defineConfig,
  defineEntityType,
  defineRelationshipType,
  defineWatcher,
  reactionFromFile,
  secret,
} from "@lobu/cli/config";
import type QuickBooksTransactionsConnector from "./quickbooks-transactions.connector.ts";
import type reconciliationMonitorReaction from "./reconciliation-monitor.reaction.ts";

const finance = defineAgent({
  id: "finance",
  name: "finance",
  description:
    "Help finance teams reconcile data, explain variance, and prepare reporting runs",
  dir: ".",
  providers: [
    {
      id: "anthropic",
      model: "claude/sonnet-4-5",
      key: secret("ANTHROPIC_API_KEY"),
    },
  ],
  network: {
    allowed: [
      "github.com",
      ".github.com",
      ".githubusercontent.com",
      "registry.npmjs.org",
      ".npmjs.org",
    ],
  },
});

// entity types and relationships defined here…

const reconciliationMonitor = defineWatcher({
  agent: finance,
  slug: "reconciliation-monitor",
  name: "Reconciliation monitor",
  schedule: "0 6 * * 1-5",
  notification: { priority: "high", channel: "both" },
  tags: ["finance", "reconciliation", "daily"],
  minCooldownSeconds: 3600,
  reaction: reactionFromFile<typeof reconciliationMonitorReaction>(
    "./reconciliation-monitor.reaction.ts"
  ),
  prompt:
    "Check accounts for unreconciled transactions, new variances, and approaching reporting deadlines. Lead with exceptions that need review.\n",
  extractionSchema: {
    type: "object",
    required: ["unreconciled_count", "new_variances", "approaching_deadlines"],
    properties: {
      unreconciled_count: { type: "integer" },
      new_variances: { type: "array", items: { type: "string" } },
      approaching_deadlines: { type: "array", items: { type: "string" } },
      payment_risks: { type: "array", items: { type: "string" } },
    },
  },
});

export default defineConfig({
  connectors: [
    connectorFromFile<typeof QuickBooksTransactionsConnector>(
      "./quickbooks-transactions.connector.ts"
    ),
  ],
  org: "finance",
  orgName: "Finance",
  orgDescription:
    "Help finance teams reconcile data, explain variance, and prepare reporting runs",
  agents: [finance],
  entities: [account, report, transaction, variance],
  relationships: [createsVariance, reconcilesTo, summarizedIn],
  watchers: [reconciliationMonitor],
});
Solutions

Pick a use case to see it end to end.

Each page walks through the connectors, memory shape, and watchers for one team — and ships as a working example you can lobu apply.

Run anywhere

Local, your cloud, or Lobu Cloud.

Same lobu.config.ts + *.connector.ts + agents/. One command to boot embedded; Docker + Helm for self-hosting; Lobu Cloud when you don't want to run it yourself.

Local

Embedded, single process.

Gateway, workers, memory, embeddings, all in one Node process. Postgres is the only external.

$ lobu run
 gateway   :8787
 worker    pid=<n>
 memory    N entities
 watchers  N armed
Self-host

Docker. Helm. Your cloud.

Helm chart and Dockerfiles in the repo (charts/lobu/, docker/app/). Run on GCP, AWS, Fly, Render, or bare metal.

# Kubernetes
$ helm install lobu ./charts/lobu

# Docker
$ docker build -f docker/app/Dockerfile .
Lobu Cloud

Managed runtime.

Same code, run by Lobu. Per-user isolation, secret proxy, automatic upgrades.

$ lobu apply
 org      <your-org>
 region   <your-region>
 agents   N deployed
 gateway  <your-org>.lobu.run

Build your first
multi-user agent.