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
Redwood NDAcontract2d
Redwood Capitalcounterparty5h
No cap on confidentiality termrisk1h
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,
  secret,
} from "@lobu/cli/config";
import type DocuSignEnvelopesConnector from "./docusign-envelopes.connector.ts";

const legalReview = defineAgent({
  id: "legal-review",
  name: "legal-review",
  description:
    "Review contracts, summarize risk, and surface missing protections",
  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 contractReviewTracker = defineWatcher({
  agent: legalReview,
  slug: "contract-review-tracker",
  name: "Contract review tracker",
  schedule: "0 8 * * 1-5",
  notification: { priority: "high" },
  tags: ["legal", "contract", "daily"],
  minCooldownSeconds: 1800,
  reactionsGuidance:
    "For any contract with `status: needs_counsel`, route an entity-scoped event\nto the assigned reviewer. For contracts >90 days unsigned, escalate to the\ncounterparty owner; never auto-resolve risk items.\n",
  prompt:
    "Review active contracts for approaching deadlines, unsigned agreements, and unresolved risk items. Flag any clauses that still need counsel approval.\n",
  extractionSchema: {
    type: "object",
    required: [
      "pending_contracts",
      "unresolved_risks",
      "approaching_deadlines",
    ],
    properties: {
      pending_contracts: { type: "array", items: { type: "string" } },
      unresolved_risks: { type: "array", items: { type: "string" } },
      approaching_deadlines: { type: "array", items: { type: "string" } },
      flagged_clauses: { type: "array", items: { type: "string" } },
    },
  },
});

export default defineConfig({
  connectors: [
    connectorFromFile<typeof DocuSignEnvelopesConnector>(
      "./docusign-envelopes.connector.ts"
    ),
  ],
  org: "legal-review",
  orgName: "Legal",
  orgDescription:
    "Review contracts, summarize risk, and surface missing protections",
  agents: [legalReview],
  entities: [clause, contract, counterparty, risk],
  relationships: [belongsToCounterparty, containsClause, createsRisk],
  watchers: [contractReviewTracker],
});
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.