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
Sarah Chenmember2d
Relay Labscompany5h
Agent memory, evals, orchestrationfocus1h
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 DiscoursePostsConnector from "./discourse-posts.connector.ts";
import type opportunityMatcherReaction from "./opportunity-matcher.reaction.ts";

const agentCommunity = defineAgent({
  id: "agent-community",
  name: "agent-community",
  description:
    "Discover aligned members, explain why they should meet, and draft warm introductions",
  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 opportunityMatcher = defineWatcher({
  agent: agentCommunity,
  slug: "opportunity-matcher",
  name: "Opportunity matcher",
  schedule: "0 */12 * * *",
  notification: { priority: "normal" },
  tags: ["community", "matching"],
  minCooldownSeconds: 300,
  reaction: reactionFromFile<typeof opportunityMatcherReaction>(
    "./opportunity-matcher.reaction.ts"
  ),
  prompt:
    "Monitor connected profiles, newsletters, websites, and member updates for new launches, posts, hiring signals, funding news, and project changes. Identify which members are likely to care, explain why, and queue approved intro or outreach drafts.\n",
  extractionSchema: {
    type: "object",
    required: ["signals"],
    properties: {
      signals: {
        type: "array",
        items: {
          type: "object",
          properties: {
            type: { type: "string" },
            source: { type: "string" },
            related_topics: { type: "array", items: { type: "string" } },
            interested_members: { type: "array", items: { type: "string" } },
            reason: { type: "string" },
            suggested_action: { type: "string" },
          },
        },
      },
    },
  },
});

export default defineConfig({
  connectors: [
    connectorFromFile<typeof DiscoursePostsConnector>(
      "./discourse-posts.connector.ts"
    ),
  ],
  org: "agent-community",
  orgName: "Agent Community",
  orgDescription:
    "Discover aligned members, explain why they should meet, and draft warm introductions",
  agents: [agentCommunity],
  entities: [match, post, topic],
  relationships: [interestedIn, introducedTo, matchesWith, writesAbout],
  watchers: [opportunityMatcher],
});
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.