Overview

Eru is semantic scaffolding for enterprise AI — a live operational model of your company that humans and AI can query, reason over, and act on.

We're starting with RevOps. As Series A–D companies scale, they lose track of their own numbers. Real revenue, actual CAC, true LTV become unanswerable. Data fragments across CRM, ERP, payments, spreadsheets, data lake — each holding a piece of the truth. Three systems, three answers.

Eru integrates these systems, reconciles the data, and builds a knowledge graph showing how everything connects — customers to contracts to invoices to payments. When numbers conflict, we trace the root cause and surface the evidence. When something changes in Stripe, the graph updates.

How It Works

Eru operates as a continuous loop — discovering, mapping, checking, and alerting. The system runs in the background, progressively building understanding of your data landscape.

Quick Start

Get Eru running in your Slack workspace in under 10 minutes.

1. Install the Slack App

Add Eru to your workspace and invite it to a channel where your data team operates.

2. Connect Your First Source

Use the /connect command to add a database or API:

Eru will guide you through credential entry (stored in AWS Secrets Manager, never sent to LLMs).

3. Ask a Question

Once connected, start querying:

Eru will explore your data, build the relevant portion of the Truth Map, and return an answer with full evidence.

Truth Map

The Truth Map is a living knowledge graph of your company's data. It captures what exists, how it connects, and what it means.

Node Types

Edge Types

Confidence Scoring

Every node and edge has a confidence score from 0.0 to 1.0:

• > 0.8 — Verified (human-confirmed or high evidence)
• 0.5–0.8 — Inferred (strong signal but not confirmed)
• < 0.5 — Needs review

Confidence decays over time if not re-validated.

Truth Checks

Truth Checks are continuous contracts that monitor your data. When something drifts, you know immediately — with evidence.

Check Primitives

Evidence Packs

Every claim Eru makes is backed by an Evidence Pack — an immutable audit trail that proves the answer.

What's Included

• Exact query executed (with hash for reproducibility)
• Query results (sanitized samples)
• Schema snapshot at execution time
• SourceSpec version references
• Mapping versions used
• Statistical summaries (drop %, null rates, cardinality)

Retention Modes

• Metadata-only — Query hashes, counts, schema snapshots (no raw rows)
• Redacted samples — PII masked, capped rows/columns
• Full samples — Rare, explicit opt-in, short retention

System Design

Eru is built as a multi-service architecture optimized for safety, auditability, and progressive discovery.

┌─────────────────────────────────────────────────────────────────┐
│                         User (Slack)                            │
└─────────────────────────────┬───────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Slack Service (TypeScript)                   │
│         Events • Commands • Modals • App Home • Alerts          │
└─────────────────────────────┬───────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                     API Service (FastAPI)                       │
│        Auth • RBAC • Truth Map Store • Work Item Queue          │
└─────────────────────────────┬───────────────────────────────────┘
                              │
              ┌───────────────┴───────────────┐
              ▼                               ▼
┌─────────────────────────┐     ┌─────────────────────────────────┐
│     Agent (Claude)      │     │      Runtime (Sandboxed)        │
│  Plan • Reason • Tools  │────▶│  SQL • HTTP • Read-Only • Safe  │
└─────────────────────────┘     └─────────────────────────────────┘
              │                               │
              ▼                               ▼
┌─────────────────────────────────────────────────────────────────┐
│                    PostgreSQL + Redis + S3                      │
│        Truth Map • Work Items • Evidence Packs • Cache          │
└─────────────────────────────────────────────────────────────────┘
                    

Agent vs Runtime Split

This is the critical safety design. The Agent (brain) plans and reasons using Claude. The Runtime (rails) executes queries safely with hard limits.

Data Model

Eru uses PostgreSQL as the primary state store and workflow engine. No external orchestration — just row-level locking and state machines.

Core Tables

• tenants — Multi-tenant isolation
• sources — Connected systems and credentials
• truth_nodes — Graph nodes (Source, Entity, Metric, Dataset)
• truth_edges — Graph edges with versioning
• truth_checks — Continuous monitoring contracts
• work_items — DB-backed task queue with state machine
• evidence_packs — Audit trail metadata (content in S3)

Security

LLM Data Boundary

We're careful about what goes to Claude:

Budget Enforcement

Hard limits per tenant per day:

• API calls: 1,000/day per source
• SQL bytes scanned: 10 GB/day per source
• Runtime wall time: 30 min/day per source
• LLM tokens: 10K/hour, 100K/day
• Questions: 5/week

Database Integrations

Eru connects to databases using protocol-level adapters. No vendor-specific connectors.

Supported Databases

• PostgreSQL
• MySQL / MariaDB
• Snowflake
• BigQuery
• Redshift
• MongoDB (read-only queries)

Connection Security

• Credentials stored in AWS Secrets Manager
• Read-only database users recommended
• IP allowlisting available via NAT Gateway
• SSL/TLS required for all connections

API & SaaS Integrations

Eru connects to REST and GraphQL APIs using OAuth2 or API keys.

Common Integrations

• Stripe — Payments, subscriptions, invoices
• Salesforce — CRM, opportunities, accounts
• HubSpot — Contacts, deals, companies
• NetSuite — ERP, financials
• Zendesk — Tickets, customers
• Shopify — Orders, products, customers

Custom APIs

Eru can ingest OpenAPI specs, Postman collections, or internal documentation to learn your custom APIs before probing.

Slack Integration

Slack is the primary interface. Eru lives where your team already works.

Slash Commands

Notifications

Eru sends alerts when:

• A Truth Check fails
• Schema drift is detected
• Reconciliation conflicts are found
• Access approval is needed