Nine components. Built once. Shared by every app you own.

Data Model & Knowledge Graph

Every app declares its data model — entities, fields, relations — in one schema. From that you get the database, migrations, API, permissions and audit hooks. Change the model; the rest follows.

Shared entities resolve to one graph of your company — people, teams, stores, customers, policies — with a per-app view for each. Hire someone once; the scheduler, the wiki and the expense tool already know their store and their approver.

Agents write to it through a git-based memory interface: each learns in its own branch, and every change lands on main as a reviewed commit. When two agents disagree, the merge forces a decision — one source of truth per concept, with history.

• ■Declare the model once → DB, migrations, API, permissions, audit
• ■Compatible with Open Knowledge Format (OKF v0.2) — plain markdown any agent can read
• ■One graph, per-app views with per-app permissions
• ■Agents learn in branches; main is the single source of truth
• ■Conflicts are resolved at merge, never silently overwritten
• ■Every fact has a commit, an author and a diff — blame works on your company's memory

Agentic Loop & Harness

The loop is what each app's agent runs: observe how people use the app, learn the patterns, propose a change, ship it. The harness is what keeps that safe: evals before anything ships, a human in the approval seat, staged rollout, instant rollback, and a list of things the agent may never touch.

Start with approve-everything. When you trust it, let low-risk changes ship on their own. The journal records which mode was on for every change.

Scale, Deploy & Versioning

Every Generic SaaS is a versioned artifact. Deploys are staged by percentage, watched by Observability, and reversible with one click. Autoscaling is per app, so the planning-poker tool doesn't pay for the shift scheduler's Monday-morning spike.

• ■Immutable versions, signed builds
• ■Staged rollout 1% → 10% → 100%, auto-halt on error budget
• ■Rollback keeps the audit trail and the data migrations
• ■Per-app horizontal scaling and scale-to-zero

Observability & Incidents

Traces, logs and metrics are emitted by the SDK, not bolted on. Every app lands in the same dashboards. Incidents open themselves from error budgets, page the right on-call, halt any rollout in flight, and write the postmortem skeleton into the Journal.

• ■OpenTelemetry-native, no vendor agent
• ■SLOs per app, error budgets gate deploys
• ■On-call schedules, escalation, status page — built in
• ■The app's agent reads incidents too — and learns from them

Functions

A shared library of business functions every Generic SaaS can call: approvals routing, notifications, pricing, working-day math, document generation. Write the approval chain once; the expense tool, the time-off tool and the purchase-order tool all use the same one.

• ■Versioned, typed, callable from any app or agent
• ■Change a rule in one place, every app follows
• ■Every call is audited with its inputs

AI Inference Gateway

One endpoint every app and every agent talks to. Behind it, local open-weight models running on your hardware — so a prompt with your payroll data in it never leaves the building. Every call is logged to the audit trail with its inputs and outputs.

• ■Local / open-weight models, no third-party API required
• ■Works fully air-gapped
• ■Prompt and response logging into Audit & Journal
• ■Models curated and kept current in partnership with Agent Libre

Identity & Access

One login for every Generic SaaS, from the identity provider you already run. Roles are defined once and shared: "store manager" means the same thing in the shift scheduler, the NPS tool and the expense app. Agents get service accounts with the same scoping as people.

• ■SSO via SAML and OIDC
• ■SCIM provisioning — offboard once, gone everywhere
• ■Roles shared across all Generic SaaS
• ■Service accounts for agents, least-privilege by default

Audit Reporting & Journal Log

Every action by every person, agent and function, in one append-only journal. Who changed the shift, which model answered the prompt, which version was live at 14:02. Reports are queries over that journal — scheduled, exported, or handed to an auditor as-is.

• ■Same schema for all apps, agents and inference calls
• ■Tamper-evident, retention you set
• ■Reports as saved queries, scheduled to whoever needs them

Security & Compliance

The platform runs where your security team already has controls: your VPC, your KMS, your network policy. Secrets are rotated for every app automatically, egress is deny-by-default, and every policy check is a line in the journal. A code scanner watches every app and its dependencies continuously; when a CVE or zero-day lands, it patches, runs the evals, and ships through the normal staged rollout — usually before you've read the advisory.

• ■Secrets management and rotation per app
• ■Network egress deny-by-default; air-gapped mode
• ■Encryption with your keys, at rest and in transit
• ■Policy-as-code checks on every deploy
• ■Continuous code & dependency scanning across every app
• ■Auto-patch: CVE lands → patch → evals → staged rollout, journaled
• ■Zero-day response: affected apps isolated at the gateway until patched